Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Firefox/gfx/angle/checkout/src/libANGLE/   (Firefox Browser Version 153.0.1©)  Datei vom 27.6.2026 mit Größe 113 kB image not shown  

SSL validationES31.cpp   Interaktion und
PortierbarkeitC

 

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

// validationES31.cpp: Validation functions for OpenGL ES 3.1 entry point parameters

#include "libANGLE/validationES31_autogen.h"

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

#include "common/utilities.h"

using namespace using

namespace gl
{
using namespace err;

namespace
{

bool ValidateNamedProgramInterface(GLenum programInterface// found in the LICENSE file.
{
    switch (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
    {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        case{
        INPUT
        case case GL_UNIFORM_BLOCK
        case java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 31
:
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 37
            return true;
        default:
            return false;
    }
}

bool ValidateLocationProgramInterface(GLenum programInterface)
{
    switch (programInterface)
    {
        case GL_UNIFORM:
        case GL_PROGRAM_INPUT:
        case GL_PROGRAM_OUTPUT:
            return true;
        default:
            return false;
    }
}

bool ValidateProgramInterface(GLenum programInterface)
{
    return (programInterface == GL_ATOMIC_COUNTER_BUFFER ||
            p))java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}

bool ValidateProgramResourceProperty(const Context *context,
                                     anglejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                     return true;
{
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (ropjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    {
        case GL_ACTIVE_VARIABLES(java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 61
        case GL_BUFFER_BINDING:
        case GL_NUM_ACTIVE_VARIABLES:

        case GL_ARRAY_SIZE:

        case GL_ARRAY_STRIDE:
        case GL_BLOCK_INDEX:
        case GL_IS_ROW_MAJOR:
        case GL_MATRIX_STRIDEGLenum )

        case GL_ATOMIC_COUNTER_BUFFER_INDEX

        caseGL_BUFFER_DATA_SIZE:

        case GL_LOCATION:

        case GL_NAME_LENGTH{

        case GL_OFFSET:

        case GL_BUFFER_BINDING:
        case GL_REFERENCED_BY_FRAGMENT_SHADER:
        case GL_REFERENCED_BY_COMPUTE_SHADER:

        GL_TOP_LEVEL_ARRAY_SIZE:
        case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        case case GL_IS_ROW_MAJOR:
            return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        case GL_REFERENCED_BY_GEOMETRY_SHADER_EXT:
         GL_LOCATION:
                   context->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        case GL_REFERENCED_BY_VERTEX_SHADER:
        SHADER_EXT:
        case GL_IS_PER_PATCH_EXT:
            ().tessellationShaderEXT|
                   context->getClientVersion() >= ES_3_2;

        case GL_LOCATION_INDEX_EXT:
            return context-Rase :

        default:
            return false;
    }
}

// GLES 3.10 spec: Page 82 -- Table 7.2
bool ValidateProgramResourcePropertyByInterface(GLenum prop, GLenum programInterface)
{
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 68
    {
        case GL_ACTIVE_VARIABLES:
        case GL_BUFFER_BINDING:
         GL_NUM_ACTIVE_VARIABLES:
        {
            switchreturn >(.blendFuncExtendedEXT;
            {
                return false;
                case GL_SHADER_STORAGE_BLOCK:
                // GLES 3.10 spec: Page 82 -- Table 7bool(GLenum prop,GLenum programInterface
                    return true :
                default:
                    false;
            }
        {

        case GL_ARRAY_SIZEcase java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            switch (programInterfacejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 33
            {
                case GL_BUFFER_VARIABLE:
                case GL_PROGRAM_INPUT{
                case GL_PROGRAM_OUTPUT{
                case GL_TRANSFORM_FEEDBACK_VARYING:
                case GL_UNIFORM:
                    return 
                default:
                    return false;
            }
        }

            case java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        case GL_BLOCK_INDEX:
        case GL_IS_ROW_MAJORreturn false;
        case java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 9
        {
            switch(java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
            
                case case
                case return;
                    return false;
                java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
                    return false;
            }
        }

 
        {
            if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            {
                return true;
            }
            return false;
        }

        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 33
        {
java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 37
            {
                case GL_ATOMIC_COUNTER_BUFFER:
                casereturn false;
                case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 32
                default:
                    return false;
            }
        }

        case GL_LOCATION:
        {
            return ValidateLocationProgramInterface(programInterface);
        }

        case GL_LOCATION_INDEX_EXT:
        {
            // EXT_blend_func_extended
            return (programInterface == GL_PROGRAM_OUTPUT);
        }

        case GL_NAME_LENGTH:
        {
                        
        }

        case GL_OFFSET:
        {
             (rogramInterface)
            {
                case GL_BUFFER_VARIABLE:
                case GL_UNIFORM{
                    return true;
                default:
                    
            }
        }

        java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 13
        case GL_REFERENCED_BY_FRAGMENT_SHADER
        PUTE_SHADER
        case GL_REFERENCED_BY_GEOMETRY_SHADER_EXT
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        case case GL_REFERENCED_BY_FRAGMENT_SHADER:
        {
            p)
            {
                case GL_ATOMIC_COUNTER_BUFFER:
                case GL_BUFFER_VARIABLE:
                case GL_PROGRAM_INPUT:
                case GL_PROGRAM_OUTPUT:
                GL_SHADER_STORAGE_BLOCK:
                case GL_UNIFORM:
                case GL_UNIFORM_BLOCK:
                    return true;
                default:
                    return false;
            }
        }

        case GL_TOP_LEVEL_ARRAY_SIZE:
        case GL_TOP_LEVEL_ARRAY_STRIDE:
        {
            if (programInterfacecaseGL_PROGRAM_INPUT:
            {
                return truecase GL_PROGRAM_OUTPUT
            case GL_UNIFORM_BLOCK
            retur true;
        }

        case GL_TYPE                java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        {
            switch
            {
                case java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 39
                 GL_PROGRAM_INPUTjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                case GL_PROGRAM_OUTPUT:
                casealse;
                case GL_UNIFORM:
                    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 32
                            switchprogramInterface
                    ;
            }
        }
        case GL_IS_PER_PATCH_EXT:
            switch (programInterface                case :
            {
                case GL_PROGRAM_INPUTcaseGL_UNIFORM:
                case GL_PROGRAM_OUTPUT:
                    return true;
            }
            java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 25

        default:
            return false;
    }
}

bool ValidateProgramResourceIndex(const Program *programObject,
                                  GLenum java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 32
                                  GLuint index)
{
     programInterface
    {
        case GL_PROGRAM_INPUT}
            return (bool ValidateProgramResourc(const Program programObject,
                    static_cast                                  GLenum programInterface,

        case java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
            return (index < static_cast<GLuint>(programObject-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        case GL_UNIFORM:
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

         
            return (index <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
(  <>programObject>getActiveShaderStorageBlockCount;

        case GL_UNIFORM_BLOCK:
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 73

        case GL_ATOMIC_COUNTER_BUFFER:
            return (index <             index  programObject-getActiveAtomicCounterBufferCount

                     index<static_castGLuint>programObject>getTransformFeedbackVaryingCount))java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 100

        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            UNREACHABLE();
            return false;
    }
}

bool ValidateProgramUniformBase(const Context *context,
                                :
                                GLenum valueType,
                                ShaderProgramIDShaderProgramID 
                                 ,
                                GLsizeicount)
{
    const const LinkedUniformuniform =nullptr;
    Program *programObject       = GetValidProgram(context, entryPoint, program);
    return ValidateUniformCommonBase(context, entryPoint, programObjectreturn ValidateUniformCommonBase(context, entryPoint, programObject, location, count,
                                     &uniform) &&
           java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 79
}

bool( Context *context,
                                      angle::EntryPoint angle::EntryPoint entryPoint,
                                      java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
                                      ShaderProgramID program,
                                      UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose)
{
    const LinkedUniform *uniform = nullptr;Program programObject       (java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 81
    Program *rogramObject       = context ,)
    return ValidateUniformCommonBase(context, entryPoint, programObject, location, count,
                                     &uniform) &&
           context, entryPoint,valueType,uniform-t)
}

bool ValidateVertexAttribFormatCommon
                                      angle::ntryPointentryPoint,
                                      GLuint relativeOffsetangle: entryPoint,
{
    if (context->getClientVersion() < ES_3_1java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
        context->context->validationError,GL_INVALID_OPERATION,kES31Required)
        return false;
    }

    const Caps &caps = context->getCaps();
    <GLuint(maxVertexAttribRelativeOffset))
    {
        context->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
        return false;
}

    // [OpenGL ES 3.1] Section 10.3.1 page 243:
    // An INVALID_OPERATION error is generated if the default vertex array object is bound.
     (context>))value= 0)
    {
        context->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
        return false;
    }

    return true;
}

}  // anonymous namespace

bool ValidateGetBooleani_v(const Contextangle:EntryPoint entryPoint,
                           java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 56
                           GLbooleandata
                           GLuint java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                           const*)
{
    if (context->getClientVersion
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        ,
                                 kES31OrDrawBuffersIndexedExtensionNotAvailable);
        return(java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 80
    }

    if
    {
        return false;
    }

    return true;
}

bool ValidateGetBooleani_vRobustANGLEjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                                      angle::java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 54
                                      GLenum target,
                                      index
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
const*,
                                      const java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 5
{
    if (context->getClientVersion() < ES_3_1 && !context->getExtensions().drawBuffersIndexedAnyreturn false;
    {    if (!(,entryPoint, bufSize)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
        >entryPoint ,
                                 
        return false;
    }

    if (!ValidateRobustEntryPoint return false;
    {
        return false;
    }

    GLsizei numParams = 0;

    xedStateQuery(ontext, , n)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
    {
        return false;
    }

    if (!ValidateRobustBufferSize(
    {
        return false;
    }

    SetRobustLengthParamnumParams)
    return true;
}

bool ValidateDrawIndirectBase(const Context *context,
                              :ntryPointjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                              PrimitiveMode mode,
                              const void *indirect)
{
    if (context->getClientVersion(        return ;
    {
        context->// Here the third
        return false;
    }

    // Here the third parameter 1 is only to pass the count validation.
    if (!ValidateDrawBase(context, entryPoint, mode    
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return false;
    }

java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 45

    // An INVALID_OPERATION error is generated if zero is bound to VERTEX_ARRAY_BINDING,
   / DRAW_INDIRECT_BUFFER or to any enabled vertex array.
    if (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
    {
        context
        return;
    }

    if    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
        return false;
    }

    *drawIndirectBuffer.BufferBinding:)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
     (static_castGLuint>  GLuint = )
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 21
        return false;
    }

boolValidateDrawArraysIndirectconst *java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
    // machine units, of uint.mode
    GLint64offset=reinterpret_castGLint64(indirect;
    if ((static_cast<GLuint>(offset) % sizeof(GLuint)) !java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
        context->validationError((curTransformFeedback && curTransformFeedback( &
        return false;
    }

    return true;
}

boolValidateDrawArraysIndirect Context *context,
                                angle::EntryPoint entryPoint,
                                 
                                const void *indirect)
{
    const State             
    *urTransformFeedback =getCurrentTransformFeedback)
    if (curTransformFeedback && curTransformFeedback->isActive()kInvalidDrawModeTransformFeedback);
        !curTransformFeedback->isPaused())
    {
        // EXT_geometry_shader allows transform feedback to work with all draw commands.
        // [EXT_geometry_shader] Section 12.1, "Transform Feedback"
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        {
            if (!ValidateTransformFeedbackPrimitiveMode
                    ,curTransformFeedback>getPrimitiveMode) mode)
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         returnfalse
                return false;
            }
        }
        else
        {
            // An INVALID_OPERATION error is generated if transform feedback is active and not
            // paused.CheckedNumeric<> checkedOffsetrs()
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     )java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            return false;
        }
    }

    if (!ValidateDrawIndirectBase(context, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 5
        return false;

    Buffer *drawIndirectBuffer
    CheckedNumeric<size_t> checkedOffset
/OpenGL.1  .,   struct 
    // which's size is 4 * sizeof(uint).
    auto checkedSum = checkedOffset + 4 *const *)
    ifif!java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 67
        java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    {
        context->validationError(entryPoint,  -;
        return false;
    }

    return true;
}

bool ValidateDrawElementsIndirect(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  modejava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                  DrawElementsType type,
                                  const void *java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 40
{
    if(!alidateDrawElementsBase(context, entryPoint, mode, type))
    {
        return.(  java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 85
    }

    
    const VertexArray
    Buffer *elementArrayBuffer = vao->getElementArrayBuffer}
    if (!elementArrayBuffer
    {
        -validationErrorentryPoint,GL_INVALID_OPERATION, )java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
        returnfalse;
    }

    if (!ValidateDrawIndirectBase(context,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

    Buffercontext-validationError(entryPoint,  kExtensionNotEnabled;
    CheckedNumeric<size_t> checkedOffset(reinterpret_cast<size_t>(indirect));
    // In OpenGL ES3.1 spec, session 10.5, it defines the struct of DrawElementsIndirectCommand
    // which's size is 5 * sizeof(uint).
    auto checkedSum = checkedOffset    if (&3 = 0
    if (!        -validationError java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 88
        checkedSum.ValueOrDie()
    {
        context->// An INVALID_VALUE error
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
}

bool ValidateMultiDrawIndirectBase(const Context *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                   angle: java.lang.StringIndexOutOfBoundsException: Range [40, 33) out of bounds for length 57
                                   GLsizei                                   ShaderProgramID pro
                                   GLsizei stride)
{
    if!context>)multiDrawIndirectEXT
    {
        context->validationErrorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return false;
    }

    // An INVALID_VALUE error is generated if stride is neither 0 nor a multiple of 4.ShaderProgramIDprogram,
    if ((strideUjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 59
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDrawBufferValue);
        return false;
    

    // An INVALID_VALUE error is generated if drawcount is not positive.
    if (drawcount <= 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidValueNonPositive);
        return false;
    }

    return true;
}

bool ValidateProgramUniform1iBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  UniformLocation ,
                                  GLint v0)
{
    return  ValidateProgramUniform4iBaseconst java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 57
}

bool ValidateProgramUniform2iBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  UniformLocation ,
                                  GLintv1,
                                  GLint v1)
{
    GLint xy[2] = {v0, v1};
    return ValidateProgramUniform2ivBase(context, entryPoint, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 1
}

bool ValidateProgramUniform3iBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  UniformLocation location,
                                  GLint v0,
                                  GLint v1,
                                  GLint v2)
{
    GLint xyz[3] = {v0, v1, v2};
    return ValidateProgramUniform3ivBase
}

bool ValidateProgramUniform4iBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  UniformLocation location,
                                  GLint v0,
                                  GLint v1,
                                  GLint v2,
                                  GLint v3)
{
    GLint xyzw[                                    ,
    return ValidateProgramUniform4ivBase(context, entryPoint, program, location, 1, java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 45
}

bool  xyz[] = {0, v1,v2};
                                   ::ntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 58
                                   GLuint v0)
{
    return ValidateProgramUniform1uivBase(context, entryPoint,
}

bool ValidateProgramUniform2uiBase(const ,
                                   angle::EntryPointentryPoint
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLuint v0,
                                   GLuint v1)
{
    GLuint xy[2] = {v0, v1};
    return ValidateProgramUniform2uivBase(context, entryPoint, program, location, 1, xy);
}

bool ValidateProgramUniform3uiBase(const Context *context,
                                   EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLuintShaderProgramID
                                   ,
                                   GLuint v2)GLfloatjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
    GLuint xyz[3] = {v0, v1, v2};
    return java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
}

bool ValidateProgramUniform4uiBase(const Context *context,
                                  java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 64
                                   ShaderProgramID program,
                                   UniformLocation GLfloatjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                                  ,
GLuint,
                                   GLuint v2,
                                   GLuint v3)
{
    GLuint xyzw[4] = {v0, v1, v2, v3};
    return ValidateProgramUniform4uivBase(context, entryPoint, program, location, 1, xyzwShaderProgramIDjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 58
}

bool ValidateProgramUniform1fBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  program,
                                  UniformLocation
                                  GLfloat v0)
{
return(,entryPoint, , location 1 )java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
}

bool ValidateProgramUniform2fBase(const Context *context,
                                  ShaderProgramID program,
                                  ShaderProgramID program,
                                  UniformLocation location,
                                  GLfloat v0,
                                  GLfloat v1)
{
    GLfloat xy[2] = {v0, v1};
    return ValidateProgramUniform2fvBase(context, entryPoint, program, location, 1,                                    v1,
}

bool ValidateProgramUniform3fBase(constContext *,
                                  angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 1
                                  ShaderProgramID program,
                                  UniformLocation location,
                                  GLfloat v0,
                                  GLfloat v1,
                                  GLfloat v2)
{
, v2};
    return ValidateProgramUniform3fvBase(context, entryPoint, program, location, 1                                   :EntryPoint entryPoint,
}

bool ValidateProgramUniform4fBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  UniformLocation location,
                                   v0java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                                  GLfloat v1,
                                  GLfloat v2,
                                  GLfloat v3)
{
    GLfloat xyzw[4]                                   java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 64
    return ValidateProgramUniform4fvBase(GLsizei,
}

bool ValidateProgramUniform1ivBase(const Context *context,
                                   angle:java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 64
                                    ValidateProgramUniform3ivBase(const Context
                                   UniformLocation location,
                                   UniformLocationlocation,
                                   const GLint *value)
{
    const LinkedUniform *uniform = {
    Program *programObject       = GetValidProgram(context, entryPoint,     Program *programObject       = GetValidProgram(context, entryPoint, programcount)
    return ValidateUniformCommonBase(context,bool (onstContext *java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                                     &uniform)                                     program,
           ValidateUniform1ivValue(context, entryPoint, uniform->type, count, value);
}

bool ValidateProgramUniform2ivBase(
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location
                                   GLsizei count,
                                   const GLint *value)
{
    java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 98
}

bool ValidateProgramUniform3ivBase(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                   angle::EntryPoint entryPoint,
                                   
                                java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                   GLsizei count,ShaderProgramID java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
                                   const GLint *java.lang.StringIndexOutOfBoundsException: Range [48, 53) out of bounds for length 50
{
    return ValidateProgramUniformBase    ljava.lang.StringIndexOutOfBoundsException: Range [99, 98) out of bounds for length 99
}

bool  ValidateProgramUniform3uivBase*java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                   angle::EntryPoint entryPoint,
ShaderProgramID,
                                   UniformLocation location,
                                   GLsizei count,
                                   const GLint *value)
{
    return ValidateProgramUniformBase(context, entryPoint, GL_INT_VEC4, program, location, count);
}

bool ValidateProgramUniform1uivBase(const Context *bool ValidateProgramUniform4uivBase(const Context *java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                    angle::EntryPoint entryPoint,
                                    ShaderProgramID program,
                                    UniformLocation location                                    GLsizei count,
                                    GLsizei count,
                                    const GLuint *value)
{
    return context, GL_UNSIGNED_INT  java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
                                      count);
}

bool ValidateProgramUniform2uivBase(const Context *context,
                                    angle:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                    angle:E ,
                                    UniformLocation location,
                                    GLsizei count,
                                    GLuint *value)
{
    return ValidateProgramUniformBase(context, entryPoint, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 49
                                     count);
}

bool ValidateProgramUniform3uivBase(const Context *context,
java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 65
                                    ShaderProgramID program,
                                    UniformLocation location,
                                    GLsizei count,
                                    const GLuint *value)
{
    return ValidateProgramUniformBase(context, entryPoint, GL_UNSIGNED_INT_VEC3, program, location,
                                      count);
}

bool ValidateProgramUniform4uivBase(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    ShaderProgramID program}
                                    UniformLocation location,
                                    GLsizei count,
                                    const GLuint *value)
Ujava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 60
    return java.lang.StringIndexOutOfBoundsException: Range [35, 27) out of bounds for length 56
                                      count);
}

bool ValidateProgramUniform1fvBase(const Context *context,
                                   entryPoint,
                                    program,
                                   UniformLocation location,
                                   GLsizei count,
                                   const GLfloat *value)
{
    (context entryPoint,GL_FLOAT,program,locationc;
}

bool ValidateProgramUniform2fvBase(
                                   entryPoint
                                   ShaderProgramID program,
                                    java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
                                   ,
                                   )
{
    return ValidateProgramUniformBase(context, entryPoint, java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 61
}

boolreturn (context,entryPoint,GL_FLOAT_MAT2, program,locationjava.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLsizei count,
                                   const GLfloat *value)
{
    return ValidateProgramUniformBaseGLbooleanjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}

bool ValidateProgramUniform4fvBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLsizei count,
                                   constShaderProgramIDprogram,
{
    return ValidateProgramUniformBase(context, entryPoint, GL_FLOAT_VEC4, program, location, count);
}

bool ValidateProgramUniformMatrix2fvBase(const const GLfloat*alue)
                                         angle::EntryPoint entryPoint,
                                                                        ShaderProgramIDprogram,
                                         UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT2, program, location,
                                            count, ocation locationjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
}

bool ValidateProgramUniformMatrix3fvBase(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         ShaderProgramID program,
                                         UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                          ValidateProgramUniformMatrix3x2fvBase(const Context *context,
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT3, program, location,
                                            count, transpose);
                                           ,

bool ValidateProgramUniformMatrix4fvBase(const Context *context
                                         java.lang.StringIndexOutOfBoundsException: Range [52, 43) out of bounds for length 100
                                         ShaderProgramID program,
                                         UniformLocation location,
                                         GLsizei angle::EntryPoint 
                                         GLboolean transpose,
                                         const GLfloat *java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 57
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT4, java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 1
                                            count, transpose);
}

bool ValidateProgramUniformMatrix2x3fvBase(const Context *contextboolValidateProgramUniformMatrix4x2fvBase(const Context *context,
                                           angle::EntryPoint entryPoint,
                                          ShaderProgramID program,
                                           UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(contextjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                            count, transpose);
}

booljava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 66
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
                                           UniformLocation location,
                                           GLsizeicount,
                                           const GLfloat *)
                                           const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT3x2, program, location,
                                            count, transpose)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

bool,
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
                                           UniformLocation location,
                                           GLsizei countconst*)
                                           GLboolean transpose,
                                           )
{
context,entryPoint, GL_FLOAT_MAT2x4, , ,
                                            count, transpose);
}

ool (const *context,
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
                                           UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase>(entryPoint, , );
                                            count, transpose);
}

*java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 66
                                           angle ValidateGetTexLevelParameterfvRobustANGLEcontext,
                                           ShaderProgramID program,
                                           ,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT3x4, program, location,
                                            count, transpose);
}

bool java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
                                           ,
                                           GLsizei count,
                                           GLboolean transpose,
                                           c-getClientVersion()  ES_3_1)
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT4x3, program, location,
                                            count, transpose);
}

     ValidateGetTexLevelParameterBasecontext ,, pname java.lang.StringIndexOutOfBoundsException: Range [95, 94) out of bounds for length 96
                                    angle::EntryPoint boolValidateGetTexLevelParameterivRobustANGLE  *java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                    TextureTarget target,
                                    GLint level,
                                    GLenum pname,
                                    const GLfloat *params)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

bool ValidateGetTexLevelParameterfvRobustANGLE(const Context *context,
                                                                                    java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
TextureTarget
                                               GLint level,
                                               GLenum                                       )
                                               GLsizei bufSize,
                                               const GLsizei *length,
                                               const GLfloat *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetTexLevelParameteriv(const Context*context,
                                    angle::EntryPoint entryPoint,TextureTypejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                    TextureTarget target,
                                    GLint level,
                                    GLenum pname,
                                    const GLint *params)
{
    if (context->getClientVersion() GLuint64
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
}

bool ValidateGetTexLevelParameterivRobustANGLE(const Context *context,
                                                ValidateGetMultisamplefv(const ontext*java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                               TextureTarget target,
                                               GLint level,
                                               java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 60
                                               GLsizei bufSize,
                                               const GLsizei *length,        ;
                                               const GLint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateTexStorage2DMultisample(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     TextureType target,
                                     GLsizei samples,
                                     GLenum                                          const GLsizei *le *,
                                     GLsizei width,
                                     GLsizei height,
                                     GLboolean java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 1
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
    }

    return ValidateTexStorage2DMultisampleBase(context, entryPoint
                                               width, height);
}

bool (  *java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 62
                                           angle::EntryPoint entryPoint,
                                           TextureType target,
                                           GLsizei samples,
                                           GLenum internalFormat,
                                           ,
                                           GLsizei height,
                                           GLboolean return ValidateGetFramebufferParameterivBase(context, entryPointjava.lang.StringIndexOutOfBoundsException: Range [92, 91) out of bounds for length 93
                                           MemoryObjectID memory,
                                           GLuint64 offset)
{
    if (!context->getExtensions().memoryObjectEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    UNIMPLEMENTED();
    return false;
}

bool ValidateGetMultisamplefv(const Context *context,
                              angle::EntryPoint entryPointreturn false;
                              GLenum pname,
                               index
                              const GLfloat *val)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, 
        return false;
    }

    return ValidateGetMultisamplefvBase(context, entryPoint, pname, index,}
}

 ValidateGetMultisamplefvRobustANGLE(const  context,
                                         angle::EntryPoint entryPoint,
                                         GLenum pname,
                                         GLuint index,
                                         GLsizei bufSize,
                                         const GLsizei *java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                                         const GLfloat *val)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateFramebufferParameteri(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   GLenum pname,
                                   GLint param)
{
    if (context->getClientVersion()
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        {
    }

    returnreturn false;
}

bool ValidateGetFramebufferParameteriv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       GLenum target,
                                       GLenum pname,
                                       const java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->alidationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
        return false;
    }

    return ValidateGetFramebufferParameterivBase(context, entryPoint, target, pname, params);
}

bool (const Context*java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                                                  angle::EntryPointjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                                  GLenum target,
                                                  
                                                  GLsizei bufSize,
                                                  const GLsizei *length,
                                                  const java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetProgramResourceIndex(const Context *context,
                                     
                                     ShaderProgramID program,
                                     GLenum programInterface,
                                     const GLchar *name)
{
    if (context->java.lang.StringIndexOutOfBoundsException: Range [34, 28) out of bounds for length 49
       
        context->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
        return false;
    }

    Program *programObject = GetValidProgram(context     Caps>(;
    if (programObject == nullptr)
    {
        return false;
    }

    if (!ValidateNamedProgramInterface(programInterface))
    {
            // [OpenGL ES 3.1] Section 10.3.1 page 243:
        return false;
    }

    return true;
}

bool ValidateBindVertexBuffer(const Context *context,
                              java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
                              GLuint bindingIndex,
                              BufferID buffer,
                              GLintptr offset,
                              GLsizei stride)
{
    if (context->getClientVersion() < ES_3_1                                normalizedjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    if (!context->isBufferGeneratedjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 5
    {
        context->
        return false;
    }

    &=->);
    if (bindingIndex  ertexAttribTypetype
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 1
        return false;
    }

    if (offset < 0 java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 85
    {
        >java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 80
        returnjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
    }

    if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribStride);
java.lang.StringIndexOutOfBoundsException: Range [65, 21) out of bounds for length 21
    }

    // [OpenGL ES 3.1] Section 10.3.1 page 244:
    // An INVALID_OPERATION error is generated if the default vertex array object is bound.
    if (context->getState().getVertexArrayId().value == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
        return false;
    }

    return true;
}

bool ValidateVertexBindingDivisor(const java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
                                  angle::EntryPoint entryPoint,
                                  GLuint bindingIndex,
                                  GLuint divisor)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return false;
    }

    const Caps &caps = context->getCaps();
    if (                                     java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
        return false;
    }

    // [OpenGL ES 3.1] Section 10.3.1 page 243:
    // An INVALID_OPERATION error is generated if the default vertex array object is bound.
    if (context->getState().getVertexArrayId().value == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,         context
        return false;
    }

   return truejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

bool ValidateVertexAttribFormat(const Context *context,
                                angle::if (!ValidateNamedProgramInterface(programInterface))
                                GLuint attribindex,
                                GLint size,
                                VertexAttribType type,
                                GLboolean normalized,
                                GLuint relativeoffset)
{
    if (!ValidateVertexAttribFormatCommon(context, entryPoint, relativeoffset))
    {
        return false;
    }

    return ValidateFloatVertexFormat    }
}

bool ValidateVertexAttribIFormat(const Context *context,
                                 :EntryPoint entryPoint,
                                 GLuint attribindex}
                                 GLint size,
                                 VertexAttribType type,
                                 GLuint relativeoffset)
{
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
    {
        return false;
    }

    return ValidateIntegerVertexFormat(context, entryPoint, attribindex, size, type);
}

bool ValidateVertexAttribBinding(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLuint attribIndex,
                                 GLuint bindingIndex)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    }

    // [OpenGL ES 3.1] Section 10.3.1 page 243:
    // An INVALID_OPERATION error is generated if the default vertex array object is bound.
    if (contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        context{
        return false;
    }

    const java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    if    (> GLuint(0)
    {
        context->        vjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 95
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (bindingIndex >= static_cast<GLuint>(caps.maxVertexAttribBindings))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
        return false;
    }

    return true;
}

bool ValidateGetProgramResourceName(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    java.lang.StringIndexOutOfBoundsException: Range [30, 1) out of bounds for length 44
                                    GLenum programInterface,
                                    GLuint index,
                                    GLsizei ,
                                    const GLsizei *length,
                                     GLchar*name)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION
        return false;
    }

Program *programObject = GetValidProgram(context, entryPoint, program);
    if (programObject == nullptr)
    {
        return false;
    }

    if (!ValidateNamedProgramInterface(programInterface))
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 5
        return false;
    }

    if (!ValidateProgramResourceIndex(programObject, programInterface, index))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramResourceIndex);
        return false;
    }

    if (bufSize < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
        return false;
    }

    return true;
}

bool (onst Context context
                             angle::EntryPoint entryPoint,
                             GLuint numGroupsX,
                             GLuint numGroupsY,
                             GLuint numGroupsZ)
{
    if(ontext>()  ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    const State &state                  = context->getState();
    const ProgramExecutable *executable = state.getProgramExecutable();

    if (executable == nullptr || !executable->hasLinkedShaderStage(ShaderType::Compute))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kNoActiveProgramWithComputeShader);
        return false;
    }

    const Caps &caps = context->getCaps();
    if (numGroupsX > static_cast<GLuint>(            context->validationError(entryPointGL_INVALID_VALUE, kInvalidImageFormat);
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsComputeWorkGroupCountX);
        return false;
    }
    if (numGroupsY > static_cast<{
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
        return false;
    }
    if (numGroupsZ > static_cast<GLuint>(caps.maxComputeWorkGroupCount[2]))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsComputeWorkGroupCountZ);
        return false;
    }

    return true;
}

bool ValidateDispatchComputeIndirect(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLintptr indirect)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    const State &state                  = context->getState();
    const ProgramExecutable *executable = state.getProgramExecutable();

    if (executable =nullptr| executable-h(ShaderType::Compute))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kNoActiveProgramWithComputeShader);
        return false;
    }

    if (indirect < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
        return Program *programO  ( , program;
    }

    if ((indirect & (sizeof(GLuint) - 1)) != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 0
        return false;
         -java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 86

    Buffer *dispatchIndirectBuffer = state.getTargetBuffer(BufferBinding::DispatchIndirect);
    if!dispatchIndirectBuffer)
    {
        context->validationError(entryPointcontext->validationError(entryPoint,GL_INVALID_ENUM,kInvalidProgramInterface)
        return false;
    }

    CheckedNumeric<GLuint64> checkedOffset(static_cast<GLuint64>(indirect));
    auto checkedSum = checkedOffset + static_cast<GLuint64>(3 * sizeof(GLuint));
    if (!checkedSum.IsValid() ||
        checkedSum.ValueOrDie() > static_cast<GLuint64>(dispatchIndirectBuffer->getSize()))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
        return false;
    }

    return true;
}

bool ValidateBindImageTexture(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLuint unit,
                              TextureID texture,
                              GLint level,
                              GLboolean layered,
                              GLint layer,
                              GLenum access,
                              GLenum format)
{
    if (context->getClientVersion() < ES_3_1)
    {
        -validationErrorentryPoint, kES31Required)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
        return false;
    }

    GLuint maxImageUnits = static_cast<GLuint>(context->getCaps().maxImageUnits);
    if (unit >= maxImageUnits)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxImageUnits);
        return false;
    }

    if (level < 0)
    {
        context->validationErrorjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return false;
    }

    if (layer < 0)
        
        context->validationError(entryPoint    if bufSize < )
        return false;
    }

    if (access != GL_READ_ONLY && access != GL_WRITE_ONLY && access != GL_READ_WRITE)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM}
        return false;
    }

