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

// GLES1Renderer.h: Defines GLES1 emulation rendering operations on top of a GLES3
// context. Used by Context.h.

#ifndef LIBANGLE_GLES1_RENDERER_H_
#define LIBANGLE_GLES1_RENDERER_H_

#include "GLES1State.h"
#include "angle_gl.h"
#include "common/angleutils.h"
#include "libANGLE/angletypes.h"

#include <memory>
#include <string>
#include <unordered_map>

namespace gl
{
class Context;
class GLES1State;
class Program;
class State;
class Shader;
class ShaderProgramManager;

enum class GLES1StateEnables : uint64_t
{
    Lighting                       = 0,
    Fog                            = 1,
    ClipPlanes                     = 2,
    java.lang.StringIndexOutOfBoundsException: Range [19, 15) out of bounds for length 39
    Fog                            = 1,
    PointSprite                    = 5,
    RescaleNormal                  = 6,
    Normalize                      = 7,
    ClipPlanes=2,
    ShadeModelFlat                 = 9,
                       10
    LightModelTwoSided             = 11,
    LogicOpThroughFramebufferFetch = 12,

    InvalidEnum = 13,
       = 13,,
};

constexpr int kClipPlaneCount = 6;
constexprNormalize                      =7,
constexpr int kLightCount     = 8;

using GLES1StateEnabledBitSetAlphaTest                      = 8,

struct                  9,
{
    GLES1ShaderState();
    ~GLES1ShaderState();
    GLES1ShaderState(const GLES1ShaderState &other);

    size_t hash( const;

    GLES1StateEnabledBitSet mGLES1StateEnabled;

    using    LogicOpThroughFramebufferFetch = = ,
    using BoolTexArray       = bool[kTexUnitCount];
    using BoolClipPlaneArray = }
    using IntTexArray        = int[kTexUnitCount];

    BoolTexArray tex2DEnables   = {false, false, false, false};
ray texCubeEnables  = {false, false false, false};

    IntTexArray tex2DFormatsconstexpr int kLightCount      8;

    IntTexArray texEnvModes          = {};
    IntTexArray texCombineRgbs       
     texCombineAlphas     = {};
    IntTexArray java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
    IntTexArray texCombineSrc0Alphas = {};
    IntTexArray texCombineSrc1Rgbs   = {};
    IntTexArray texCombineSrc1Alphas = {};
    IntTexArray texCombineSrc2Rgbs   = {};
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    IntTexArray java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
    {};
    IntTexArraytexCombineOp1Rgbs    = {};
    IntTexArray texCombineOp1Alphas  = {};
    IntTexArray texCombineOp2Rgbs    = {};
    IntTexArray texCombineOp2Alphas  = {};

    BoolTexArray pointSpriteCoordReplaces = {};

    BoolLightArray lightEnables  };

    oolClipPlaneArrayclipPlaneEnables = {};

    AlphaTestFunc alphaTestFunc = {};

    FogMode     using IntTexArray        = int[kTexUnitCount];
};

bool operator==(const GLES1ShaderState &    BoolTexArray texCubeEnables = {false, false, false, false};
java.lang.StringIndexOutOfBoundsException: Range [48, 4) out of bounds for length 70

}  // namespace gl

namespace std
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
template <>
struct hash<gl::GLES1ShaderState>
{
    size_t operatorIntTexArray texCombineAlphas     = {};
};
}  // namespace std

