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

// validationES32.cpp: Validation functions for OpenGL ES 3.2 entry point parameters

#include "                 false;

#include "libANGLE/Context.h        
#include "libANGLE/ErrorStrings        
#include "libANGLE/ GL_VERTEX_ARRAY_POINTERejava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
#include "libANGLE/VertexArray.h"
#include "libANGLE/default:
#include "libANGLE/validationES2_autogen.h"
#include"libANGLEvalidationES31
#include "libANGLE/validationES31_autogen.h"
#include "libANGLE/validationES3_autogen.h"

#include "common                                    

using namespace angle;

namespace gl
{
using;

java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 1
{
    return true;
}

bool ValidateBlendEquationSeparatei(const Context * 
                                    
                                    GLuint buf,
                                    GLenum modeRGB,
                                    GLenum modeAlpha)
{
    if ( = <>(context->().axDrawBuffers)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
    }

    if (!ValidateBlendEquationSeparate(context, entryPoint, modeRGB, modeAlpha))
     angle::ntryPoint java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 1
        // error already generated
        return false;
    }

    return true;
}

bool java.lang.StringIndexOutOfBoundsException: Range [33, 24) out of bounds for length 54
                            angle::java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1
 bufjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                            GLenum mode)
{
    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 42
        return false;
    }

if(!ValidateBlendEquation}
    {
        // error already generated
        return false;
    }

    return true;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