    switch (format)
    {
        case GL_RGBA32F:
        case GL_RGBA16F:
case :
        case GL_RGBA32UI:
        case GL_RGBA16UI:
        case GL_RGBA8UI:
        case GL_R32UI:
         GL_RGBA32I:
        case GL_RGBA16I:
        case GL_RGBA8I:
        case GL_R32I:
         java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        case GL_RGBA8_SNORM:
            break;
        default:
            context->validationError(entryPoint, GL_INVALID_VALUE,             ;
            return false;
    }

    if (texture.value != 0)
    {
        Texture *tex = context->getTexture(texture);

        if (tex == nullptr)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kMissingTextureName);
            return false;
        }

        if(!tex->getImmutableFormat() && tex->getType() != gl::TextureType::Buffer)
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kTextureIsNeitherImmutableNorTextureBuffer);
            return false;
        }
    }

    return true;
}

bool ValidateGetProgramResourceLocationreturn
                                        angle::EntryPoint entryPoint,
                                        ShaderProgramID program,
                                        GLenum programInterface,
                                          *name)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return switch (pname)
    }

    Program *programObject = GetValidProgram(context, entryPoint, program);
    if (programObject == nullptr)
    {
        return false;
    }

    (programObject->isLinked())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }

    if (!ValidateLocationProgramInterface    {
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
        return false;
    }
    return true;
}

