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

• Show log

  Commit

• Hash : 2aa5286d
  Author :
  Date : 2021-10-12T17:05:48
  

  Add Entry Point name to validation errors
  
  Add gl/gles entry point names to validation error messages
  
  some special cases:
  1. Debug::insertPerfWarning() is invoked from multiple places,
  such as TextureVK, ContextVK,
  adding an extra entryPoint function parameter
  in these files will need
  extra investigations.
  I am passing the entryPoint name GLInvalid as a
  temp workaround.
  
  2.ErrorSet::hangleError() is invoked from multiple
  Context*.cpp files,
  adding an extra entryPoint function parameter
  in these files will need
  extra investigations.
  I am passing the entryPoint name GLInvalid as a
  temp workaround.
  
  3. Debug::insertMessage(), Debug::popGroup(), Debug::pushGroup()
  can be invoked from more than one GL entry points,
  e.g. Debug::pushGroup() can be invoked from
  either GL_APIENTRY GL_PushDebugGroup() or
  GL_APIENTRY GL_PushDebugGroupKHR()
  through context->pushDebugGroup() call.
  Right now the same entry point name glPushDebugGroup will
  be printed out in the error message for both cases.
  However, we should be able to tell the actual entry point
  by checking which version: KHR version or core version the
  application uses, and this helps avoid the confusion.
  For now we will let the same entry point name
  getting printed for both cases.
  
  Bug: angleproject:6523
  Change-Id: I64a5463d9168d8444d376d1f428c3b3d894f2ea9
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3215063
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Yuxin Hu <yuxinhu@google.com>
  

Download

• src/libANGLE/validationGL1.cpp

