//
// 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 "libANGLE/validationES32_autogen.h"

#include "libANGLE/Context.h"
#include "libANGLE/ErrorStrings.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/VertexArray.h"
#include "libANGLE/validationES.h"
#include "libANGLE/validationES2_autogen.h"
#include "libANGLE/validationES31.h"
#include "libANGLE/validationES31_autogen.h"
#include "libANGLE/validationES3_autogen.h"

#include "common/utilities.h"

using namespace angle;

namespace gl
{
using namespace err;

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

bool ValidateBlendEquationSeparatei(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLuint buf,
                                    GLenum modeRGB,
                                    GLenum modeAlpha)
{
    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
        return false;
    }

    if (!ValidateBlendEquationSeparate(context, entryPoint, modeRGB, modeAlpha))
    {
        // error already generated
        return false;
    }

    return true;
}

bool ValidateBlendEquationi(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLuint buf,
                            GLenum mode)
{
    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
        return false;
    }

    if (!ValidateBlendEquation(context, entryPoint, mode))
    {
        // error already generated
        return false;
    }

    return true;
}

bool ValidateBlendFuncSeparatei(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLuint buf,
                                GLenum srcRGB,
                                GLenum dstRGB,
                                GLenum srcAlpha,
                                GLenum dstAlpha)
{
    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
        return false;
    }

    if (!ValidateBlendFuncSeparate(context, entryPoint, srcRGB, dstRGB, srcAlpha, dstAlpha))
    {
        // error already generated
        return false;
    }

    return true;
}

bool ValidateBlendFunci(const Context *context,
                        angle::EntryPoint entryPoint,
                        GLuint buf,
                        GLenum src,
                        GLenum dst)
{
    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
        return false;
    }

    if (!ValidateBlendFunc(context, entryPoint, src, dst))
    {
        // error already generated
        return false;
    }

    return true;
}

bool ValidateColorMaski(const Context *context,
                        angle::EntryPoint entryPoint,
                        GLuint index,
                        GLboolean r,
                        GLboolean g,
                        GLboolean b,
                        GLboolean a)
{
    if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
        return false;
    }

    return true;
}

bool ValidateCopyImageSubData(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLuint srcName,
                              GLenum srcTarget,
                              GLint srcLevel,
                              GLint srcX,
                              GLint srcY,
                              GLint srcZ,
                              GLuint dstName,
                              GLenum dstTarget,
                              GLint dstLevel,
                              GLint dstX,
                              GLint dstY,
                              GLint dstZ,
                              GLsizei srcWidth,
                              GLsizei srcHeight,
                              GLsizei srcDepth)
{
    if (context->getClientVersion() < ES_3_2)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
        return false;
    }

    return ValidateCopyImageSubDataBase(context, entryPoint, srcName, srcTarget, srcLevel, srcX,
                                        srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ,
                                        srcWidth, srcHeight, srcDepth);
}

bool ValidateDebugMessageCallback(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLDEBUGPROC callback,
                                  const void *userParam)
{
    return true;
}

bool ValidateDebugMessageControl(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLenum source,
                                 GLenum type,
                                 GLenum severity,
                                 GLsizei count,
                                 const GLuint *ids,
                                 GLboolean enabled)
{
    return true;
}

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

bool ValidateDisablei(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 ValidateDrawElementsBaseVertex(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    PrimitiveMode mode,
                                    GLsizei count,
                                    DrawElementsType type,
                                    const void *indices,
                                    GLint basevertex)
{
    return ValidateDrawElementsCommon(context, entryPoint, mode, count, type, indices, 1);
}

bool ValidateDrawElementsInstancedBaseVertex(const Context *context,
                                             angle::EntryPoint entryPoint,
                                             PrimitiveMode mode,
                                             GLsizei count,
                                             DrawElementsType type,
                                             const void *indices,
                                             GLsizei instancecount,
                                             GLint basevertex)
{
    return ValidateDrawElementsInstancedBase(context, entryPoint, mode, count, type, indices,
                                             instancecount);
}

bool ValidateDrawRangeElementsBaseVertex(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         PrimitiveMode mode,
                                         GLuint start,
                                         GLuint end,
                                         GLsizei count,
                                         DrawElementsType type,
                                         const void *indices,
                                         GLint basevertex)
{
    if (end < start)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidElementRange);
        return false;
    }

    if (!ValidateDrawElementsCommon(context, entryPoint, mode, count, type, indices, 0))
    {
        return false;
    }

    // Skip range checks for no-op calls.
    if (count <= 0)
    {
        return 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, kIndexExceedsMaxDrawBuffer);
                return false;
            }
            break;
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
            return false;
    }
    return true;
}

bool ValidateFramebufferTexturejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                angle:
                                java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                                
                                TextureID texture,}
                                
{
    return true;
}

boolValidateGetDebugMessageLog(const Context *context,
                                angle::EntryPoint entryPoint,
                                ,
                                GLsizei bufSize,
                                 >= static_cast<GLuint>(context().)
                                const GLenum *types,
                                const GLuint *ids,
                                const GLenum *severities,
                                java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 21
                                const GLchar *messageLog)
{
    return true;
}

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

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