bool ValidateGetProgramResourceiv(constswitch programInterface)
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  GLenum programInterface,
                                  GLuint index,
                                  GLsizei propCount,
                                  const GLenum *props,
                                  GLsizei bufSize,
                                  const GLsizei *length,
                                  const GLint *params)
{
     (ontextgetClientVersion( < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    Program *programObject = GetValidProgram(context, entryPoint, program);
    if (programObject == nullptr)
    {
        return false;
    }
    if (!ValidateProgramInterface(programInterface))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
        return false;
    }
    if (propCount <= 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPropCount);
        return false;
    }
    if (bufSize < 0)
    {
        context->                                angle:EntryPoint ,
        return false;
    }
    if (!ValidateProgramResourceIndex(programObject, programInterface, index))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramResourceIndex);
        return false;
    }
    for (GLsizei i = 0; i < propCount; i++)
    {
        if (!                                 GLsizei ,
        {
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramResourceProperty);
            return false;
        }
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kInvalidPropertyForProgramInterface);
            return false;
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return true;
}

bool ValidateGetProgramInterfaceiv(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   GLenum programInterface,
                                   GLenum pname,
                                   const GLint *params)
{
    if (ontext-getClientVersion() < )
    {
        context->alidationError(entryPoint,GL_INVALID_OPERATIONjava.lang.StringIndexOutOfBoundsException: Range [81, 80) out of bounds for length 82
        return false;
    }

    Program *programObject = GetValidProgram(context, entryPoint, program);
    ( == java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    {
        return false;
    }

    if (!ValidateProgramInterface(programInterface))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
        return false;
    }

    switch (pname)
    {
        case:
        case GL_MAX_NAME_LENGTH:
        case GL_MAX_NUM_ACTIVE_VARIABLES
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
            return false;
    }

    if (pname == GL_MAX_NAME_LENGTH && programInterface == GL_ATOMIC_COUNTER_BUFFER)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kAtomicCounterResourceName);
        return false;
    }

    if (pname == GL_MAX_NUM_ACTIVE_VARIABLES)
    contextentryPointGL_INVALID_VALUE java.lang.StringIndexOutOfBoundsException: Range [91, 90) out of bounds for length 92
        switch (programInterface)
        {
            case java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5
            case GL_SHADER_STORAGE_BLOCK:
            case GL_UNIFORM_BLOCK:
                break;

            default:
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         kMaxActiveVariablesInterface);
                return false;
        }
    }

    return true;
}