• //
  // Copyright 2019 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.
  //
  
  // validationGL1.cpp: Validation functions for OpenGL 1.0 entry point parameters
  
  #include "libANGLE/validationGL1_autogen.h"
  
  namespace gl
  {
  
  bool ValidateAccum(const Context *, angle::EntryPoint entryPoint, GLenum op, GLfloat value)
  {
      return true;
  }
  
  bool ValidateBegin(const Context *, angle::EntryPoint entryPoint, GLenum mode)
  {
      return true;
  }
  
  bool ValidateBitmap(const Context *,
                      angle::EntryPoint entryPoint,
                      GLsizei width,
                      GLsizei height,
                      GLfloat xorig,
                      GLfloat yorig,
                      GLfloat xmove,
                      GLfloat ymove,
                      const GLubyte *bitmap)
  {
      return true;
  }
  
  bool ValidateCallList(const Context *, angle::EntryPoint entryPoint, GLuint list)
  {
      return true;
  }
  
  bool ValidateCallLists(const Context *,
                         angle::EntryPoint entryPoint,
                         GLsizei n,
                         GLenum type,
                         const void *lists)
  {
      return true;
  }
  
  bool ValidateClearAccum(const Context *,
                          angle::EntryPoint entryPoint,
                          GLfloat red,
                          GLfloat green,
                          GLfloat blue,
                          GLfloat alpha)
  {
      return true;
  }
  
  bool ValidateClearDepth(const Context *, angle::EntryPoint entryPoint, GLdouble depth)
  {
      return true;
  }
  
  bool ValidateClearIndex(const Context *, angle::EntryPoint entryPoint, GLfloat c)
  {
      return true;
  }
  
  bool ValidateClipPlane(const Context *,
                         angle::EntryPoint entryPoint,
                         GLenum plane,
                         const GLdouble *equation)
  {
      return true;
  }
  
  bool ValidateColor3b(const Context *,
                       angle::EntryPoint entryPoint,
                       GLbyte red,
                       GLbyte green,
                       GLbyte blue)
  {
      return true;
  }
  
  bool ValidateColor3bv(const Context *, angle::EntryPoint entryPoint, const GLbyte *v)
  {
      return true;
  }
  
  bool ValidateColor3d(const Context *,
                       angle::EntryPoint entryPoint,
                       GLdouble red,
                       GLdouble green,
                       GLdouble blue)
  {
      return true;
  }
  
  bool ValidateColor3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateColor3f(const Context *,
                       angle::EntryPoint entryPoint,
                       GLfloat red,
                       GLfloat green,
                       GLfloat blue)
  {
      return true;
  }
  
  bool ValidateColor3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateColor3i(const Context *,
                       angle::EntryPoint entryPoint,
                       GLint red,
                       GLint green,
                       GLint blue)
  {
      return true;
  }
  
  bool ValidateColor3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateColor3s(const Context *,
                       angle::EntryPoint entryPoint,
                       GLshort red,
                       GLshort green,
                       GLshort blue)
  {
      return true;
  }
  
  bool ValidateColor3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateColor3ub(const Context *,
                        angle::EntryPoint entryPoint,
                        GLubyte red,
                        GLubyte green,
                        GLubyte blue)
  {
      return true;
  }
  
  bool ValidateColor3ubv(const Context *, angle::EntryPoint entryPoint, const GLubyte *v)
  {
      return true;
  }
  
  bool ValidateColor3ui(const Context *,
                        angle::EntryPoint entryPoint,
                        GLuint red,
                        GLuint green,
                        GLuint blue)
  {
      return true;
  }
  
  bool ValidateColor3uiv(const Context *, angle::EntryPoint entryPoint, const GLuint *v)
  {
      return true;
  }
  
  bool ValidateColor3us(const Context *,
                        angle::EntryPoint entryPoint,
                        GLushort red,
                        GLushort green,
                        GLushort blue)
  {
      return true;
  }
  
  bool ValidateColor3usv(const Context *, angle::EntryPoint entryPoint, const GLushort *v)
  {
      return true;
  }
  
  bool ValidateColor4b(const Context *,
                       angle::EntryPoint entryPoint,
                       GLbyte red,
                       GLbyte green,
                       GLbyte blue,
                       GLbyte alpha)
  {
      return true;
  }
  
  bool ValidateColor4bv(const Context *, angle::EntryPoint entryPoint, const GLbyte *v)
  {
      return true;
  }
  
  bool ValidateColor4d(const Context *,
                       angle::EntryPoint entryPoint,
                       GLdouble red,
                       GLdouble green,
                       GLdouble blue,
                       GLdouble alpha)
  {
      return true;
  }
  
  bool ValidateColor4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateColor4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateColor4i(const Context *,
                       angle::EntryPoint entryPoint,
                       GLint red,
                       GLint green,
                       GLint blue,
                       GLint alpha)
  {
      return true;
  }
  
  bool ValidateColor4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateColor4s(const Context *,
                       angle::EntryPoint entryPoint,
                       GLshort red,
                       GLshort green,
                       GLshort blue,
                       GLshort alpha)
  {
      return true;
  }
  
  bool ValidateColor4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateColor4ubv(const Context *, angle::EntryPoint entryPoint, const GLubyte *v)
  {
      return true;
  }
  
  bool ValidateColor4ui(const Context *,
                        angle::EntryPoint entryPoint,
                        GLuint red,
                        GLuint green,
                        GLuint blue,
                        GLuint alpha)
  {
      return true;
  }
  
  bool ValidateColor4uiv(const Context *, angle::EntryPoint entryPoint, const GLuint *v)
  {
      return true;
  }
  
  bool ValidateColor4us(const Context *,
                        angle::EntryPoint entryPoint,
                        GLushort red,
                        GLushort green,
                        GLushort blue,
                        GLushort alpha)
  {
      return true;
  }
  
  bool ValidateColor4usv(const Context *, angle::EntryPoint entryPoint, const GLushort *v)
  {
      return true;
  }
  
  bool ValidateColorMaterial(const Context *, angle::EntryPoint entryPoint, GLenum face, GLenum mode)
  {
      return true;
  }
  
  bool ValidateCopyPixels(const Context *,
                          angle::EntryPoint entryPoint,
                          GLint x,
                          GLint y,
                          GLsizei width,
                          GLsizei height,
                          GLenum type)
  {
      return true;
  }
  
  bool ValidateDeleteLists(const Context *, angle::EntryPoint entryPoint, GLuint list, GLsizei range)
  {
      return true;
  }
  
  bool ValidateDepthRange(const Context *, angle::EntryPoint entryPoint, GLdouble n, GLdouble f)
  {
      return true;
  }
  
  bool ValidateDrawBuffer(const Context *, angle::EntryPoint entryPoint, GLenum buf)
  {
      return true;
  }
  
  bool ValidateDrawPixels(const Context *,
                          angle::EntryPoint entryPoint,
                          GLsizei width,
                          GLsizei height,
                          GLenum format,
                          GLenum type,
                          const void *pixels)
  {
      return true;
  }
  
  bool ValidateEdgeFlag(const Context *, angle::EntryPoint entryPoint, GLboolean flag)
  {
      return true;
  }
  
  bool ValidateEdgeFlagv(const Context *, angle::EntryPoint entryPoint, const GLboolean *flag)
  {
      return true;
  }
  
  bool ValidateEnd(const Context *, angle::EntryPoint entryPoint)
  {
      return true;
  }
  
  bool ValidateEndList(const Context *, angle::EntryPoint entryPoint)
  {
      return true;
  }
  
  bool ValidateEvalCoord1d(const Context *, angle::EntryPoint entryPoint, GLdouble u)
  {
      return true;
  }
  
  bool ValidateEvalCoord1dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *u)
  {
      return true;
  }
  
  bool ValidateEvalCoord1f(const Context *, angle::EntryPoint entryPoint, GLfloat u)
  {
      return true;
  }
  
  bool ValidateEvalCoord1fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *u)
  {
      return true;
  }
  
  bool ValidateEvalCoord2d(const Context *, angle::EntryPoint entryPoint, GLdouble u, GLdouble v)
  {
      return true;
  }
  
  bool ValidateEvalCoord2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *u)
  {
      return true;
  }
  
  bool ValidateEvalCoord2f(const Context *, angle::EntryPoint entryPoint, GLfloat u, GLfloat v)
  {
      return true;
  }
  
  bool ValidateEvalCoord2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *u)
  {
      return true;
  }
  
  bool ValidateEvalMesh1(const Context *,
                         angle::EntryPoint entryPoint,
                         GLenum mode,
                         GLint i1,
                         GLint i2)
  {
      return true;
  }
  
  bool ValidateEvalMesh2(const Context *,
                         angle::EntryPoint entryPoint,
                         GLenum mode,
                         GLint i1,
                         GLint i2,
                         GLint j1,
                         GLint j2)
  {
      return true;
  }
  
  bool ValidateEvalPoint1(const Context *, angle::EntryPoint entryPoint, GLint i)
  {
      return true;
  }
  
  bool ValidateEvalPoint2(const Context *, angle::EntryPoint entryPoint, GLint i, GLint j)
  {
      return true;
  }
  
  bool ValidateFeedbackBuffer(const Context *,
                              angle::EntryPoint entryPoint,
                              GLsizei size,
                              GLenum type,
                              const GLfloat *buffer)
  {
      return true;
  }
  
  bool ValidateFogi(const Context *, angle::EntryPoint entryPoint, GLenum pname, GLint param)
  {
      return true;
  }
  
  bool ValidateFogiv(const Context *, angle::EntryPoint entryPoint, GLenum pname, const GLint *params)
  {
      return true;
  }
  
  bool ValidateFrustum(const Context *,
                       angle::EntryPoint entryPoint,
                       GLdouble left,
                       GLdouble right,
                       GLdouble bottom,
                       GLdouble top,
                       GLdouble zNear,
                       GLdouble zFar)
  {
      return true;
  }
  
  bool ValidateGenLists(const Context *, angle::EntryPoint entryPoint, GLsizei range)
  {
      return true;
  }
  
  bool ValidateGetClipPlane(const Context *,
                            angle::EntryPoint entryPoint,
                            GLenum plane,
                            const GLdouble *equation)
  {
      return true;
  }
  
  bool ValidateGetDoublev(const Context *,
                          angle::EntryPoint entryPoint,
                          GLenum pname,
                          const GLdouble *data)
  {
      return true;
  }
  
  bool ValidateGetLightiv(const Context *,
                          angle::EntryPoint entryPoint,
                          GLenum light,
                          GLenum pname,
                          const GLint *params)
  {
      return true;
  }
  
  bool ValidateGetMapdv(const Context *,
                        angle::EntryPoint entryPoint,
                        GLenum target,
                        GLenum query,
                        const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateGetMapfv(const Context *,
                        angle::EntryPoint entryPoint,
                        GLenum target,
                        GLenum query,
                        const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateGetMapiv(const Context *,
                        angle::EntryPoint entryPoint,
                        GLenum target,
                        GLenum query,
                        const GLint *v)
  {
      return true;
  }
  
  bool ValidateGetMaterialiv(const Context *,
                             angle::EntryPoint entryPoint,
                             GLenum face,
                             GLenum pname,
                             const GLint *params)
  {
      return true;
  }
  
  bool ValidateGetPixelMapfv(const Context *,
                             angle::EntryPoint entryPoint,
                             GLenum map,
                             const GLfloat *values)
  {
      return true;
  }
  
  bool ValidateGetPixelMapuiv(const Context *,
                              angle::EntryPoint entryPoint,
                              GLenum map,
                              const GLuint *values)
  {
      return true;
  }
  
  bool ValidateGetPixelMapusv(const Context *,
                              angle::EntryPoint entryPoint,
                              GLenum map,
                              const GLushort *values)
  {
      return true;
  }
  
  bool ValidateGetPolygonStipple(const Context *, angle::EntryPoint entryPoint, const GLubyte *mask)
  {
      return true;
  }
  
  bool ValidateGetTexGendv(const Context *,
                           angle::EntryPoint entryPoint,
                           GLenum coord,
                           GLenum pname,
                           const GLdouble *params)
  {
      return true;
  }
  
  bool ValidateGetTexGenfv(const Context *,
                           angle::EntryPoint entryPoint,
                           GLenum coord,
                           GLenum pname,
                           const GLfloat *params)
  {
      return true;
  }
  
  bool ValidateGetTexGeniv(const Context *,
                           angle::EntryPoint entryPoint,
                           GLenum coord,
                           GLenum pname,
                           const GLint *params)
  {
      return true;
  }
  
  bool ValidateGetTexImage(const Context *,
                           angle::EntryPoint entryPoint,
                           TextureTarget target,
                           GLint level,
                           GLenum format,
                           GLenum type,
                           const void *pixels)
  {
      return true;
  }
  
  bool ValidateIndexMask(const Context *, angle::EntryPoint entryPoint, GLuint mask)
  {
      return true;
  }
  
  bool ValidateIndexd(const Context *, angle::EntryPoint entryPoint, GLdouble c)
  {
      return true;
  }
  
  bool ValidateIndexdv(const Context *, angle::EntryPoint entryPoint, const GLdouble *c)
  {
      return true;
  }
  
  bool ValidateIndexf(const Context *, angle::EntryPoint entryPoint, GLfloat c)
  {
      return true;
  }
  
  bool ValidateIndexfv(const Context *, angle::EntryPoint entryPoint, const GLfloat *c)
  {
      return true;
  }
  
  bool ValidateIndexi(const Context *, angle::EntryPoint entryPoint, GLint c)
  {
      return true;
  }
  
  bool ValidateIndexiv(const Context *, angle::EntryPoint entryPoint, const GLint *c)
  {
      return true;
  }
  
  bool ValidateIndexs(const Context *, angle::EntryPoint entryPoint, GLshort c)
  {
      return true;
  }
  
  bool ValidateIndexsv(const Context *, angle::EntryPoint entryPoint, const GLshort *c)
  {
      return true;
  }
  
  bool ValidateInitNames(const Context *, angle::EntryPoint entryPoint)
  {
      return true;
  }
  
  bool ValidateIsList(const Context *, angle::EntryPoint entryPoint, GLuint list)
  {
      return true;
  }
  
  bool ValidateLightModeli(const Context *, angle::EntryPoint entryPoint, GLenum pname, GLint param)
  {
      return true;
  }
  
  bool ValidateLightModeliv(const Context *,
                            angle::EntryPoint entryPoint,
                            GLenum pname,
                            const GLint *params)
  {
      return true;
  }
  
  bool ValidateLighti(const Context *,
                      angle::EntryPoint entryPoint,
                      GLenum light,
                      GLenum pname,
                      GLint param)
  {
      return true;
  }
  
  bool ValidateLightiv(const Context *,
                       angle::EntryPoint entryPoint,
                       GLenum light,
                       GLenum pname,
                       const GLint *params)
  {
      return true;
  }
  
  bool ValidateLineStipple(const Context *,
                           angle::EntryPoint entryPoint,
                           GLint factor,
                           GLushort pattern)
  {
      return true;
  }
  
  bool ValidateListBase(const Context *, angle::EntryPoint entryPoint, GLuint base)
  {
      return true;
  }
  
  bool ValidateLoadMatrixd(const Context *, angle::EntryPoint entryPoint, const GLdouble *m)
  {
      return true;
  }
  
  bool ValidateLoadName(const Context *, angle::EntryPoint entryPoint, GLuint name)
  {
      return true;
  }
  
  bool ValidateMap1d(const Context *,
                     angle::EntryPoint entryPoint,
                     GLenum target,
                     GLdouble u1,
                     GLdouble u2,
                     GLint stride,
                     GLint order,
                     const GLdouble *points)
  {
      return true;
  }
  
  bool ValidateMap1f(const Context *,
                     angle::EntryPoint entryPoint,
                     GLenum target,
                     GLfloat u1,
                     GLfloat u2,
                     GLint stride,
                     GLint order,
                     const GLfloat *points)
  {
      return true;
  }
  
  bool ValidateMap2d(const Context *,
                     angle::EntryPoint entryPoint,
                     GLenum target,
                     GLdouble u1,
                     GLdouble u2,
                     GLint ustride,
                     GLint uorder,
                     GLdouble v1,
                     GLdouble v2,
                     GLint vstride,
                     GLint vorder,
                     const GLdouble *points)
  {
      return true;
  }
  
  bool ValidateMap2f(const Context *,
                     angle::EntryPoint entryPoint,
                     GLenum target,
                     GLfloat u1,
                     GLfloat u2,
                     GLint ustride,
                     GLint uorder,
                     GLfloat v1,
                     GLfloat v2,
                     GLint vstride,
                     GLint vorder,
                     const GLfloat *points)
  {
      return true;
  }
  
  bool ValidateMapGrid1d(const Context *,
                         angle::EntryPoint entryPoint,
                         GLint un,
                         GLdouble u1,
                         GLdouble u2)
  {
      return true;
  }
  
  bool ValidateMapGrid1f(const Context *,
                         angle::EntryPoint entryPoint,
                         GLint un,
                         GLfloat u1,
                         GLfloat u2)
  {
      return true;
  }
  
  bool ValidateMapGrid2d(const Context *,
                         angle::EntryPoint entryPoint,
                         GLint un,
                         GLdouble u1,
                         GLdouble u2,
                         GLint vn,
                         GLdouble v1,
                         GLdouble v2)
  {
      return true;
  }
  
  bool ValidateMapGrid2f(const Context *,
                         angle::EntryPoint entryPoint,
                         GLint un,
                         GLfloat u1,
                         GLfloat u2,
                         GLint vn,
                         GLfloat v1,
                         GLfloat v2)
  {
      return true;
  }
  
  bool ValidateMateriali(const Context *,
                         angle::EntryPoint entryPoint,
                         GLenum face,
                         GLenum pname,
                         GLint param)
  {
      return true;
  }
  
  bool ValidateMaterialiv(const Context *,
                          angle::EntryPoint entryPoint,
                          GLenum face,
                          GLenum pname,
                          const GLint *params)
  {
      return true;
  }
  
  bool ValidateMultMatrixd(const Context *, angle::EntryPoint entryPoint, const GLdouble *m)
  {
      return true;
  }
  
  bool ValidateNewList(const Context *, angle::EntryPoint entryPoint, GLuint list, GLenum mode)
  {
      return true;
  }
  
  bool ValidateNormal3b(const Context *,
                        angle::EntryPoint entryPoint,
                        GLbyte nx,
                        GLbyte ny,
                        GLbyte nz)
  {
      return true;
  }
  
  bool ValidateNormal3bv(const Context *, angle::EntryPoint entryPoint, const GLbyte *v)
  {
      return true;
  }
  
  bool ValidateNormal3d(const Context *,
                        angle::EntryPoint entryPoint,
                        GLdouble nx,
                        GLdouble ny,
                        GLdouble nz)
  {
      return true;
  }
  
  bool ValidateNormal3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateNormal3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateNormal3i(const Context *, angle::EntryPoint entryPoint, GLint nx, GLint ny, GLint nz)
  {
      return true;
  }
  
  bool ValidateNormal3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateNormal3s(const Context *,
                        angle::EntryPoint entryPoint,
                        GLshort nx,
                        GLshort ny,
                        GLshort nz)
  {
      return true;
  }
  
  bool ValidateNormal3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateOrtho(const Context *,
                     angle::EntryPoint entryPoint,
                     GLdouble left,
                     GLdouble right,
                     GLdouble bottom,
                     GLdouble top,
                     GLdouble zNear,
                     GLdouble zFar)
  {
      return true;
  }
  
  bool ValidatePassThrough(const Context *, angle::EntryPoint entryPoint, GLfloat token)
  {
      return true;
  }
  
  bool ValidatePixelMapfv(const Context *,
                          angle::EntryPoint entryPoint,
                          GLenum map,
                          GLsizei mapsize,
                          const GLfloat *values)
  {
      return true;
  }
  
  bool ValidatePixelMapuiv(const Context *,
                           angle::EntryPoint entryPoint,
                           GLenum map,
                           GLsizei mapsize,
                           const GLuint *values)
  {
      return true;
  }
  
  bool ValidatePixelMapusv(const Context *,
                           angle::EntryPoint entryPoint,
                           GLenum map,
                           GLsizei mapsize,
                           const GLushort *values)
  {
      return true;
  }
  
  bool ValidatePixelStoref(const Context *, angle::EntryPoint entryPoint, GLenum pname, GLfloat param)
  {
      return true;
  }
  
  bool ValidatePixelTransferf(const Context *,
                              angle::EntryPoint entryPoint,
                              GLenum pname,
                              GLfloat param)
  {
      return true;
  }
  
  bool ValidatePixelTransferi(const Context *,
                              angle::EntryPoint entryPoint,
                              GLenum pname,
                              GLint param)
  {
      return true;
  }
  
  bool ValidatePixelZoom(const Context *,
                         angle::EntryPoint entryPoint,
                         GLfloat xfactor,
                         GLfloat yfactor)
  {
      return true;
  }
  
  bool ValidatePolygonMode(const Context *, angle::EntryPoint entryPoint, GLenum face, GLenum mode)
  {
      return true;
  }
  
  bool ValidatePolygonStipple(const Context *, angle::EntryPoint entryPoint, const GLubyte *mask)
  {
      return true;
  }
  
  bool ValidatePopAttrib(const Context *, angle::EntryPoint entryPoint)
  {
      return true;
  }
  
  bool ValidatePopName(const Context *, angle::EntryPoint entryPoint)
  {
      return true;
  }
  
  bool ValidatePushAttrib(const Context *, angle::EntryPoint entryPoint, GLbitfield mask)
  {
      return true;
  }
  
  bool ValidatePushName(const Context *, angle::EntryPoint entryPoint, GLuint name)
  {
      return true;
  }
  
  bool ValidateRasterPos2d(const Context *, angle::EntryPoint entryPoint, GLdouble x, GLdouble y)
  {
      return true;
  }
  
  bool ValidateRasterPos2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateRasterPos2f(const Context *, angle::EntryPoint entryPoint, GLfloat x, GLfloat y)
  {
      return true;
  }
  
  bool ValidateRasterPos2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateRasterPos2i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y)
  {
      return true;
  }
  
  bool ValidateRasterPos2iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateRasterPos2s(const Context *, angle::EntryPoint entryPoint, GLshort x, GLshort y)
  {
      return true;
  }
  
  bool ValidateRasterPos2sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateRasterPos3d(const Context *,
                           angle::EntryPoint entryPoint,
                           GLdouble x,
                           GLdouble y,
                           GLdouble z)
  {
      return true;
  }
  
  bool ValidateRasterPos3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateRasterPos3f(const Context *,
                           angle::EntryPoint entryPoint,
                           GLfloat x,
                           GLfloat y,
                           GLfloat z)
  {
      return true;
  }
  
  bool ValidateRasterPos3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateRasterPos3i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y, GLint z)
  {
      return true;
  }
  
  bool ValidateRasterPos3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateRasterPos3s(const Context *,
                           angle::EntryPoint entryPoint,
                           GLshort x,
                           GLshort y,
                           GLshort z)
  {
      return true;
  }
  
  bool ValidateRasterPos3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateRasterPos4d(const Context *,
                           angle::EntryPoint entryPoint,
                           GLdouble x,
                           GLdouble y,
                           GLdouble z,
                           GLdouble w)
  {
      return true;
  }
  
  bool ValidateRasterPos4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateRasterPos4f(const Context *,
                           angle::EntryPoint entryPoint,
                           GLfloat x,
                           GLfloat y,
                           GLfloat z,
                           GLfloat w)
  {
      return true;
  }
  
  bool ValidateRasterPos4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateRasterPos4i(const Context *,
                           angle::EntryPoint entryPoint,
                           GLint x,
                           GLint y,
                           GLint z,
                           GLint w)
  {
      return true;
  }
  
  bool ValidateRasterPos4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateRasterPos4s(const Context *,
                           angle::EntryPoint entryPoint,
                           GLshort x,
                           GLshort y,
                           GLshort z,
                           GLshort w)
  {
      return true;
  }
  
  bool ValidateRasterPos4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateRectd(const Context *,
                     angle::EntryPoint entryPoint,
                     GLdouble x1,
                     GLdouble y1,
                     GLdouble x2,
                     GLdouble y2)
  {
      return true;
  }
  
  bool ValidateRectdv(const Context *,
                      angle::EntryPoint entryPoint,
                      const GLdouble *v1,
                      const GLdouble *v2)
  {
      return true;
  }
  
  bool ValidateRectf(const Context *,
                     angle::EntryPoint entryPoint,
                     GLfloat x1,
                     GLfloat y1,
                     GLfloat x2,
                     GLfloat y2)
  {
      return true;
  }
  
  bool ValidateRectfv(const Context *,
                      angle::EntryPoint entryPoint,
                      const GLfloat *v1,
                      const GLfloat *v2)
  {
      return true;
  }
  
  bool ValidateRecti(const Context *,
                     angle::EntryPoint entryPoint,
                     GLint x1,
                     GLint y1,
                     GLint x2,
                     GLint y2)
  {
      return true;
  }
  
  bool ValidateRectiv(const Context *, angle::EntryPoint entryPoint, const GLint *v1, const GLint *v2)
  {
      return true;
  }
  
  bool ValidateRects(const Context *,
                     angle::EntryPoint entryPoint,
                     GLshort x1,
                     GLshort y1,
                     GLshort x2,
                     GLshort y2)
  {
      return true;
  }
  
  bool ValidateRectsv(const Context *,
                      angle::EntryPoint entryPoint,
                      const GLshort *v1,
                      const GLshort *v2)
  {
      return true;
  }
  
  bool ValidateRenderMode(const Context *, angle::EntryPoint entryPoint, GLenum mode)
  {
      return true;
  }
  
  bool ValidateRotated(const Context *,
                       angle::EntryPoint entryPoint,
                       GLdouble angle,
                       GLdouble x,
                       GLdouble y,
                       GLdouble z)
  {
      return true;
  }
  
  bool ValidateScaled(const Context *,
                      angle::EntryPoint entryPoint,
                      GLdouble x,
                      GLdouble y,
                      GLdouble z)
  {
      return true;
  }
  
  bool ValidateSelectBuffer(const Context *,
                            angle::EntryPoint entryPoint,
                            GLsizei size,
                            const GLuint *buffer)
  {
      return true;
  }
  
  bool ValidateTexCoord1d(const Context *, angle::EntryPoint entryPoint, GLdouble s)
  {
      return true;
  }
  
  bool ValidateTexCoord1dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateTexCoord1f(const Context *, angle::EntryPoint entryPoint, GLfloat s)
  {
      return true;
  }
  
  bool ValidateTexCoord1fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateTexCoord1i(const Context *, angle::EntryPoint entryPoint, GLint s)
  {
      return true;
  }
  
  bool ValidateTexCoord1iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateTexCoord1s(const Context *, angle::EntryPoint entryPoint, GLshort s)
  {
      return true;
  }
  
  bool ValidateTexCoord1sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateTexCoord2d(const Context *, angle::EntryPoint entryPoint, GLdouble s, GLdouble t)
  {
      return true;
  }
  
  bool ValidateTexCoord2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateTexCoord2f(const Context *, angle::EntryPoint entryPoint, GLfloat s, GLfloat t)
  {
      return true;
  }
  
  bool ValidateTexCoord2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateTexCoord2i(const Context *, angle::EntryPoint entryPoint, GLint s, GLint t)
  {
      return true;
  }
  
  bool ValidateTexCoord2iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateTexCoord2s(const Context *, angle::EntryPoint entryPoint, GLshort s, GLshort t)
  {
      return true;
  }
  
  bool ValidateTexCoord2sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateTexCoord3d(const Context *,
                          angle::EntryPoint entryPoint,
                          GLdouble s,
                          GLdouble t,
                          GLdouble r)
  {
      return true;
  }
  
  bool ValidateTexCoord3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateTexCoord3f(const Context *,
                          angle::EntryPoint entryPoint,
                          GLfloat s,
                          GLfloat t,
                          GLfloat r)
  {
      return true;
  }
  
  bool ValidateTexCoord3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateTexCoord3i(const Context *, angle::EntryPoint entryPoint, GLint s, GLint t, GLint r)
  {
      return true;
  }
  
  bool ValidateTexCoord3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateTexCoord3s(const Context *,
                          angle::EntryPoint entryPoint,
                          GLshort s,
                          GLshort t,
                          GLshort r)
  {
      return true;
  }
  
  bool ValidateTexCoord3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateTexCoord4d(const Context *,
                          angle::EntryPoint entryPoint,
                          GLdouble s,
                          GLdouble t,
                          GLdouble r,
                          GLdouble q)
  {
      return true;
  }
  
  bool ValidateTexCoord4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateTexCoord4f(const Context *,
                          angle::EntryPoint entryPoint,
                          GLfloat s,
                          GLfloat t,
                          GLfloat r,
                          GLfloat q)
  {
      return true;
  }
  
  bool ValidateTexCoord4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateTexCoord4i(const Context *,
                          angle::EntryPoint entryPoint,
                          GLint s,
                          GLint t,
                          GLint r,
                          GLint q)
  {
      return true;
  }
  
  bool ValidateTexCoord4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateTexCoord4s(const Context *,
                          angle::EntryPoint entryPoint,
                          GLshort s,
                          GLshort t,
                          GLshort r,
                          GLshort q)
  {
      return true;
  }
  
  bool ValidateTexCoord4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateTexGend(const Context *,
                       angle::EntryPoint entryPoint,
                       GLenum coord,
                       GLenum pname,
                       GLdouble param)
  {
      return true;
  }
  
  bool ValidateTexGendv(const Context *,
                        angle::EntryPoint entryPoint,
                        GLenum coord,
                        GLenum pname,
                        const GLdouble *params)
  {
      return true;
  }
  
  bool ValidateTexGenf(const Context *,
                       angle::EntryPoint entryPoint,
                       GLenum coord,
                       GLenum pname,
                       GLfloat param)
  {
      return true;
  }
  bool ValidateTexGenfv(const Context *,
                        angle::EntryPoint entryPoint,
                        GLenum coord,
                        GLenum pname,
                        const GLfloat *params)
  {
      return true;
  }
  
  bool ValidateTexGeni(const Context *,
                       angle::EntryPoint entryPoint,
                       GLenum coord,
                       GLenum pname,
                       GLint param)
  {
      return true;
  }
  
  bool ValidateTexGeniv(const Context *,
                        angle::EntryPoint entryPoint,
                        GLenum coord,
                        GLenum pname,
                        const GLint *params)
  {
      return true;
  }
  
  bool ValidateTexImage1D(const Context *,
                          angle::EntryPoint entryPoint,
                          GLenum target,
                          GLint level,
                          GLint internalformat,
                          GLsizei width,
                          GLint border,
                          GLenum format,
                          GLenum type,
                          const void *pixels)
  {
      return true;
  }
  
  bool ValidateTranslated(const Context *,
                          angle::EntryPoint entryPoint,
                          GLdouble x,
                          GLdouble y,
                          GLdouble z)
  {
      return true;
  }
  
  bool ValidateVertex2d(const Context *, angle::EntryPoint entryPoint, GLdouble x, GLdouble y)
  {
      return true;
  }
  
  bool ValidateVertex2dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateVertex2f(const Context *, angle::EntryPoint entryPoint, GLfloat x, GLfloat y)
  {
      return true;
  }
  
  bool ValidateVertex2fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateVertex2i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y)
  {
      return true;
  }
  
  bool ValidateVertex2iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateVertex2s(const Context *, angle::EntryPoint entryPoint, GLshort x, GLshort y)
  {
      return true;
  }
  
  bool ValidateVertex2sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateVertex3d(const Context *,
                        angle::EntryPoint entryPoint,
                        GLdouble x,
                        GLdouble y,
                        GLdouble z)
  {
      return true;
  }
  
  bool ValidateVertex3dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateVertex3f(const Context *,
                        angle::EntryPoint entryPoint,
                        GLfloat x,
                        GLfloat y,
                        GLfloat z)
  {
      return true;
  }
  
  bool ValidateVertex3fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateVertex3i(const Context *, angle::EntryPoint entryPoint, GLint x, GLint y, GLint z)
  {
      return true;
  }
  
  bool ValidateVertex3iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateVertex3s(const Context *,
                        angle::EntryPoint entryPoint,
                        GLshort x,
                        GLshort y,
                        GLshort z)
  {
      return true;
  }
  
  bool ValidateVertex3sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateVertex4d(const Context *,
                        angle::EntryPoint entryPoint,
                        GLdouble x,
                        GLdouble y,
                        GLdouble z,
                        GLdouble w)
  {
      return true;
  }
  
  bool ValidateVertex4dv(const Context *, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateVertex4f(const Context *,
                        angle::EntryPoint entryPoint,
                        GLfloat x,
                        GLfloat y,
                        GLfloat z,
                        GLfloat w)
  {
      return true;
  }
  
  bool ValidateVertex4fv(const Context *, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateVertex4i(const Context *,
                        angle::EntryPoint entryPoint,
                        GLint x,
                        GLint y,
                        GLint z,
                        GLint w)
  {
      return true;
  }
  
  bool ValidateVertex4iv(const Context *, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateVertex4s(const Context *,
                        angle::EntryPoint entryPoint,
                        GLshort x,
                        GLshort y,
                        GLshort z,
                        GLshort w)
  {
      return true;
  }
  
  bool ValidateVertex4sv(const Context *, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateAreTexturesResident(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLsizei n,
                                   const GLuint *textures,
                                   const GLboolean *residences)
  {
      return true;
  }
  
  bool ValidateArrayElement(const Context *context, angle::EntryPoint entryPoint, GLint i)
  {
      return true;
  }
  
  bool ValidateCopyTexImage1D(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLenum target,
                              GLint level,
                              GLenum internalformat,
                              GLint x,
                              GLint y,
                              GLsizei width,
                              GLint border)
  {
      return true;
  }
  
  bool ValidateCopyTexSubImage1D(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLint x,
                                 GLint y,
                                 GLsizei width)
  {
      return true;
  }
  
  bool ValidateEdgeFlagPointer(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLsizei stride,
                               const void *pointer)
  {
      return true;
  }
  
  bool ValidateIndexPointer(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLenum type,
                            GLsizei stride,
                            const void *pointer)
  {
      return true;
  }
  
  bool ValidateIndexub(const Context *context, angle::EntryPoint entryPoint, GLubyte c)
  {
      return true;
  }
  
  bool ValidateIndexubv(const Context *context, angle::EntryPoint entryPoint, const GLubyte *c)
  {
      return true;
  }
  
  bool ValidateInterleavedArrays(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLenum format,
                                 GLsizei stride,
                                 const void *pointer)
  {
      return true;
  }
  
  bool ValidatePopClientAttrib(const Context *context, angle::EntryPoint entryPoint)
  {
      return true;
  }
  
  bool ValidatePrioritizeTextures(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLsizei n,
                                  const GLuint *textures,
                                  const GLfloat *priorities)
  {
      return true;
  }
  
  bool ValidatePushClientAttrib(const Context *context, angle::EntryPoint entryPoint, GLbitfield mask)
  {
      return true;
  }
  
  bool ValidateTexSubImage1D(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLenum target,
                             GLint level,
                             GLint xoffset,
                             GLsizei width,
                             GLenum format,
                             GLenum type,
                             const void *pixels)
  {
      return true;
  }
  
  bool ValidateCompressedTexImage1D(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLenum target,
                                    GLint level,
                                    GLenum internalformat,
                                    GLsizei width,
                                    GLint border,
                                    GLsizei imageSize,
                                    const void *data)
  {
      return true;
  }
  
  bool ValidateCompressedTexSubImage1D(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       GLenum target,
                                       GLint level,
                                       GLint xoffset,
                                       GLsizei width,
                                       GLenum format,
                                       GLsizei imageSize,
                                       const void *data)
  {
      return true;
  }
  
  bool ValidateGetCompressedTexImage(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     TextureTarget targetPacked,
                                     GLint level,
                                     const void *img)
  {
      return true;
  }
  
  bool ValidateLoadTransposeMatrixd(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    const GLdouble *m)
  {
      return true;
  }
  
  bool ValidateLoadTransposeMatrixf(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    const GLfloat *m)
  {
      return true;
  }
  
  bool ValidateMultTransposeMatrixd(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    const GLdouble *m)
  {
      return true;
  }
  
  bool ValidateMultTransposeMatrixf(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    const GLfloat *m)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1d(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLdouble s)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1dv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1f(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLfloat s)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1i(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLint s)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1iv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLint *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1s(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLshort s)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord1sv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLshort *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2d(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLdouble s,
                               GLdouble t)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2dv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2f(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLfloat s,
                               GLfloat t)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2i(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLint s,
                               GLint t)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2iv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLint *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2s(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLshort s,
                               GLshort t)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord2sv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLshort *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3d(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLdouble s,
                               GLdouble t,
                               GLdouble r)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3dv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3f(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLfloat s,
                               GLfloat t,
                               GLfloat r)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3i(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLint s,
                               GLint t,
                               GLint r)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3iv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLint *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3s(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLshort s,
                               GLshort t,
                               GLshort r)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord3sv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLshort *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord4d(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLdouble s,
                               GLdouble t,
                               GLdouble r,
                               GLdouble q)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord4dv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord4fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord4i(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLint s,
                               GLint t,
                               GLint r,
                               GLint q)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord4iv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLint *v)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord4s(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum target,
                               GLshort s,
                               GLshort t,
                               GLshort r,
                               GLshort q)
  {
      return true;
  }
  
  bool ValidateMultiTexCoord4sv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                const GLshort *v)
  {
      return true;
  }
  
  bool ValidateFogCoordPointer(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum type,
                               GLsizei stride,
                               const void *pointer)
  {
      return true;
  }
  
  bool ValidateFogCoordd(const Context *context, angle::EntryPoint entryPoint, GLdouble coord)
  {
      return true;
  }
  
  bool ValidateFogCoorddv(const Context *context, angle::EntryPoint entryPoint, const GLdouble *coord)
  {
      return true;
  }
  
  bool ValidateFogCoordf(const Context *context, angle::EntryPoint entryPoint, GLfloat coord)
  {
      return true;
  }
  
  bool ValidateFogCoordfv(const Context *context, angle::EntryPoint entryPoint, const GLfloat *coord)
  {
      return true;
  }
  
  bool ValidateMultiDrawArrays(const Context *context,
                               angle::EntryPoint entryPoint,
                               PrimitiveMode modePacked,
                               const GLint *first,
                               const GLsizei *count,
                               GLsizei drawcount)
  {
      return true;
  }
  
  bool ValidateMultiDrawElements(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 PrimitiveMode modePacked,
                                 const GLsizei *count,
                                 DrawElementsType typePacked,
                                 const void *const *indices,
                                 GLsizei drawcount)
  {
      return true;
  }
  
  bool ValidatePointParameteri(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLenum pname,
                               GLint param)
  {
      return true;
  }
  
  bool ValidatePointParameteriv(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum pname,
                                const GLint *params)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3b(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLbyte red,
                                GLbyte green,
                                GLbyte blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3bv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 const GLbyte *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3d(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLdouble red,
                                GLdouble green,
                                GLdouble blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3dv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3f(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLfloat red,
                                GLfloat green,
                                GLfloat blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3fv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3i(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLint red,
                                GLint green,
                                GLint blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3iv(const Context *context, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3s(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLshort red,
                                GLshort green,
                                GLshort blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3sv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 const GLshort *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3ub(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLubyte red,
                                 GLubyte green,
                                 GLubyte blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3ubv(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  const GLubyte *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3ui(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLuint red,
                                 GLuint green,
                                 GLuint blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3uiv(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  const GLuint *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3us(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLushort red,
                                 GLushort green,
                                 GLushort blue)
  {
      return true;
  }
  
  bool ValidateSecondaryColor3usv(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  const GLushort *v)
  {
      return true;
  }
  
  bool ValidateSecondaryColorPointer(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLint size,
                                     GLenum type,
                                     GLsizei stride,
                                     const void *pointer)
  {
      return true;
  }
  
  bool ValidateWindowPos2d(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLdouble x,
                           GLdouble y)
  {
      return true;
  }
  
  bool ValidateWindowPos2dv(const Context *context, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateWindowPos2f(const Context *context, angle::EntryPoint entryPoint, GLfloat x, GLfloat y)
  {
      return true;
  }
  
  bool ValidateWindowPos2fv(const Context *context, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateWindowPos2i(const Context *context, angle::EntryPoint entryPoint, GLint x, GLint y)
  {
      return true;
  }
  
  bool ValidateWindowPos2iv(const Context *context, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateWindowPos2s(const Context *context, angle::EntryPoint entryPoint, GLshort x, GLshort y)
  {
      return true;
  }
  
  bool ValidateWindowPos2sv(const Context *context, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateWindowPos3d(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLdouble x,
                           GLdouble y,
                           GLdouble z)
  {
      return true;
  }
  
  bool ValidateWindowPos3dv(const Context *context, angle::EntryPoint entryPoint, const GLdouble *v)
  {
      return true;
  }
  
  bool ValidateWindowPos3f(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLfloat x,
                           GLfloat y,
                           GLfloat z)
  {
      return true;
  }
  
  bool ValidateWindowPos3fv(const Context *context, angle::EntryPoint entryPoint, const GLfloat *v)
  {
      return true;
  }
  
  bool ValidateWindowPos3i(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLint x,
                           GLint y,
                           GLint z)
  {
      return true;
  }
  
  bool ValidateWindowPos3iv(const Context *context, angle::EntryPoint entryPoint, const GLint *v)
  {
      return true;
  }
  
  bool ValidateWindowPos3s(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLshort x,
                           GLshort y,
                           GLshort z)
  {
      return true;
  }
  
  bool ValidateWindowPos3sv(const Context *context, angle::EntryPoint entryPoint, const GLshort *v)
  {
      return true;
  }
  
  bool ValidateGetBufferSubData(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                GLintptr offset,
                                GLsizeiptr size,
                                const void *data)
  {
      return true;
  }
  
  bool ValidateGetQueryObjectiv(const Context *context,
                                angle::EntryPoint entryPoint,
                                QueryID id,
                                GLenum pname,
                                const GLint *params)
  {
      return true;
  }
  
  bool ValidateMapBuffer(const Context *context,
                         angle::EntryPoint entryPoint,
                         BufferBinding targetPacked,
                         GLenum access)
  {
      return true;
  }
  }  // namespace gl
  

Download