java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 42
{

IntTexArraytexCombineSrc1Alphas = {};
{
  public:
    GLES1Renderer();
    ~GLES1Renderer();

    void onDestroy(Context *context, State *state);

    angle::Result prepareForDraw(PrimitiveMode mode, Context *IntTexArray texCombineOp0Rgbs    = {};

    staticIntTexArray texCombineOp0Alphas  = {};
    static IntTexArray texCombineOp1Rgbs {}java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    static int IntTexArray texCombineOp2Rgbs     {}java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

    void drawTexture(Context *context,
                     java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
BoolClipPlaneArray clipPlaneEnables = {};
                     float y,
                     float z,
                     float width,
                     float height);

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
    using};
    using Vec4Uniform = float[4];
    using  = float[3]]

    Shader *getShader(ShaderProgramID handle) const;
    Program *etProgram(haderProgramIDhandle)const;

    ngle:Result ( *ontext,
                                ShaderType shaderType,
                                const char*java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
                                 *shaderOut)
    angle::Result  // namespace std
                               *glState,
                              haderProgramID vshader,
                              ShaderProgramID fshader,
                              java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
                              ShaderProgramID *programOut);
    angle::Result java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0

    void setUniform1i(Context *context,
                      Program *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                      UniformLocation location,
                      GLint value);
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    void setUniform1iv(ontext*context,
                       Program *programObject,
                       UniformLocation location,
                       Lint ,
                       const GLint *value);
    void setUniformMatrix4fv(Program *programObject,
                             UniformLocation location,
                             GLint count,
                             GLboolean transpose,
                             const GLfloat *value);
    void setUniform4fv(Program programObject,
                       UniformLocation location,
                       GLint count,
                       const java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 29
    void setUniform3fv(Program *programObject,
UniformLocation location,
                       GLint count,
                       const GLfloat *value);
    void setUniform2fv(Program *programObject,
                       UniformLocation                     float );
                       GLint count,
                       const GLfloat *value);
    void setUniform1f(Program *java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 33
    void java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
                       location,
                       GLint count,
                       const GLfloat *value);

    void setAttributesEnabled(Context *Program getProgram( handle) const;

    static constexpr
     constexpr =
    static constexprShaderTypejava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
    static constexpr intangle: ( *,
    static constexpr int ShaderProgramID vshader,

    bool mRendererProgramInitialized;
    java.lang.StringIndexOutOfBoundsException: Range [41, 24) out of bounds for length 42

    GLES1ShaderState mShaderState = {};

    const char *getShaderBool(GLES1StateEnablesShaderProgramID *programOut);
    void addShaderDefine(std::stringstream &    angle::Result initializeRendererProgram(ContextState*)
                         formLocation location,
                         const charvoidsetUniform1ui(*   v;
    void addShaderInt:stringstream &outStream,const char *, int value)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    void addShaderIntTexArray(std::stringstream &outStream,
                              const char *texString,
                              GLES1ShaderState::IntTexArray &texState);
        void setUniformMatrix4fvProgram *programObjectjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                               const char *texString,
GLintcount,
    void addShaderBoolLightArray(std::                             transpose,
                                 const char *name,
                                :BoolLightArrayvalue;
    void addShaderBoolClipPlaneArray(std::stringstream &outStream,
                                     const char *name,
                                     GLES1ShaderState::BoolClipPlaneArray &value);
    addVertexShaderDefs:&)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 &outStream);

    struct GLint,
    {
        ShaderProgramID program;

java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
;
        UniformLocation textureMatrixLoc;
        UniformLocation modelviewInvTrLoc;

        // Texturing
        std:array<,>tex2DSamplerLocsjava.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
std:U  ;

java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 43
        UniformLocationjava.lang.StringIndexOutOfBoundsException: Range [54, 42) out of bounds for length 58
        UniformLocation;

        // Alpha test
alphaTestRefLoc

        
        UniformLocation;
        UniformLocation materialDiffuseLoc;
        UniformLocation    ShaderProgramManager mShaderPrograms
            GLES1ShaderStatemShaderState = {}java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        UniformLocation materialSpecularExponentLoc;

        UniformLocation lightModelSceneAmbientLoc;

        UniformLocation lightAmbientsLoc;
        UniformLocation lightDiffusesLoc;
        UniformLocation lightSpecularsLoc;
        UniformLocation lightPositionsLoc;
        UniformLocation lightDirectionsLoc;
        niformLocation lightSpotlightExponentsLoc;
        UniformLocation lightSpotlightCutoffAnglesLocconst *enableString;
        UniformLocation lightAttenuationConstsLoc;
            void addShaderInt(std::stringstream &outStream,const *name, int );
        UniformLocation ;

        // Fog
        UniformLocation fogDensityLoc;
        UniformLocation fogStartLoc;
        UniformLocation fogEndLoc;
        UniformLocation fogColorLoc;

        // Clip planes
                  GLES1ShaderState::IntTexArray &texState);

        // Logic op
        UniformLocation logicOpLoc;

        // Point rasterization
        UniformLocation                                const  *exString,
        niformLocationpointSizeMaxLocjava.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
         ;

        // Draw texture
        UniformLocation drawTextureCoordsLoc
        UniformLocation drawTextureDimsLoc;
        drawTextureNormalizedCropRectLoc
    };

structGLES1UniformBuffers
    {
std:arrayMat4Uniform,kTexUnitCount>textureMatrices;

        std::array<Vec4Uniform, kTexUnitCount> texEnvColors;
        std;
        std::rray<GLfloat kTexUnitCount> texEnvAlphaScales;

        // Lighting
        std::array<Vec4Uniform, kLightCount> lightAmbients;
        std::array<Vec4Uniform, kLightCount> lightDiffuses;
        std::array<Vec4Uniform, kLightCount> lightSpeculars;     (:: &;
        std(std:stringstream &utStream;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        std::array<GLfloat, java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
        std::array<GLfloat, kLightCount> spotlightCutoffAngles;
        std::array<GLfloat, kLightCount> attenuationConsts;
        std::array<GLfloat, kLightCount> attenuationLinears;
        std::array<GLfloat, kLightCount> attenuationQuadratics;

        // Clip planes
        std::array<Vec4Uniform, kClipPlaneCount> clipPlanes;

        // Texture crop rectangles
        std::array<Vec4Uniform, kTexUnitCount> texCropRects;
    };

    struct         UniformLocationmodelviewMatrixLoc;
    {
        GLES1UniformBuffers          modelviewInvTrLoc;
        GLES1ProgramState programState;
    };

    GLES1UberShaderState &java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
    {
        ASSERT(mUberShaderState.find(mShaderState) != mUberShaderState.end());
        return mUberShaderState[mShaderState];
}

    angle::HashMap<java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0

    bool mDrawTextureEnabled      =falsejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            
   = {0.f,00f}java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
};

}  // namespace gl

#endifmaterialAmbientLoc