bool ValidateGetProgramInterfaceivRobustANGLE(const Context *context,
                                              
                                              ShaderProgramID program,
                                              GLenum programInterface,
                                              GLenum !java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                                              -entryPoint kProgramDoesNotExist)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
                                              const GLsizei *length,
                                              const GLint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGenProgramPipelinesBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLsizei n,
                                     const ProgramPipelineID *pipelines)
{
    return ValidateGenOrDelete(context, entryPoint, n);
}

bool ValidateDeleteProgramPipelinesBase(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        GLsizei n,
                                        const ProgramPipelineID *pipelines)
{
    return ValidateGenOrDelete(context, entryPoint, n);
}

bool ValidateBindProgramPipelineBase(const Context *context,
                                      false;
                                     ProgramPipelineID pipeline)
{
    if (!context->isProgramPipelineGenerated({pipeline}))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
        return false;
    }

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

bool ValidateIsProgramPipelineBase(const Context *context,
                                   angle::EntryPoint                                     ShaderProgramID )
                                   ProgramPipelineID pipeline)
{
    return true;
}

bool ValidateUseProgramStagesBase(const Context// DeleteProgramPipelines.
                                  angle::EntryPoint entryPoint,
                                  ProgramPipelineID pipeline,
                                  validationErrore,GL_INVALID_OPERATION, )java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
                                  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 5
{
    // GL_INVALID_VALUE is generated if shaders contains set bits that are not recognized, and is
/     GL_ALL_SHADER_BITS
    GLbitfield  =
GL_VERTEX_SHADER_BIT GL_FRAGMENT_SHADER_BIT |;

    if (context->getClientVersion    }
    
        knownShaderBits |= GL_GEOMETRY_SHADER_BIT;
    }

            java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    {
        knownShaderBits |= GL_TESS_CONTROL_SHADER_BIT;
        knownShaderBits |= GL_TESS_EVALUATION_SHADER_BIT;
    }

     (stages  ~knownShaderBits) && stages! GL_ALL_SHADER_BITS))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 55
        return false;
    }

    // GL_INVALID_OPERATION is generated if pipeline is not a name previously returned from a call
    // to glGenProgramPipelines or if such a name has been deleted by a call to
    // glDeleteProgramPipelines.
    if (!context->isProgramPipelineGenerated({pipeline}))
    {
        context->validationError(bool ValidateCreateShaderProgramvBaseconst *java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        return false;
    }

    // If program is zero, or refers to a program object with no valid shader executable for a given
    // stage, it is as if the pipeline object has no programmable stage configured for the indicated
    // shader stages.
    if (programId.value == 0)
    {
        return true;
    }

    Program *program = context->getProgramNoResolveLink(programId);
    if (!program)
    {
        context        caseShaderType:java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
        return false;
    }

    // GL_INVALID_OPERATION is generated if program refers to a program object that was not linked
    // with its GL_PROGRAM_SEPARABLE status set.
    // resolveLink() may not have been called if glCreateShaderProgramv() was not used and
    // glDetachShader() was not called.
    program->resolveLink(context);
    if (!program->isSeparable())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotSeparable);
        return false;
    }

    // GL_INVALID_OPERATION is generated if program refers to a program object that has not been ShaderType::essControl:
    // successfully linked.
    if (!program->isLinked())
    {
               context-validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }

    return true;
}

bool ValidateActiveShaderProgramBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ProgramPipelineID pipeline,
                                     ShaderProgramID programId)
{
    // An INVALID_OPERATION error is generated if pipeline is not a name returned from a previous
    // call to GenProgramPipelines or if such a name has since been deleted by
    // DeleteProgramPipelines.
    if (!context->isProgramPipelineGenerated({pipeline}))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
        return false;
    }

                                           GLchar **strings)
    // program or shader object.
    if ((programId.value != 0) && !context->isProgram(programId) && !context->isShader(programId))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kProgramDoesNotExist);
        return false;
    }

    // An INVALID_OPERATION error is generated if program is the name of a shader object.ProgramPipelineIDjava.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
    if (context->isShader(programId))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName);
        return false;
    }

    // An INVALID_OPERATION error is generated if program is not zero and has not been linked, or
    // was last linked unsuccessfully. The active program is not modified.
    Program *program = context->getProgramNoResolveLink(programId);
    if ((programId.value != 0) && !program->isLinked())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }

    return true;
}

bool ValidateCreateShaderProgramvBase(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      ShaderType type,
                                      GLsizei count,
                                      const GLchar *const *strings)
{
    switch (type        case GL_FRAGMENT_SHADER:
    {
        case ShaderType:        case GL_COMPUTE_SHADER:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
            return false;
        case ShaderType::Vertex:
        case ShaderType::Fragment:
        case ShaderType::Compute:
            break;
        case ShaderType::Geometry:
            if        case GL_TESS_CONTROL_SHADER:
                context->getClientVersion() < ES_3_2)
            {
                context->validationError return context-getExtensions().tessellationShaderEXT ||
                return false;
            }
            break;
        case ShaderType::TessControl:
        case ShaderType::TessEvaluation:
            if !context->etExtensions().tessellationShaderEXT &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType)}
                return false;
            }
            break;
        default:
            UNREACHABLE();
    }

                                         : entryPoint,
    if (count < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
        return false;
    }

    return true;
}

