context_private_call_gles.cpp | Explore in Territory

//
// 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_gles.cpp:
//   Helpers that set/get state that is entirely locally accessed by the context.

#include "libANGLE/context_private_call_gles_autogen.h"

#include "common/debug.h"
#include "libANGLE/queryconversions.h"
#include "libANGLE/queryutils.h"

namespace
{
angle::Mat4 FixedMatrixToMat4(const GLfixed *m)
{ … }
}  // namespace

namespace gl
{
void ContextPrivateClearColor(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLfloat red,
                              GLfloat green,
                              GLfloat blue,
                              GLfloat alpha)
{ … }

void ContextPrivateClearDepthf(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLfloat depth)
{ … }

void ContextPrivateClearStencil(PrivateState *privateState,
                                PrivateStateCache *privateStateCache,
                                GLint stencil)
{ … }

void ContextPrivateClearColorx(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLfixed red,
                               GLfixed green,
                               GLfixed blue,
                               GLfixed alpha)
{ … }

void ContextPrivateClearDepthx(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLfixed depth)
{ … }

void ContextPrivateColorMask(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLboolean red,
                             GLboolean green,
                             GLboolean blue,
                             GLboolean alpha)
{ … }

void ContextPrivateColorMaski(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLuint index,
                              GLboolean r,
                              GLboolean g,
                              GLboolean b,
                              GLboolean a)
{ … }

void ContextPrivateDepthMask(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLboolean flag)
{ … }

void ContextPrivateDisable(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLenum cap)
{ … }

void ContextPrivateDisablei(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            GLenum target,
                            GLuint index)
{ … }

void ContextPrivateEnable(PrivateState *privateState,
                          PrivateStateCache *privateStateCache,
                          GLenum cap)
{ … }

void ContextPrivateEnablei(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLenum target,
                           GLuint index)
{ … }

void ContextPrivateActiveTexture(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLenum texture)
{ … }

void ContextPrivateCullFace(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            CullFaceMode mode)
{ … }

void ContextPrivateDepthFunc(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLenum func)
{ … }

void ContextPrivateDepthRangef(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLfloat zNear,
                               GLfloat zFar)
{ … }

void ContextPrivateDepthRangex(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLfixed zNear,
                               GLfixed zFar)
{ … }

void ContextPrivateFrontFace(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLenum mode)
{ … }

void ContextPrivateLineWidth(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLfloat width)
{ … }

void ContextPrivateLineWidthx(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLfixed width)
{ … }

void ContextPrivatePolygonOffset(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLfloat factor,
                                 GLfloat units)
{ … }

void ContextPrivatePolygonOffsetClamp(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLfloat factor,
                                      GLfloat units,
                                      GLfloat clamp)
{ … }

void ContextPrivatePolygonOffsetx(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLfixed factor,
                                  GLfixed units)
{ … }

void ContextPrivateSampleCoverage(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLfloat value,
                                  GLboolean invert)
{ … }

void ContextPrivateSampleCoveragex(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLclampx value,
                                   GLboolean invert)
{ … }

void ContextPrivateScissor(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLint x,
                           GLint y,
                           GLsizei width,
                           GLsizei height)
{ … }

void ContextPrivateVertexAttrib1f(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLuint index,
                                  GLfloat x)
{ … }

void ContextPrivateVertexAttrib1fv(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLuint index,
                                   const GLfloat *values)
{ … }

void ContextPrivateVertexAttrib2f(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLuint index,
                                  GLfloat x,
                                  GLfloat y)
{ … }

void ContextPrivateVertexAttrib2fv(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLuint index,
                                   const GLfloat *values)
{ … }

void ContextPrivateVertexAttrib3f(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLuint index,
                                  GLfloat x,
                                  GLfloat y,
                                  GLfloat z)
{ … }

void ContextPrivateVertexAttrib3fv(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLuint index,
                                   const GLfloat *values)
{ … }

void ContextPrivateVertexAttrib4f(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLuint index,
                                  GLfloat x,
                                  GLfloat y,
                                  GLfloat z,
                                  GLfloat w)
{ … }

void ContextPrivateVertexAttrib4fv(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLuint index,
                                   const GLfloat *values)
{ … }

void ContextPrivateVertexAttribI4i(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLuint index,
                                   GLint x,
                                   GLint y,
                                   GLint z,
                                   GLint w)
{ … }

void ContextPrivateVertexAttribI4iv(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    const GLint *values)
{ … }

void ContextPrivateVertexAttribI4ui(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLuint x,
                                    GLuint y,
                                    GLuint z,
                                    GLuint w)
{ … }

void ContextPrivateVertexAttribI4uiv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLuint *values)
{ … }