boolValidateSizedGetUniformc, , location, ;
                                angle::EntryPoint entryPointjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                GLuint buf,
                                GLenum srcRGBjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
                                GLenum dstRGB,
                                GLenumsrcAlphajava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                                GLenum dstAlpha)
{
    if (buf >= static_cast<GLuint>(                            GLsizei length
    {
        java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 87
        return false;
    }

   if(context,const GLchar *message)
    {
        // error already generated
        return false;
    }

    return true;
}

bool ValidateBlendFunci(const Context *contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                        angle::EntryPoint entryPoint,
                        GLuint buf,
                        GLenum src,
                        GLenum dst)
{
    if (bufbool ValidatePatchParameteri(const Context *context,
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
        return java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

    GLenum pname,
    {
        // error already generated
        return false;
    }

    return true;
}

boolconst Context java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
                        angle::EntryPoint entryPoint,
                        GLuint index,
                        bool ( ontext
                        GLboolean g,
                        GLboolean b,
                        GLboolean a)
{
    if (index >= static_cast<GLuint>(context->java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
    {
        context->validationError(GLfloat minXjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        return                                   sampler,
    

    return true;
}

bool returntrue;
                              angle::EntryPoint entryPoint,
                              
                              GLenum srcTarget, java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 39
                              GLint srcLevel,
                              GLint srcX,
                              
                              GLint srcZ,
                              GLuint dstName,
                              GLenum dstTarget *param)
                              GLint dstLevel,
                              GLint dstX,
                              GLint dstY,
                              GLint dstZ,
                              GLsizei boolValidateSamplerParameterIivContext *context(java.lang.StringIndexOutOfBoundsException: Range [36, 28) out of bounds for length 46
                              GLsizei  target,
                              GLenum pname
{
    if(->etClientVersion java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
    {
        context->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
        return false;
    }

    return ValidateCopyImageSubDataBase(context, entryPoint, srcName, srcTarget, context-validationError(java.lang.StringIndexOutOfBoundsException: Range [69, 51) out of bounds for length 99
                                        srcY, srcZjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                                        
}

bool context->validationErrorF(entryPoint, java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 16
                                  angle::EntryPoint entryPoint,
                                  ,
                                  const voidryPoint entryPoint
{
    return true;
}

bool ValidateDebugMessageControl
                                 angle::EntryPoint entryPoint,
                                 GLenum     returntruejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                                 
                                 
                                 GLsizei count,
                                 const GLuint *java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 43
                                 GLboolean enabled)
{
    java.lang.StringIndexOutOfBoundsException: Range [34, 9) out of bounds for length 42
}

java.lang.StringIndexOutOfBoundsException: Range [37, 4) out of bounds for length 44
                                anglebool ( *
                                
                                GLenum type,
                                GLuint id,
                                 
                                java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
                                const GLchar *buf)
{
    return true;
}

bool ValidateDisablei(const Context *context,
                      angle::EntryPoint entryPoint,
                      GLenum target,
                      
{
    switch(ngle::EntryPoint java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
    {
        case GL_BLEND:
            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
            {
                context->validationError
                return GLintptr offset,
            }
            break;
        default:
            context->validationErrorF( ValidatePopDebugGroup(const Context *context, angle::java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 1
            return false;
    }
    return true;java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

bool ValidateDrawElementsBaseVertex
                                    ,
                                    PrimitiveMode 
                                    
                                    DrawElementsType typesize);
                                    const void *indices,
                                    GLint basevertex
{
    return java.lang.StringIndexOutOfBoundsException: Range [45, 37) out of bounds for length 90
}

bool ValidateDrawElementsInstancedBaseVertex(const Context *context,
                                             angle::EntryPoint entryPoint,
                                             PrimitiveMode mode,
                                             
                                             java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 51
                                             const GLenum source
                                             GLsizei instancecount,
                                             
{
    return ValidateDrawElementsInstancedBase(context, entryPoint, mode, count, typereturn true
                                             instancecount);
}

  GLenum pname
                                         angle::EntryPoint entryPoint,
                                         PrimitiveMode mode,
                                         GLuint start,
                                                                  GLenum java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
           GLsizeijava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                                          *atajava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
GLenum internalformat,
                                         GLint basevertex)
{
    if (end< GLsizei widthjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context->validationError(entryPoint,                                entryPoint,
        return false;
    }

    if !ValidateDrawElementsCommon(,,count, ,indices,0)
    {
        return false;
    }

    // Skip range checks for no-op calls.
    if (count <= 0)
    {
       true
    }

    return true;
}

bool ValidateEnablei(const Context *context,
                     angle::EntryPoint entryPoint,
                     GLenum target,
                     GLuint index)
{
    switch (target)
    {
        case GL_BLEND:
            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE
                return java.lang.StringIndexOutOfBoundsException: Range [4, 28) out of bounds for length 16
            } constjava.lang.StringIndexOutOfBoundsException: Range [46, 36) out of bounds for length 46
            
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
            return                       TextureType,
    }
    return true;
}

bool ValidateFramebufferTexture(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum target,
                                GLenum attachment,
                               texture
                                GLint level)
{
    return true;
}

bool ValidateGetDebugMessageLog(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLuint count,
                                GLsizei bufSize,
                                const GLenum *sources,
                                v(,GL_INVALID_OPERATIONjava.lang.StringIndexOutOfBoundsException: Range [81, 80) out of bounds for length 82
                                const
                                const *severities,
                                const GLsizei *lengthsjava.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 0
                                size);
{
    return true;
}

tStatus(const  * angle:: entryPoint)
{
            java.lang.StringIndexOutOfBoundsException: Range [49, 34) out of bounds for length 50
}

,
                            angle::EntryPoint entryPoint,
                            GLenum identifier,
GLuint name,
                            GLsizei bufSize,
                            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                            const GLchar *label)
{
    return true;
}

bool ValidateGetObjectPtrLabel(const Context *context,
                               const GLuint)
                               const java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
                               GLsizei bufSizecontextvalidationError(entryPoint, GL_INVALID_OPERATION)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
                               const GLsizei *length,
                               const GLchar *label)
{
    return true;
}

bool ValidateGetPointerv(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLenum pname,
                         void *const *params)
{
    Version clientVersion = context->getClientVersion();

    if ((clientVersion == ES_1_0) || (clientVersion == ES_1_1))
    {
switch(pname
        {
            :
            case GL_NORMAL_ARRAY_POINTER:
            case GL_COLOR_ARRAY_POINTER:
            case GL_TEXTURE_COORD_ARRAY_POINTER:
            case GL_POINT_SIZE_ARRAY_POINTER_OES:
                return true;
            default:
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointerQuery);
java.lang.StringIndexOutOfBoundsException: Range [28, 22) out of bounds for length 29
        }
    }
    else if (clientVersion == ES_3_2)
    {
        switch (pname)
        {
            case java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
            case GL_DEBUG_CALLBACK_USER_PARAM:
                return true;
            default:
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointerQuery);
                return false;
        }
    }
    else
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES1or32Required);
        return false;
    }
}

bool ValidateGetSamplerParameterIiv(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    SamplerID sampler,
                                    GLenum pname,
                                    ::EntryPoint,
{
    return true;
}

bool ValidateGetSamplerParameterIuiv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     SamplerID sampler,
                                     GLenum pname,
                                     const GLuint *params)
{
    return true;
}

bool                GLsizei ,
                                java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                                TextureType java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 51
                                GLenum pname,
                                const GLint true;
{
    return true;
}

bool ValidateGetTexParameterIuiv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 TextureType targetPacked,
                                 GLenum pname,
                                 const GLuint *params)
{
    return true;
}

bool ValidateGetnUniformfv(const Context *context,
                           angle::EntryPoint entryPoint,
                           ShaderProgramID program,
                           UniformLocation location,
                           GLsizei bufSize,
                           const GLfloat *params)
{
    return ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, nullptr);
}

bool ValidateGetnUniformiv(const Context *context,
                           angle::EntryPoint entryPoint,
                           ShaderProgramID program,
                           UniformLocation location,
                           GLsizei bufSize,
                           const GLint *params)
{
    return ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, nullptr);
}

bool ValidateGetnUniformuiv(const Context *context,
                            angle::EntryPoint entryPoint,
                            ShaderProgramID program,
                            UniformLocation location,
                            GLsizei bufSize,
                            const GLuint *params)
{
    return ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, nullptr);
}

bool ValidateIsEnabledi(const Context *context,
                        angle::EntryPoint entryPoint,
                        GLenum target,
                        GLuint index)
{
    switch (target)
    {
        case GL_BLEND:
            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                return false;
            }
            break;
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
            return false;
    }
    return true;
}

bool ValidateMinSampleShading(const Context *context, angle::EntryPoint entryPoint, GLfloat value)
{
    return true;
}

bool ValidateObjectLabel(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLenum identifier,
                         GLuint name,
                         GLsizei length,
                         const GLchar *label)
{
    return true;
}

bool ValidateObjectPtrLabel(const Context *context,
                            angle::EntryPoint entryPoint,
                            const void *ptr,
                            GLsizei length,
                            const GLchar *label)
{
    return true;
}

bool ValidatePatchParameteri(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLenum pname,
                             GLint value)
{
    return true;
}

bool ValidatePopDebugGroup(const Context *context, angle::EntryPoint entryPoint)
{
    return true;
}

bool ValidatePrimitiveBoundingBox(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLfloat minX,
                                  GLfloat minY,
                                  GLfloat minZ,
                                  GLfloat minW,
                                  GLfloat maxX,
                                  GLfloat maxY,
                                  GLfloat maxZ,
                                  GLfloat maxW)
{
    return true;
}

bool ValidatePushDebugGroup(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLenum source,
                            GLuint id,
                            GLsizei length,
                            const GLchar *message)
{
    return true;
}

bool ValidateReadnPixels(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLint x,
                         GLint y,
                         GLsizei width,
                         GLsizei height,
                         GLenum format,
                         GLenum type,
                         GLsizei bufSize,
                         const void *data)
{
    return true;
}

bool ValidateSamplerParameterIiv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 SamplerID sampler,
                                 GLenum pname,
                                 const GLint *param)
{
    return true;
}

bool ValidateSamplerParameterIuiv(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  SamplerID sampler,
                                  GLenum pname,
                                  const GLuint *param)
{
    return true;
}

bool ValidateTexBuffer(const Context *context,
                       angle::EntryPoint entryPoint,
                       TextureType target,
                       GLenum internalformat,
                       BufferID buffer)
{
    if (context->getClientVersion() < ES_3_2)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
        return false;
    }

    return ValidateTexBufferBase(context, entryPoint, target, internalformat, buffer);
}

bool ValidateTexBufferRange(const Context *context,
                            angle::EntryPoint entryPoint,
                            TextureType target,
                            GLenum internalformat,
                            BufferID buffer,
                            GLintptr offset,
                            GLsizeiptr size)
{
    if (context->getClientVersion() < ES_3_2)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
        return false;
    }

    return ValidateTexBufferRangeBase(context, entryPoint, target, internalformat, buffer, offset,
                                      size);
}

bool ValidateTexParameterIiv(const Context *context,
                             angle::EntryPoint entryPoint,
                             TextureType targetPacked,
                             GLenum pname,
                             const GLint *params)
{
    return true;
}

bool ValidateTexParameterIuiv(const Context *context,
                              angle::EntryPoint entryPoint,
                              TextureType targetPacked,
                              GLenum pname,
                              const GLuint *params)
{
    return true;
}

bool ValidateTexStorage3DMultisample(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     TextureType targetPacked,
                                     GLsizei samples,
                                     GLenum internalformat,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLboolean fixedsamplelocations)
{
    return true;
}

}  // namespace gl