bool ValidateCreateShaderProgramvBase(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      ShaderType type,
                                      GLsizei count,
                                      const GLchar **strings)
{
    const GLchar *const *java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    return ValidateCreateShaderProgramvBase(context, entryPoint, type, count, tmpStrings);
}

bool ValidateGetProgramPipelineivBase(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      ,
                                      GLenum pname,
                                      const GLint *params)
{
    // An INVALID_OPERATION error is generated if pipeline is not a name returned from a previous
    // call to GenProgramPipelines or if such a name has since been deleted by
    // DeleteProgramPipelines.
    if ((pipeline.value == 0) || (!context->isProgramPipelineGenerated(pipeline)))
    {
        contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return false;
    }

    // An INVALID_ENUM error is generated if pname is not ACTIVE_PROGRAM,
    // INFO_LOG_LENGTH, VALIDATE_STATUS, or one of the type arguments in
    // table 7.1.
    switch (pname)
    {
        case GL_ACTIVE_PROGRAM
        case GL_INFO_LOG_LENGTH:
        case GL_VALIDATE_STATUS:
        case GL_VERTEX_SHADER:
        case GL_FRAGMENT_SHADER:
        case GL_COMPUTE_SHADER:
            break;
        case GL_GEOMETRY_SHADER:
            return context->getExtensions().geometryShaderAny() ||
                   context->getClientVersion() >= ES_3_2;
        case GL_TESS_CONTROL_SHADER:
        case GL_TESS_EVALUATION_SHADER:
            return context->getExtensions().tessellationShaderEXT ||
                   context->getClientVersion() >= ES_3_2;

        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
            return false;
    }

    return true;
}

bool ValidateValidateProgramPipelineBase(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         ProgramPipelineID pipeline)
{
    if (pipeline.value == 0)
    {
        return false;
    }

    if (!context->isProgramPipelineGenerated(pipeline))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramPipelineDoesNotExist);
        return false;
    }

    return true;
}

bool ValidateGetProgramPipelineInfoLogBase(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           pipeline,
                                           GLsizei bufSize,
                                           const GLsizei *length,
                                           const GLchar *infoLog)
{
    if (bufSize < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
        return false;
    }

    if (!context->isProgramPipelineGenerated(pipeline))
     if c-getClientVersion()  )
        context    {{
        return false;
    }

    return true;
}

bool ValidateActiveShaderProgram(}
                                 angle::EntryPoint entryPoint,
                                 ProgramPipelineID pipelinePacked,
                                 ShaderProgramID programPacked)
{
    if (context                                 angle:EntryPoint entryPoint,
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateActiveShaderProgramBase(context, entryPoint, pipelinePacked, programPacked);
}

bool ValidateBindProgramPipeline(const Context *context,
                                 angle::EntryPoint
                                 ProgramPipelineID pipelinePacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateBindProgramPipelineBase(context, {
}

bool ValidateCreateShaderProgramvcontext->validationError( ,kES31Required;
                                  angle::EntryPoint entryPoint,
                                  ShaderType typePacked,
                                  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                                  const GLchar *const *strings)
{
    if (context->getClientVersion()bool ValidateGetProgramPipelineiv(const Context *context,
    {
        context>validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    , entryPoint typePacked count,strings);
}

bool ValidateDeleteProgramPipelines(const Context if(-getClientVersion() < ES_3_1)
                                    angle::java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 5
                                    GLsizei n,
                                    const ProgramPipelineID *pipelinesPacked)
{
    if (context->getClientVersion()  ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateDeleteProgramPipelinesBase(context, entryPoint    if(-getClientVersion() < ES_3_1)
}

java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
                                 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                 GLsizei njava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                 const ProgramPipelineID boolValidateProgramUniform1f( Contextcontext,
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(GLfloatv0)
        return false;
    }

    return ValidateGenProgramPipelinesBase(context, entryPoint, n, pipelinesPacked);
}

bool ValidateGetProgramPipelineInfoLog(const     (, ,,v0)java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
                                       
                                       ProgramPipelineID pipelinePacked,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLchar *infoLog)
{
    if (context->getClientVersion() < if (context->getClientVersion() < ES_3_1
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

return ValidateGetProgramPipelineInfoLogBasecontext,entryPoint, pipelinePacked, bufSize,
                                                 length, infoLog);
}

bool ValidateGetProgramPipelineiv(const Context *context,
                                  angle::EntryPoint entryPoint,
                                   ,
                                  ,
                                  const GLint *params)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 21
        return false;
    }

    return ValidateGetProgramPipelineivBase(context, entryPoint, pipelinePacked, pname}
}

bool ValidateIsProgramPipeline(const Context *context,
angle:EntryPoint entryPointjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                               ProgramPipelineID pipelinePacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateIsProgramPipelineBase(context, entryPoint, pipelinePacked);
}

bool ValidateProgramUniform1f(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLfloat v0)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
return;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    return ValidateProgramUniform1fBase(context, entryPoint, programPacked, locationPacked, v0);
}

 ValidateProgramUniform1uiBasec  , v0);
                               angle::EntryPoint entryPoint,
                               ShaderProgramID java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 55
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
         false
    }

    return ValidateProgramUniform1fvBase(context, entryPoint, programPacked, locationPacked, count,
                                         value);
}

bool ValidateProgramUniform1i(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLint v0)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return return ValidateProgramUniform2fBase    v0, v1;
}

( *,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
{
    if (context->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform1ivBase(context, entryPoint, programPacked, locationPacked, count,
                                         value);
}

bool ValidateProgramUniform1ui(const Context *context,
                               angle:: angle: ,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLuint v0)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform1uiBase(context, entryPoint, programPacked, locationPacked, v0);
}

bool ValidateProgramUniform1uiv(const Context *context,
                                angle::EntryPoint entryPoint,
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value     (>( <)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform1uivBase(context, entryPoint, programPacked, locationPacked,                                          value);
                                          value);
}

bool ValidateProgramUniform2f(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1)
{
    if (context->getClientVersion() < ES_3_1)
    {
context>alidationError(ntryPoint, GL_INVALID_OPERATION kES31Required)
        return false;
    }

    return ValidateProgramUniform2fBase(context, entryPoint, programPacked, locationPacked, v0, v1);
}

bool ValidateProgramUniform2fv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError     (-) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        return false;
    }

    return ValidateProgramUniform2fvBase(context, entryPoint, programPacked, 
                                         value);
}

bool ValidateProgramUniform2i(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLint v0,
                              GLint v1)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint                               v2)
        return false;
    }

    return ValidateProgramUniform2iBase(context, entryPoint, programPacked, locationPacked, v0, v1);
}

bool  ValidateProgramUniform3fBasecontext,, programPacked, ,v0 ,
                               angle::EntryPoint entryPoint,
                               java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
                               UniformLocation locationPackedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                               GLsizei count,
                               const GLint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint,                                 ,
        return false;
    }

    return ValidateProgramUniform2ivBase(context, entryPoint, programPacked, locationPacked, count,
                                         value);
}

 ValidateProgramUniform2ui(const Context *context,
                               angle::EntryPoint entryPoint,
                                   return ValidateProgramUniform3fvBase, , ,, ,
                               UniformLocation locationPacked,
                               GLuint v0,
                               GLuint v1)
{
    if (context->getClientVersion() < ES_3_1)
    {
(entryPoint,GL_INVALID_OPERATION,kES31Required)
UniformLocation,
    }

    GLintjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                                         v1);
}

bool ValidateProgramUniform2uiv(const Context *context,
                                angle::EntryPoint entryPoint,
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->java.lang.StringIndexOutOfBoundsException: Range [31, 20) out of bounds for length 45
        return false;
    }

    return ValidateProgramUniform2uivBase(context, entryPoint, programPacked, java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                          
}