void ContextPrivateViewport(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            GLint x,
                            GLint y,
                            GLsizei width,
                            GLsizei height)
{ … }

void ContextPrivateSampleMaski(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLuint maskNumber,
                               GLbitfield mask)
{ … }

void ContextPrivateMinSampleShading(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLfloat value)
{ … }

void ContextPrivatePrimitiveBoundingBox(PrivateState *privateState,
                                        PrivateStateCache *privateStateCache,
                                        GLfloat minX,
                                        GLfloat minY,
                                        GLfloat minZ,
                                        GLfloat minW,
                                        GLfloat maxX,
                                        GLfloat maxY,
                                        GLfloat maxZ,
                                        GLfloat maxW)
{ … }

void ContextPrivateLogicOp(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           LogicalOperation opcode)
{ … }

void ContextPrivateLogicOpANGLE(PrivateState *privateState,
                                PrivateStateCache *privateStateCache,
                                LogicalOperation opcode)
{ … }

void ContextPrivatePolygonMode(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLenum face,
                               PolygonMode mode)
{ … }

void ContextPrivatePolygonModeNV(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLenum face,
                                 PolygonMode mode)
{ … }

void ContextPrivateProvokingVertex(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   ProvokingVertexConvention provokeMode)
{ … }

void ContextPrivateCoverageModulation(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLenum components)
{ … }

void ContextPrivateClipControl(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               ClipOrigin origin,
                               ClipDepthMode depth)
{ … }

void ContextPrivateShadingRate(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLenum rate)
{ … }

void ContextPrivateBlendColor(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLfloat red,
                              GLfloat green,
                              GLfloat blue,
                              GLfloat alpha)
{ … }

void ContextPrivateBlendEquation(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLenum mode)
{ … }

void ContextPrivateBlendEquationi(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLuint buf,
                                  GLenum mode)
{ … }

void ContextPrivateBlendEquationSeparate(PrivateState *privateState,
                                         PrivateStateCache *privateStateCache,
                                         GLenum modeRGB,
                                         GLenum modeAlpha)
{ … }

void ContextPrivateBlendEquationSeparatei(PrivateState *privateState,
                                          PrivateStateCache *privateStateCache,
                                          GLuint buf,
                                          GLenum modeRGB,
                                          GLenum modeAlpha)
{ … }

void ContextPrivateBlendFunc(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLenum sfactor,
                             GLenum dfactor)
{ … }

void ContextPrivateBlendFunci(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLuint buf,
                              GLenum src,
                              GLenum dst)
{ … }

void ContextPrivateBlendFuncSeparate(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLenum srcRGB,
                                     GLenum dstRGB,
                                     GLenum srcAlpha,
                                     GLenum dstAlpha)
{ … }

void ContextPrivateBlendFuncSeparatei(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint buf,
                                      GLenum srcRGB,
                                      GLenum dstRGB,
                                      GLenum srcAlpha,
                                      GLenum dstAlpha)
{ … }

void ContextPrivateStencilFunc(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLenum func,
                               GLint ref,
                               GLuint mask)
{ … }

void ContextPrivateStencilFuncSeparate(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLenum face,
                                       GLenum func,
                                       GLint ref,
                                       GLuint mask)
{ … }

void ContextPrivateStencilMask(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLuint mask)
{ … }

void ContextPrivateStencilMaskSeparate(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLenum face,
                                       GLuint mask)
{ … }

void ContextPrivateStencilOp(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLenum fail,
                             GLenum zfail,
                             GLenum zpass)
{ … }

void ContextPrivateStencilOpSeparate(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLenum face,
                                     GLenum fail,
                                     GLenum zfail,
                                     GLenum zpass)
{ … }

void ContextPrivatePixelStorei(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLenum pname,
                               GLint param)
{ … }

void ContextPrivateHint(PrivateState *privateState,
                        PrivateStateCache *privateStateCache,
                        GLenum target,
                        GLenum mode)
{ … }

GLboolean ContextPrivateIsEnabled(PrivateState *privateState,
                                  PrivateStateCache *privateStateCache,
                                  GLenum cap)
{ … }

GLboolean ContextPrivateIsEnabledi(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLenum target,
                                   GLuint index)
{ … }

void ContextPrivatePatchParameteri(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLenum pname,
                                   GLint value)
{ … }

void ContextPrivateAlphaFunc(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             AlphaTestFunc func,
                             GLfloat ref)
{ … }

void ContextPrivateAlphaFuncx(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              AlphaTestFunc func,
                              GLfixed ref)
{ … }

void ContextPrivateClipPlanef(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLenum p,
                              const GLfloat *eqn)
{ … }

void ContextPrivateClipPlanex(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLenum plane,
                              const GLfixed *equation)
{ … }

