//
// 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.
//

// validationGL2.cpp: Validation functions for OpenGL 2.0 entry point parameters

#include "libANGLE/validationGL2_autogen.h"

namespace gl
{

bool ValidateGetVertexAttribdv(const Context *context,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum pname,
                               const GLdouble *params)
{
    return true;
}

bool ValidateVertexAttrib1d(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLdouble x)
{
    return true;
}

bool ValidateVertexAttrib1dv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLdouble *v)
{
    return true;
}

bool ValidateVertexAttrib1s(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLshort x)
{
    return true;
}

bool ValidateVertexAttrib1sv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLshort *v)
{
    return true;
}

bool ValidateVertexAttrib2d(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLdouble x,
                            GLdouble y)
{
    return true;
}

bool ValidateVertexAttrib2dv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLdouble *v)
{
    return true;
}

bool ValidateVertexAttrib2s(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLshort x,
                            GLshort y)
{
    return true;
}

bool ValidateVertexAttrib2sv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLshort *v)
{
    return true;
}

bool ValidateVertexAttrib3d(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLdouble x,
                            GLdouble y,
                            GLdouble z)
{
    return true;
}

bool ValidateVertexAttrib3dv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLdouble *v)
{
    return true;
}

bool ValidateVertexAttrib3s(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLshort x,
                            GLshort y,
                            GLshort z)
{
    return true;
}

bool ValidateVertexAttrib3sv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLshort *v)
{
    return true;
}

bool ValidateVertexAttrib4Nbv(const PrivateState &state,
                              ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLbyte *v)
{
    return true;
}

bool ValidateVertexAttrib4Niv(const PrivateState &state,
                              ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLint *v)
{
    return true;
}

bool ValidateVertexAttrib4Nsv(const PrivateState &state,
                              ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v)
{
    return true;
}

bool ValidateVertexAttrib4Nub(const PrivateState &state,
                              ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLubyte x,
                              GLubyte y,
                              GLubyte z,
                              GLubyte w)
{
    return true;
}

bool ValidateVertexAttrib4Nubv(const PrivateState &state,
                               ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLubyte *v)
{
    return true;
}

bool ValidateVertexAttrib4Nuiv(const PrivateState &state,
                               ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLuint *v)
{
    return true;
}

bool ValidateVertexAttrib4Nusv(const PrivateState &state,
                               ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLushort *v)
{
    return true;
}

bool ValidateVertexAttrib4bv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLbyte *v)
{
    return true;
}

bool ValidateVertexAttrib4d(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLdouble x,
                            GLdouble y,
                            GLdouble z,
                            GLdouble w)
{
    return true;
}

bool ValidateVertexAttrib4dv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLdouble *v)
{
    return true;
}

bool ValidateVertexAttrib4iv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLint *v)
{
    return true;
}

bool ValidateVertexAttrib4s(const PrivateState &state,
                            ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLshort x,
                            GLshort y,
                            GLshort z,
                            GLshort w)
{
    return true;
}

bool ValidateVertexAttrib4sv(const PrivateState &state,
                             ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             const GLshort *v)
{
    return true;
}

bool ValidateVertexAttrib4ubv(const PrivateState &state,
                              ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLubyte *v)
{
    return true;
}

bool ValidateVertexAttrib4uiv(const PrivateState &state,
                              ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLuint *v)
{
    return true;
}

bool ValidateVertexAttrib4usv(const PrivateState &state,
                              ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLushort *v)
{
    return true;
}

}  // namespace gl