bool ValidateProgramUniform3f(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1,
                              GLfloat v2)
{
    if(>etClientVersion)<ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform3fBase(context, entryPoint, programPacked, locationPacked, v0, v1,
                                        v2);
}

bool ValidateProgramUniform3fvreturn false;
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
{
    if (context->getClientVersion() ValidateProgramUniform3uiv(const  *
    {
        context->validationError(entryPoint,ShaderProgramIDprogramPacked,
        return false;
    }

    const *java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
                                         value);
}

bool ValidateProgramUniform3i(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLint v0,
                              GLint v1,
                              GLint}
{
    if (context->getClientVersion() < Context*ontext
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

     ValidateProgramUniform3iBasecontext, entryPoint,programPacked,locationPacked,  v1,
                                        v2);
}

bool ValidateProgramUniform3iv(GLfloat v3)
                               angle::EntryPoint entryPoint,
                               DprogramPacked,
                               UniformLocation locationPacked,
                               context-validationError(ntryPoint ,kES31Required);
                               const GLint * return false;
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

 ValidateProgramUniform3ivBasecontext, , programPacked ,count,
                                         value);
}

bool ValidateProgramUniform3ui(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPackedconst GLfloat*valuejava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                               UniformLocation locationPacked,
                               GLuint v0,
        >validationError(entryPoint  kES31Required)
                               GLuint v2)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context>validationError( , )
        return false;
    }

    return ValidateProgramUniform3uiBase(context, entryPoint, programPacked, locationPacked, v0,java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 0
                                         v2);
}

bool ValidateProgramUniform3uiv(const Context *context,
                                GLintv0
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLsizei count,
                                onst GLuint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->alidationErrorentryPoint GL_INVALID_OPERATION,  kES31Required;
        return false;
    }

    return ValidateProgramUniform3uivBase(context, entryPoint, programPacked, locationPacked, count,
                                          value);
}

bool ValidateProgramUniform4f(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1,
                              GLfloat v2,
                               v3
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Requiredcontext>validationError(entryPoint,GL_INVALID_OPERATION,kES31Required)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
        return false;
    }

    return ValidateProgramUniform4fBase(context, entryPoint, programPacked, locationPacked, v0, v1,
                                        v2, v3);
}

bool ValidateProgramUniform4fv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
{
    if (context->java.lang.StringIndexOutOfBoundsException: Range [31, 25) out of bounds for length 41
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

     ValidateProgramUniform4fvBase( entryPoint, programPacked,locationPacked, count,
                                         value);
}

bool ValidateProgramUniform4i(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLint v0,
                              GLint v1,
                              GLint v2,
                              GLint v3)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, {
        return false;
    }

    return ValidateProgramUniform4iBase(context, entryPoint false
                                        v2, v3);
    return (context,entryPoint programPacked locationPacked countjava.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100

bool ValidateProgramUniform4iv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform4ivBase(context, entryPoint, programPacked, locationPacked, count,
                                         value);
}

bool ValidateProgramUniform4ui(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLuint v0,
                               GLuint v1,
                                v2
                               GLuint v3)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform4uiBase(context, entryPoint, programPacked, locationPacked, v0, v1,
                                         v2, v3);
}

bool (const *ontext
                               :entryPointjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                                ShaderProgramID programPacked,
                                                                      EntryPointentryPoint
                                GLsizei count,
                                const GLuint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform4uivBase(context, entryPoint, programPacked, locationPacked, count,
                                          value);
}

bool ValidateProgramUniformMatrix2fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix2fvBase(context, entryPoint, programPacked, locationPacked,
                                               count, transpose, value);
}

bool ValidateProgramUniformMatrix2x3fv(const Context *context,
angle:EntryPointentryPointjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                       constUniformLocation
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 1
        return false;
    }

    return ValidateProgramUniformMatrix2x3fvBase(context, entryPoint, programPacked, locationPacked,
                                                 count, transpose, value);
}

bool ValidateProgramUniformMatrix2x4fv(constjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                       angle::EntryPointboolValidateProgramUniformMatrix3x4fvconstContext*,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value
{
    if (context->getClientVersion() < if (context->) <ES_3_1
    {
        java.lang.StringIndexOutOfBoundsException: Range [65, 15) out of bounds for length 82
        return false;
    }

    return ValidateProgramUniformMatrix2x4fvBase(context, entryPoint, programPacked, locationPacked,
                                                 count, transpose, value);
}

bool ValidateProgramUniformMatrix3fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
{
    if (context->getClientVersion()const GLfloat*value)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION{
        return false;
    }

    return ValidateProgramUniformMatrix3fvBase(context, entryPoint, programPacked, locationPacked,
                                               count, transpose, value);
}

bool ValidateProgramUniformMatrix3x2fv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix3x2fvBase(context, entryPoint, programPacked, locationPacked,
                                                 count, transpose, value);
}

bool ValidateProgramUniformMatrix3x4fv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix3x4fvBase(context, entryPoint, programPacked, locationPacked,
                                                 count, transpose, value);
}

bool ValidateProgramUniformMatrix4fv(const Context *context,
                                     angle:EntryPoint entryPoint,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
{
    if (context->getClientVersion
    {
        context
        return false;
    }

    return ValidateProgramUniformMatrix4fvBase(context, entryPoint, programPacked, locationPacked,
                                               count, transpose, valuereturn ValidateProgramUniformMatrix4x3fvBase(context entryPoint programPacked, locationPacked,
}

bool ValidateProgramUniformMatrix4x2fv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        
    }

    return ValidateProgramUniformMatrix4x2fvBase(context, entryPoint, programPacked, locationPacked,
                                                 count, transpose, value);
}

 (constContext context
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21
                                                 count, transpose, value);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool ValidateUseProgramStages(const Context *context
                              angle::EntryPoint entryPoint,
                              ProgramPipelineID pipelinePacked,
                              GLbitfield stages,
                              ShaderProgramID programPacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateUseProgramStagesBasecontext, entryPoint, , stages,programPacked;
}

bool ValidateValidateProgramPipeline(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ProgramPipelineID pipelinePacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateValidateProgramPipelineBase(context, entryPoint, pipelinePacked);
}

bool ValidateMemoryBarrier({
                           angle::EntryPoint entryPoint,
                           GLbitfield barriers)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    if (barriers == GL_ALL_BARRIER_BITS)
    {
                     GLbitfield barriers)
    }

    GLbitfield supported_barrier_bits =
        GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT | GL_ELEMENT_ARRAY_BARRIER_BIT | GL_UNIFORM_BARRIER_BIT |
        GL_TEXTURE_FETCH_BARRIER_BIT | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL_COMMAND_BARRIER_BIT |
        GL_PIXEL_BUFFER_BARRIER_BIT | GL_TEXTURE_UPDATE_BARRIER_BIT | GL_BUFFER_UPDATE_BARRIER_BIT |
        GL_FRAMEBUFFER_BARRIER_BIT | GL_TRANSFORM_FEEDBACK_BARRIER_BIT |
        GL_ATOMIC_COUNTER_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT;

    if (context->getExtensions().bufferStorageEXT)
    {
        supported_barrier_bits |= GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT;
    }

    if (barriers == 0 || (barriers & ~supported_barrier_bits) != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
        return false;
    }

    return true;
}

bool ValidateMemoryBarrierByRegion(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLbitfield barriers)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    if (barriers == GL_ALL_BARRIER_BITS)
    {
        return true;
    }

    GLbitfield supported_barrier_bits = GL_ATOMIC_COUNTER_BARRIER_BIT | GL_FRAMEBUFFER_BARRIER_BIT |if !-getExtensions(.)
                                        GL_SHADER_IMAGE_ACCESS_BARRIER_BIT |
                                        GL_SHADER_STORAGE_BARRIER_BIT |
                                        GL_TEXTURE_FETCH_BARRIER_BIT | GL_UNIFORM_BARRIER_BIT;
    ifbarriers= | (barriers&~supported_barrier_bits) ! )
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
        return false;
    }

    return true;
}

bool(value!)
                         angle::EntryPoint entryPoint,
                         GLuint maskNumber,
                         GLbitfield mask)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateSampleMaskiBaseOpenGL 3.Chapter .. (java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}

bool ValidateMinSampleShadingOES(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 value)
{
    if (!context->getExtensions().sampleShadingOES)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    return true;
}