void ContextPrivateColor4f(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLfloat red,
                           GLfloat green,
                           GLfloat blue,
                           GLfloat alpha)
{ … }

void ContextPrivateColor4ub(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            GLubyte red,
                            GLubyte green,
                            GLubyte blue,
                            GLubyte alpha)
{ … }

void ContextPrivateColor4x(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLfixed red,
                           GLfixed green,
                           GLfixed blue,
                           GLfixed alpha)
{ … }

void ContextPrivateFogf(PrivateState *privateState,
                        PrivateStateCache *privateStateCache,
                        GLenum pname,
                        GLfloat param)
{ … }

void ContextPrivateFogfv(PrivateState *privateState,
                         PrivateStateCache *privateStateCache,
                         GLenum pname,
                         const GLfloat *params)
{ … }

void ContextPrivateFogx(PrivateState *privateState,
                        PrivateStateCache *privateStateCache,
                        GLenum pname,
                        GLfixed param)
{ … }

void ContextPrivateFogxv(PrivateState *privateState,
                         PrivateStateCache *privateStateCache,
                         GLenum pname,
                         const GLfixed *params)
{ … }

void ContextPrivateFrustumf(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            GLfloat l,
                            GLfloat r,
                            GLfloat b,
                            GLfloat t,
                            GLfloat n,
                            GLfloat f)
{ … }

void ContextPrivateFrustumx(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            GLfixed l,
                            GLfixed r,
                            GLfixed b,
                            GLfixed t,
                            GLfixed n,
                            GLfixed f)
{ … }

void ContextPrivateGetClipPlanef(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLenum plane,
                                 GLfloat *equation)
{ … }

void ContextPrivateGetClipPlanex(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLenum plane,
                                 GLfixed *equation)
{ … }

void ContextPrivateGetLightfv(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLenum light,
                              LightParameter pname,
                              GLfloat *params)
{ … }

void ContextPrivateGetLightxv(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLenum light,
                              LightParameter pname,
                              GLfixed *params)
{ … }

void ContextPrivateGetMaterialfv(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLenum face,
                                 MaterialParameter pname,
                                 GLfloat *params)
{ … }

void ContextPrivateGetMaterialxv(PrivateState *privateState,
                                 PrivateStateCache *privateStateCache,
                                 GLenum face,
                                 MaterialParameter pname,
                                 GLfixed *params)
{ … }

void ContextPrivateGetTexEnvfv(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               TextureEnvTarget target,
                               TextureEnvParameter pname,
                               GLfloat *params)
{ … }

void ContextPrivateGetTexEnviv(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               TextureEnvTarget target,
                               TextureEnvParameter pname,
                               GLint *params)
{ … }

void ContextPrivateGetTexEnvxv(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               TextureEnvTarget target,
                               TextureEnvParameter pname,
                               GLfixed *params)
{ … }

void ContextPrivateLightModelf(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLenum pname,
                               GLfloat param)
{ … }

void ContextPrivateLightModelfv(PrivateState *privateState,
                                PrivateStateCache *privateStateCache,
                                GLenum pname,
                                const GLfloat *params)
{ … }

void ContextPrivateLightModelx(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               GLenum pname,
                               GLfixed param)
{ … }

void ContextPrivateLightModelxv(PrivateState *privateState,
                                PrivateStateCache *privateStateCache,
                                GLenum pname,
                                const GLfixed *param)
{ … }

void ContextPrivateLightf(PrivateState *privateState,
                          PrivateStateCache *privateStateCache,
                          GLenum light,
                          LightParameter pname,
                          GLfloat param)
{ … }

void ContextPrivateLightfv(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLenum light,
                           LightParameter pname,
                           const GLfloat *params)
{ … }

void ContextPrivateLightx(PrivateState *privateState,
                          PrivateStateCache *privateStateCache,
                          GLenum light,
                          LightParameter pname,
                          GLfixed param)
{ … }

void ContextPrivateLightxv(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLenum light,
                           LightParameter pname,
                           const GLfixed *params)
{ … }

void ContextPrivateLoadIdentity(PrivateState *privateState, PrivateStateCache *privateStateCache)
{ … }

void ContextPrivateLoadMatrixf(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               const GLfloat *m)
{ … }

void ContextPrivateLoadMatrixx(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               const GLfixed *m)
{ … }

void ContextPrivateMaterialf(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLenum face,
                             MaterialParameter pname,
                             GLfloat param)
{ … }

void ContextPrivateMaterialfv(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLenum face,
                              MaterialParameter pname,
                              const GLfloat *params)
{ … }

void ContextPrivateMaterialx(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLenum face,
                             MaterialParameter pname,
                             GLfixed param)
{ … }

void ContextPrivateMaterialxv(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLenum face,
                              MaterialParameter pname,
                              const GLfixed *param)
{ … }

