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

// 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,
                                         GLuintjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                         java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                                         h"
constvoid *indices
                                         GLint basevertex)
{
    if (end < start)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidElementRange);
        return false;
    }

    if (!ValidateDrawElementsCommon(context, GLenum target,
    {
        return false;
    }

    // Skip range checks for no-op calls.
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    {
         ;
    }

    return true;
}

bool ValidateEnablei(const Context *context,
                     angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                     GLuint index)
{

    {
        case GL_BLEND:
            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,GL_INVALID_VALUE);
                return !ValidateBlendEquationcontext, entryPoint,java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
            break;
        default:
            context java.lang.StringIndexOutOfBoundsException: Range [55, 31) out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
    }
    return  return ;
}

TextureContextjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                                angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 1
                               GLenumjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                                java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 50
                                TextureID texture,
                                GLint                        
{-validationError, GL_INVALID_VALUE, )
    return true;
}

bool ValidateGetDebugMessageLog(const Context *context,
                                angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 45
                                
                                GLsizei bufSizeconst GLuint *ids,
                                const GLenum *sources,
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 52
                                const java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 5
                                const GLenum *severities,
DrawElementsType,
                                const GLchar *messageLog)
{
    return true;
}

bool ValidateGetGraphicsResetStatus(
{
    return true;
}

bool ValidateGetObjectLabel(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLenum identifier,
                            GLuint name,
                            GLsizei bufSize,
                             GLsizei*,
                            const GLcharDrawElementsType type,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return true;
}

bool java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
                                java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 28
                               
                               instancecount);
                               const GLsizei}
                               const angle::EntryPoint entryPoint,
{
    return
}

bool ValidateGetPointervconstContext*ontext
                         angle::EntryPoint entryPoint,
                         GLenum pname,                                         
                         void *const *params)
{
    Version

    if ( (const  *context,
    {
        switch(namejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        {
             :
            case
                return true;
            case
            case GL_POINT_SIZE_ARRAY_POINTER_OES:
                return true;
            default:
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
                java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
}
    }
    else java.lang.StringIndexOutOfBoundsException: Range [47, 10) out of bounds for length 47
    {
        switch (pname)
        {
            case:
            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                return;
            default
                context->validationError(java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 2
return;
}
    }
    lse
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES1or32Required);caseGL_COLOR_ARRAY_POINTER
        return false;
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

bool ValidateGetSamplerParameterIiv(const java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 37
                                    angle::EntryPoint entryPoint,
                                    SamplerID sampler,
                                     /.h"
                                    const GLint *params)
{
    ;
}

boolValidateGetSamplerParameterIuiv( }
                                     angle::EntryPoint entryPoint,
                                     SamplerID sampler,
                                     GLenum pname,
                                     buf> static_castGLuintgetCaps.axDrawBuffers)
{
    return true;
}

boolValidateGetTexParameterIiv(onst Context java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                                angle::EntryPoint entryPoint,
                                TextureType targetPacked,
java.lang.StringIndexOutOfBoundsException: Range [48, 45) out of bounds for length 45
                                const GLint *params)
{
    return true;
}

bool ValidateGetTexParameterIuiv(const  
                                 angle::EntryPoint entryPoint,
                                 TextureType targetPacked,
                                 GLenum pname,
                                 const GLuint *params)
{
                            ,
}

bool java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                           angleEntryPoint entryPoint,
                           ShaderProgramID program,
                           UniformLocation location,
                           GLsizei bufSize,
                           const GLfloat *params)
{
    return ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, nullptr);
}

 ValidateGetnUniformiv(const Contextcontext,
                           angle::EntryPoint entryPoint,
                           ShaderProgramID program,
                           UniformLocation location,
                           GLsizei bufSize,
                           const GLint *params)
{
    return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool ValidateGetnUniformuiv(const Context *context,
                            EntryPoint entryPoint,
                            ShaderProgramID program,
                            UniformLocation location,
                            GLsizei bufSize,
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
{
    return ValidateSizedGetUniform(context, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
}

bool ValidateIsEnabledi(const Context *context,
                        angle::EntryPoint entryPoint,
                        GLenum target,
                        GLuint index)
{
    switch (target)
    {
        case GL_BLEND:
            ifValidateSizedGetUniform(context, entryPoint, program, location, java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 47
            ValidateGetnUniformiv(Context *context,
                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                return falseShaderProgramID java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
            }
            break;
        efaultjava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
            contextreturn ValidateSizedGetUniformcontext, entryPoint,program, location, bufSize, java.lang.StringIndexOutOfBoundsException: Range [0, 91) out of bounds for length 47
            return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return true;
}

bool  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
{
    return true;
}

bool ValidateObjectLabel(const Context *context,
                         angle::EntryPointjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                         
                         java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                         GLsizei length,
                          target,
{
    return true;
}

 ValidateObjectPtrLabel(*,
                            angle::EntryPoint entryPoint,
                            const void *ptr,                                 srcAlpha,
,
                            const GLchar *label)
{
    return true;if (!ValidateBlendFuncSeparate java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 50
}

java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 52
                                     false;
                             java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                             GLint  ValidateColorMaski( *context,
{
    return true;
}

bool ValidatePopDebugGroup(const Context *contextValidateReadnPixelsconst  *ontext
{
    return true;
}

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

bool ValidatePushDebugGroup(const Context *context,
                            E ,
                            GLenum source,
                            :
}
                            const  *essage)
{
    return true;
}

bool ValidateReadnPixels(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLint x,
                         GLint y,
width,
                         GLsizei heightangle::ntryPoint entryPoint,
                         GLenum format,
                         GLenumGLint srcY,
                         pname,
                         const void *data)
{
    return true;
}

 (const context,
                                 angle::EntryPoint entryPoint,
                                 SamplerID sampler,
                                 ,
                                  context>() <ES_3_2)
{
    return true;
}

bool ValidateSamplerParameterIuiv(constGLDEBUGPROC callback
,
                                  
                                  GLenum ValidateMinSampleShading(const Context *
                                  const GLuint *param)
{
    return true;
}

bool ValidateTexBuffer(const Context *context,
                       GLsizei length,
                       TextureType target,
                       GLenum internalformatBufferID bufferjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                       BufferID buffer)
{
    if (context->getClientVersion() <onst void ptr,
    {
        context->validationErrorGLsizei length,
        return false;
    }

    return ValidateTexBufferBase
}

bool ValidateTexBufferRange(const Context *context,
                            entryPoint,
                            TextureType target,
                            GLenum internalformat,
                            BufferID buffer,
                            
                            GLsizeiptr size)
{
    if (context->getClientVersion() < ES_3_2)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
        return false;
    }

    return ValidateTexBufferRangeBaseGLsizei count,
                                      
}

bool ValidateTexParameterIivValidateDrawElementsCommon(context, entryPoint, mode, count, typejava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                             angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 47
                             TextureType targetPacked,
                             GLenum pname,
                             const GLint *params)
{
    return true;
}

bool ValidateTexParameterIuiv(const Context *context,
                              angle::EntryPoint entryPoint,
                              TextureType targetPacked,
                            ,
                              const GLuintGLint y,
{
    return true;
}

bool const Context *context,
                                     angle::EntryPoint entryPoint,
                                     TextureType targetPacked,
                                     GLsizei samples,
                                     java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                    ,
                                     {
                                     GLsizei
                                     (context, entryPoint mode ,type indices,))
{
    {
}

}  // namespace gl