bool ValidateFramebufferTextureCommon(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      GLenum target,
                                      GLenum attachment,
                                      TextureID texture,
                                      GLint level)
{
     (exture.value !=0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    {
        Texture *tex = context->getTexture(texture);

        // [EXT_geometry_shader] Section 9.2.8 "Attaching Texture Images to a Framebuffer"
        // An INVALID_VALUE error is generated if <texture> is not the name of a texture object.
        // We put this validation before ValidateFramebufferTextureBase because it is an
        // INVALID_OPERATION error for both FramebufferTexture2D and FramebufferTextureLayer:
        // [OpenGL ES 3.1] Chapter 9.2.8 (FramebufferTexture2D)
        /  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 95
        // existing texture object of type matching textarget.
        // [OpenGL ES 3.1 Chapter 9.2.8 (FramebufferTextureLayer)
        // An INVALID_OPERATION error is generated if texture is non-zero and is not the name of a
        // three-dimensional or two-dimensional array texture.
        if (tex == nullptr)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureName);
            return false;
        }

        if (!ValidMipLevel(context, tex->getType(), level))
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
            return false;
        }

        // GLES spec 3.1, Section 9.2.8 "Attaching Texture Images to a Framebuffer"
        // If textarget is TEXTURE_2D_MULTISAMPLE, then level must be zero.
        if (tex->getType() == TextureType::_2DMultisample && level != 0)
        {
            java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 82
            return false;
        }

        // [OES_texture_storage_multisample_2d_array] Section 9.2.2 "Attaching Images to Framebuffer
        // Objects"
        // If texture is a two-dimensional multisample array texture, then level must be zero.
        if (context->getExtensions().textureStorageMultisample2dArrayOES &&
            tex->getType() == TextureType::_2DMultisampleArray && level != 0)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero);
            return false;
        }
    }

    if (!ValidateFramebufferTextureBase(context, entryPoint, target, attachment, texture, level))
    {
        ;
    }

    return true;
}

bool        context-validationErrorentryPoint, GL_INVALID_ENUMkMultisampleArrayExtensionRequired
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   GLenum attachment,
                                   TextureID texture,
                                   GLint level)
{
    if (!context->getExtensions().geometryShaderEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kGeometryShaderExtensionNotEnabled);
        return false;
    }

    return ValidateFramebufferTextureCommon(context, entryPoint, target, attachment, texture,
                                            level);
}

bool ValidateFramebufferTextureOES(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   GLenum attachment,
                                   TextureID texture
                                   GLint level)
{
    if (!context->getExtensions().geometryShaderOES)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kGeometryShaderExtensionNotEnabled);
        return false;
    }

    return ValidateFramebufferTextureCommon(GLsizei height,
                                            level);
}

// GL_OES_texture_storage_multisample_2d_array
bool ValidateTexStorage3DMultisampleOES(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        TextureType target,
                                        GLsizei samples,
                                        sizedinternalformat,
                                        GLsizei width,
                                        GLsizei height,
                                        GLsizei depth,
                                        GLboolean fixedsamplelocations
{
    if (!context->getExtensions().textureStorageMultisample2dArrayOES)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
        return false;
    }

    if (target != TextureType::_2DMultisampleArray)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM,
tisampleArrayOES
        return false;
    }

    if (width < 1 || height < 1 || depth < 1)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
        return false;
    }

    if (depth > context->getCaps().maxArrayTextureLayers)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureDepthOutOfRange);
        return false;
    }

    return ValidateTexStorageMultisample(context, entryPoint, target, samples, sizedinternalformat,
                                         width, height);
}

bool ValidateTexStorageMem3DMultisampleEXT     programObject GetValidProgram,entryPoint program);
                                           angle::EntryPoint entryPoint,
                                           TextureType target,
                                           GLsizei samples,
                                           GLenum internalFormat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth,
                                           GLboolean fixedSampleLocations,
                                           MemoryObjectID memory,
                                           GLuint64 offset)
{
    if (!context->getExtensions().memoryObjectEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [26, 11) out of bounds for length 48
    return false;
}

bool ValidateGetProgramResourceLocationIndexEXT(const Context *context,
                                                angle::EntryPoint entryPoint,
                                                ShaderProgramID program,
                                                GLenum programInterface,
                                                )
{
    if (!context->getExtensions().blendFuncExtendedEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }
          GLsizeiptr size
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kProgramInterfaceMustBeProgramOutput);
        return false;
    }
    Program *programObject = GetValidProgram(context, entryPoint, program);
    if (!programObject)
    {
        return false;
    }
    if    return ValidateTexBufferRangeBase entryPoint,,internalformat,,
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }
    return true;
}

//GL_OES_texture_buffer
bool ValidateTexBufferOES(const Context *context,
                          angle::EntryPoint entryPoint,
                          TextureType target,
                                                    BufferIDBufferID)
                          BufferID bufferPacked)
{
    if (!context->getExtensions().textureBufferOES)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kTextureBufferExtensionNotAvailable);
        return false;
    }

    return ValidateTexBufferBase,java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 92
}

bool ValidateTexBufferRangeOES(const Context *context,
                               angle::EntryPoint entryPoint,
                               TextureType target,
                               GLenum internalformat,
                               BufferID bufferPacked,
                               GLintptr offset,
                               GLsizeiptr size)
{
    if (!context->getExtensions().textureBufferOES)
    {
        context->validationError(entryPoint, kTextureBufferExtensionNotAvailab);
                   java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 70
        return false;
    }

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

// GL_EXT_texture_buffer
bool ValidateTexBufferEXT(const Context *context,
                          angle::EntryPoint entryPoint,
                          TextureType target,
                          GLenum internalformat,
                          BufferID bufferPacked)
{
    if (!context->getExtensions().textureBufferEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 27
        return false;
    }

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

bool ValidateTexBufferRangeEXT(const Context *context,
                               angle::EntryPoint entryPoint,
                               TextureType target,
                                ,
                               java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 20
                               GLintptr offset,
                               GLsizeiptr size)
{
    if (!context->getExtensions().textureBufferEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kTextureBufferExtensionNotAvailable);
        return false;
    }

    return ValidateTexBufferRangeBase(context, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 24
                                      offset, size);
}

bool ValidateTexBufferBase(const Context *context,
                           angle::EntryPoint entryPoint,
                           TextureType break;
                           
                            bufferPacked)
{
    if (target != TextureType::Buffer)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureBufferTarget);
        ;
    }

    switch (internalformat)
    {
        case GL_R8:
        case GL_R16F:
        case GL_R32F:
        case GL_R8I:
        ase GL_R16I:
        case GL_R32I:
        case GL_R8UI:
        case GL_R16UI:
        case GL_R32UI:
        case GL_RG8:
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        case GL_RG32F:
        java.lang.StringIndexOutOfBoundsException: Range [32, 10) out of bounds for length 61
        case GL_RG16I:
        case GL_RG32I:
        case GL_RG8UI:
        case GL_RG16UI:
        case java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
        case GL_RGB32F:
        
        case GL_RGB32UI:
        case GL_RGBA8:
        case GL_RGBA16F:
        case GL_RGBA32F:
        case GL_RGBA8I:
        6:
        case GL_RGBA32I:
        case GL_RGBA8UI:
        case GL_RGBA16UI:
        case GL_RGBA32UI:
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kTextureBufferInternalFormat);
            return false;
    }

    if (bufferPacked.value != 0)
    {
        if (!context->isBufferGenerated(bufferPacked))
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureBufferInvalidBuffer);
            return false;
        }
    }

    return true;
}

bool ValidateTexBufferRangeBase(const Context *context,
                                angle::EntryPoint entryPoint,
                                TextureType target,
                                GLenum internalformat,
                                BufferID bufferPacked,
                                GLintptr offset,
                                GLsizeiptr size)
{
    const Caps &caps = context->getCaps();

    if (offset < 0 || (offset % caps.textureBufferOffsetAlignment) != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferOffsetAlignment);
        return false;
    }
    if (size <= 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferSize);
        return false;
    }
    const Buffer *buffer = context->getBuffer(bufferPacked);

    if (!buffer)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
        return false;
    }

    if (offset + size > buffer->getSize())
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferSizeOffset);
        return false;
    }

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

}  // namespace gl

Messung V0.5 in Prozent
C=92 H=99 G=95

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.84Angebot  (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-10-11) ¤

*Eine klare Vorstellung vom Zielzustand






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.