void ContextPrivateMatrixMode(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              MatrixType mode)
{ … }

void ContextPrivateMultMatrixf(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               const GLfloat *m)
{ … }

void ContextPrivateMultMatrixx(PrivateState *privateState,
                               PrivateStateCache *privateStateCache,
                               const GLfixed *m)
{ … }

void ContextPrivateMultiTexCoord4f(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLenum target,
                                   GLfloat s,
                                   GLfloat t,
                                   GLfloat r,
                                   GLfloat q)
{ … }

void ContextPrivateMultiTexCoord4x(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   GLenum texture,
                                   GLfixed s,
                                   GLfixed t,
                                   GLfixed r,
                                   GLfixed q)
{ … }

void ContextPrivateNormal3f(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            GLfloat nx,
                            GLfloat ny,
                            GLfloat nz)
{ … }

void ContextPrivateNormal3x(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            GLfixed nx,
                            GLfixed ny,
                            GLfixed nz)
{ … }

void ContextPrivateOrthof(PrivateState *privateState,
                          PrivateStateCache *privateStateCache,
                          GLfloat left,
                          GLfloat right,
                          GLfloat bottom,
                          GLfloat top,
                          GLfloat zNear,
                          GLfloat zFar)
{ … }

void ContextPrivateOrthox(PrivateState *privateState,
                          PrivateStateCache *privateStateCache,
                          GLfixed left,
                          GLfixed right,
                          GLfixed bottom,
                          GLfixed top,
                          GLfixed zNear,
                          GLfixed zFar)
{ … }

void ContextPrivatePointParameterf(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   PointParameter pname,
                                   GLfloat param)
{ … }

void ContextPrivatePointParameterfv(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    PointParameter pname,
                                    const GLfloat *params)
{ … }

void ContextPrivatePointParameterx(PrivateState *privateState,
                                   PrivateStateCache *privateStateCache,
                                   PointParameter pname,
                                   GLfixed param)
{ … }

void ContextPrivatePointParameterxv(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    PointParameter pname,
                                    const GLfixed *params)
{ … }

void ContextPrivatePointSize(PrivateState *privateState,
                             PrivateStateCache *privateStateCache,
                             GLfloat size)
{ … }

void ContextPrivatePointSizex(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLfixed size)
{ … }

void ContextPrivatePopMatrix(PrivateState *privateState, PrivateStateCache *privateStateCache)
{ … }

void ContextPrivatePushMatrix(PrivateState *privateState, PrivateStateCache *privateStateCache)
{ … }

void ContextPrivateRotatef(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLfloat angle,
                           GLfloat x,
                           GLfloat y,
                           GLfloat z)
{ … }

void ContextPrivateRotatex(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           GLfixed angle,
                           GLfixed x,
                           GLfixed y,
                           GLfixed z)
{ … }

void ContextPrivateScalef(PrivateState *privateState,
                          PrivateStateCache *privateStateCache,
                          GLfloat x,
                          GLfloat y,
                          GLfloat z)
{ … }

void ContextPrivateScalex(PrivateState *privateState,
                          PrivateStateCache *privateStateCache,
                          GLfixed x,
                          GLfixed y,
                          GLfixed z)
{ … }

void ContextPrivateShadeModel(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              ShadingModel model)
{ … }

void ContextPrivateTexEnvf(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           TextureEnvTarget target,
                           TextureEnvParameter pname,
                           GLfloat param)
{ … }

void ContextPrivateTexEnvfv(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            TextureEnvTarget target,
                            TextureEnvParameter pname,
                            const GLfloat *params)
{ … }

void ContextPrivateTexEnvi(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           TextureEnvTarget target,
                           TextureEnvParameter pname,
                           GLint param)
{ … }

void ContextPrivateTexEnviv(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            TextureEnvTarget target,
                            TextureEnvParameter pname,
                            const GLint *params)
{ … }

void ContextPrivateTexEnvx(PrivateState *privateState,
                           PrivateStateCache *privateStateCache,
                           TextureEnvTarget target,
                           TextureEnvParameter pname,
                           GLfixed param)
{ … }

void ContextPrivateTexEnvxv(PrivateState *privateState,
                            PrivateStateCache *privateStateCache,
                            TextureEnvTarget target,
                            TextureEnvParameter pname,
                            const GLfixed *params)
{ … }

void ContextPrivateTranslatef(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLfloat x,
                              GLfloat y,
                              GLfloat z)
{ … }

void ContextPrivateTranslatex(PrivateState *privateState,
                              PrivateStateCache *privateStateCache,
                              GLfixed x,
                              GLfixed y,
                              GLfixed z)
{ … }
}  // namespace gl
chromium/third_party/angle/src/libANGLE/context_private_call_gles.cpp