bool ValidateGetObjectPtrLabelconst Context *bool ValidateGetObjectPtrLabel(const Context *context
                               ValidateDebugMessageInsertContext *contextjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                               const void *ptr,
                               GLsizei bufSize,
                               const GLsizei *length,
                               const{
{
    return true;
}

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

    if ((clientVersion ==             if(index= >etCaps(.)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    {
        switch (pname)
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            case java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
            case java.lang.StringIndexOutOfBoundsException: Range [36, 32) out of bounds for length 65
            case GL_COLOR_ARRAY_POINTER:
            case GL_TEXTURE_COORD_ARRAY_POINTER:
            GLsizeiconst length,
                return true;
            default:
                context{
                return false;
        }
    }
    else if (clientVersion == ES_3_2)
    {
        switch (pname)
        {
            case GL_DEBUG_CALLBACK_FUNCTION:
            case GL_DEBUG_CALLBACK_USER_PARAM:
                return;
            default:
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointerQuery);
                return false;
        }
    }
    else
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        return false;
    }
}

bool ValidateGetSamplerParameterIiv(const 
                                    (  *,
                                    SamplerID sampler,
                                    GLenum pname,
                                    const GLint *params)
{
    return trueGLsizei count,
}

bool ValidateGetSamplerParameterIuivContext*,
                                      ()
                                     SamplerID sampler,
                                     ,
                                     
{
    return if (!Validatcontext,    java.lang.StringIndexOutOfBoundsException: Range [84, 83) out of bounds for length 88
}

bool ValidateGetTexParameterIiv(const Contextreturnjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 41
                                angle::EntryPoint entryPoint,
                                angle:entryPoint
                                GLenum pname,
                                const                java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    return true;
}

bool ValidateGetTexParameterIuiv(const Context *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,
                       ShaderProgramIDjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                            location
                           GLsizei bufSize,
                           const GLfloat *angle::EntryPoint entryPoint
{
    return                   GLenum attachment
}

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

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

bool java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
                        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                        GLenum targetangle::EntryPoint ,
                         index
{
    switch (target)
    {
        case GL_BLEND:
            if (index >= static_cast<GLuint>(context->getCaps(const GLchar *label
            {
                context->validationError(entryPoint, GL_INVALID_VALUEjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                return false;
            }
            break;
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
            return false;
    }
    return ;
}

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(case GL_NORMAL_ARRAY_POINTER:
                            angle::EntryPoint entryPoint,
                            const void *ptr,
                            GLsizei length,
                            returntrue;
{
    return true;
 }

boolreturn true;
                             GLuintbuf,
                             ::java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 56
                             
{
    return java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

bool ValidatePopDebugGroup(const Context *context, java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
{
    return true
}angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56

bool ValidatePrimitiveBoundingBox(const Context *context,
                                  angle::EntryPoint entryPoint                           
                                  
                                  GLfloat minY,
                                  GLfloat minZ,
                                  GLfloat minW,
                                  GLfloat maxX,
                                  GLfloat maxY,
                                  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                                  GLfloat maxW)
{
    return true}
}

onst Contextcontext,
                            angle::EntryPoint entryPoint,
                            GLenum sourcejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
boolconst Context context,
                            context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
                            
{
    return truejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

ValidateReadnPixelsContext*,
                         angle::EntryPoint entryPoint,
                         GLint x,
                         GLint y,
                         GLsizei width,
                         GLsizei height,
                         GLenum format,
                         
                         GLsizei bufSize,
                         const void *data)
{
    return true;
}

bool ValidateSamplerParameterIivangle::ntryPoint entryPoint,
 (arget)
                                 SamplerIDsampler,
                                  GLcharmjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                 const GLint *param)
{
    return ;
}

bool bool ValidateSamplerParameterIuiv
                                  :java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                                  SamplerID sampler,
                                  GLenum ,
                                  
{
    return true;
}

bool ValidateTexBufferconst Context *context,
                       angle::EntryPoint entryPoint,
                       TextureType
                       GLenum internalformat,
                       BufferID buffer)
{
    if (context->getClientVersionreturn
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
        return false;
    }

return                                 GLenum severity,
}

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

    return ValidateTexBufferRangeBase(context, entryPoint, target, internalformat,                                GLenum java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 57
                                      
}

bool bool ValidateGetGraphicsReseContext*ontext,angleEntryPoint )
                             angle::EntryPoint entryPoint    return                    internalformat,
                             TextureType bool ValidateGetObjectLabel(const Context *context
                             GLenum pname,
                             const GLint                             java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
    return true;
}

bool ValidateTexParameterIuiv(const Context *context,
                              angle::EntryPoint entryPoint,
                              TextureType targetPacked,
                              GLenum java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
                               *params)
{
    return true;
}

bool ValidateTexStorage3DMultisample(const Context *context,
                                     angle::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 51
                                     TextureType java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
                                     GLsizei samples,
                                     GLenum java.lang.StringIndexOutOfBoundsException: Range [34, 28) out of bounds for length 52
                                     TextureType targetPacked
                                     GLsizei height,
                                                 case GL_VERTEX_ARRAY_POINTER
                                     
{
    return true;
}

}  // namespace gl                return false;