GLES1State.h - mozsearch

mozilla-central/gfx/angle/checkout/src/libANGLE/GLES1State.h (file symbol)

Enable keyboard shortcuts

Source code

Revision control

Copy as Markdown

Other Tools

//

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

//

// GLES1State.h: Defines the GLES1State class holding the state of

// a GLES1 context.

#ifndef LIBANGLE_GLES1STATE_H_

#define LIBANGLE_GLES1STATE_H_

#include <unordered_set>

#include "common/FixedVector.h"

#include "common/angleutils.h"

#include "common/bitset_utils.h"

#include "common/matrix_utils.h"

#include "common/vector_utils.h"

#include "libANGLE/Caps.h"

#include "libANGLE/angletypes.h"

namespace gl

// State types specific to GLES1 contexts, from the OpenGL ES 1.1 spec "State Tables" section

struct TextureCoordF

    TextureCoordF();

    TextureCoordF(float _s, float _t, float _r, float _q);

    bool operator==(const TextureCoordF &other) const;

    GLfloat s = 0.0f;

    GLfloat t = 0.0f;

    GLfloat r = 0.0f;

    GLfloat q = 0.0f;

};

struct MaterialParameters

    MaterialParameters();

    ColorF ambient;

    ColorF diffuse;

    ColorF specular;

    ColorF emissive;

    GLfloat specularExponent;

};

struct LightModelParameters

    LightModelParameters();

    ColorF color;

    bool twoSided;

};

struct LightParameters

    LightParameters();

    LightParameters(const LightParameters &other);

    bool enabled                 = false;

    ColorF ambient               = {0.0f, 0.0f, 0.0f, 1.0f};

    ColorF diffuse               = {0.0f, 0.0f, 0.0f, 1.0f};

    ColorF specular              = {0.0f, 0.0f, 0.0f, 1.0f};

    angle::Vector4 position      = {0.0f, 0.0f, 1.0f, 0.0f};

    angle::Vector3 direction     = {0.0f, 0.0f, -1.0f};

    GLfloat spotlightExponent    = 0.0f;

    GLfloat spotlightCutoffAngle = 180.0f;

    GLfloat attenuationConst     = 1.0f;

    GLfloat attenuationLinear    = 0.0f;

    GLfloat attenuationQuadratic = 0.0f;

};

struct FogParameters

    FogParameters();

    FogMode mode;

    GLfloat density;

    GLfloat start;

    GLfloat end;

    ColorF color;

};

struct TextureEnvironmentParameters

    TextureEnvironmentParameters();

    TextureEnvironmentParameters(const TextureEnvironmentParameters &other);

    TextureEnvMode mode         = TextureEnvMode::Modulate;

    TextureCombine combineRgb   = TextureCombine::Modulate;

    TextureCombine combineAlpha = TextureCombine::Modulate;

    TextureSrc src0Rgb   = TextureSrc::Texture;

    TextureSrc src0Alpha = TextureSrc::Texture;

    TextureSrc src1Rgb   = TextureSrc::Previous;

    TextureSrc src1Alpha = TextureSrc::Previous;

    TextureSrc src2Rgb   = TextureSrc::Constant;

    TextureSrc src2Alpha = TextureSrc::Constant;

    TextureOp op0Rgb   = TextureOp::SrcColor;

    TextureOp op0Alpha = TextureOp::SrcAlpha;

    TextureOp op1Rgb   = TextureOp::SrcColor;

    TextureOp op1Alpha = TextureOp::SrcAlpha;

    TextureOp op2Rgb   = TextureOp::SrcAlpha;

    TextureOp op2Alpha = TextureOp::SrcAlpha;

    ColorF color       = {0.0f, 0.0f, 0.0f, 0.0f};

    GLfloat rgbScale   = 1.0f;

    GLfloat alphaScale = 1.0f;

    bool pointSpriteCoordReplace = false;

    auto tie() const

        return std::tie(mode, combineRgb, combineAlpha, src0Rgb, src0Alpha, src1Rgb, src1Alpha,

                        src2Rgb, src2Alpha, op0Rgb, op0Alpha, op1Rgb, op1Alpha, op2Rgb, op2Alpha,

                        color, rgbScale, alphaScale, pointSpriteCoordReplace);

};

bool operator==(const TextureEnvironmentParameters &a, const TextureEnvironmentParameters &b);

bool operator!=(const TextureEnvironmentParameters &a, const TextureEnvironmentParameters &b);

struct PointParameters

    PointParameters();

    PointParameters(const PointParameters &other);

    GLfloat pointSizeMin                    = 0.0f;

    GLfloat pointSizeMax                    = 1.0f;

    GLfloat pointFadeThresholdSize          = 1.0f;

    angle::Vector3 pointDistanceAttenuation = {1.0f, 0.0f, 0.0f};

    GLfloat pointSize                       = 1.0f;

};

struct ClipPlaneParameters

    ClipPlaneParameters();

    ClipPlaneParameters(bool enabled, const angle::Vector4 &equation);

    ClipPlaneParameters(const ClipPlaneParameters &other);

    ClipPlaneParameters &operator=(const ClipPlaneParameters &other);

    bool enabled;

    angle::Vector4 equation;

};

class Context;

class GLES1Renderer;

class State;

class GLES1State final : angle::NonCopyable

  public:

    GLES1State();

    ~GLES1State();

    void initialize(const Context *context, const State *state);

    void setAlphaFunc(AlphaTestFunc func, GLfloat ref);

    void setClientTextureUnit(unsigned int unit);

    unsigned int getClientTextureUnit() const;

    void setCurrentColor(const ColorF &color);

    const ColorF &getCurrentColor() const;

    void setCurrentNormal(const angle::Vector3 &normal);

    const angle::Vector3 &getCurrentNormal() const;

    void setCurrentTextureCoords(unsigned int unit, const TextureCoordF &coords);

    const TextureCoordF &getCurrentTextureCoords(unsigned int unit) const;

    void setMatrixMode(MatrixType mode);

    MatrixType getMatrixMode() const;

    GLint getCurrentMatrixStackDepth(GLenum param) const;

    void pushMatrix();

    void popMatrix();

    using MatrixStack = angle::FixedVector<angle::Mat4, Caps::GlobalMatrixStackDepth>;

    MatrixStack &currentMatrixStack();

    const MatrixStack &currentMatrixStack() const;

    const MatrixStack &getMatrixStack(MatrixType mode) const;

    const angle::Mat4 &getModelviewMatrix() const;

    void loadMatrix(const angle::Mat4 &m);

    void multMatrix(const angle::Mat4 &m);

    void setLogicOpEnabled(bool enabled);

    void setLogicOp(LogicalOperation opcodePacked);

    void setClientStateEnabled(ClientVertexArrayType clientState, bool enable);

    void setTexCoordArrayEnabled(unsigned int unit, bool enable);

    bool isClientStateEnabled(ClientVertexArrayType clientState) const;

    bool isTexCoordArrayEnabled(unsigned int unit) const;

    bool isTextureTargetEnabled(unsigned int unit, const TextureType type) const;

    LightModelParameters &lightModelParameters();

    const LightModelParameters &lightModelParameters() const;

    LightParameters &lightParameters(unsigned int light);

    const LightParameters &lightParameters(unsigned int light) const;

    MaterialParameters &materialParameters();

    const MaterialParameters &materialParameters() const;

    bool isColorMaterialEnabled() const;

    void setShadeModel(ShadingModel model);

    void setClipPlane(unsigned int plane, const GLfloat *equation);

    void getClipPlane(unsigned int plane, GLfloat *equation) const;

    FogParameters &fogParameters();

    const FogParameters &fogParameters() const;

    TextureEnvironmentParameters &textureEnvironment(unsigned int unit);

    const TextureEnvironmentParameters &textureEnvironment(unsigned int unit) const;

    PointParameters &pointParameters();

    const PointParameters &pointParameters() const;

    AttributesMask getVertexArraysAttributeMask() const;

    AttributesMask getActiveAttributesMask() const;

    bool shouldHandleDirtyProgram();

    void setHint(GLenum target, GLenum mode);

    GLenum getHint(GLenum target) const;

    enum DirtyGles1Type

        DIRTY_GLES1_TEXTURE_UNIT_ENABLE = 0,

        DIRTY_GLES1_CLIENT_STATE_ENABLE,

        DIRTY_GLES1_FEATURE_ENABLE,

        DIRTY_GLES1_CURRENT_VECTOR,

        DIRTY_GLES1_CLIENT_ACTIVE_TEXTURE,

        DIRTY_GLES1_MATRICES,

        DIRTY_GLES1_TEXTURE_ENVIRONMENT,

        DIRTY_GLES1_MATERIAL,

        DIRTY_GLES1_LIGHTS,

        DIRTY_GLES1_FOG,

        DIRTY_GLES1_SHADE_MODEL,

        DIRTY_GLES1_POINT_PARAMETERS,

        DIRTY_GLES1_ALPHA_TEST,

        DIRTY_GLES1_LOGIC_OP,

        DIRTY_GLES1_CLIP_PLANES,

        DIRTY_GLES1_HINT_SETTING,

        DIRTY_GLES1_PROGRAM,

        DIRTY_GLES1_MAX,

};

    void setAllDirty() { mDirtyBits.set(); }

  private:

    friend class State;

    friend class GLES1Renderer;

    // Back pointer for reading from State.

    const State *mGLState;

    using DirtyBits = angle::BitSet<DIRTY_GLES1_MAX>;

    DirtyBits mDirtyBits;

    void setDirty(DirtyGles1Type type) { mDirtyBits.set(type); }

    void clearDirty() { mDirtyBits.reset(); }

    void clearDirtyBits(const DirtyGles1Type &bitset) { mDirtyBits &= ~bitset; }

    bool isDirty(DirtyGles1Type type) const { return mDirtyBits.test(type); }

    // All initial state values come from the

    // OpenGL ES 1.1 spec.

    std::vector<angle::PackedEnumBitSet<TextureType>> mTexUnitEnables;

    // Table 6.4, 6.5 (IsEnabled)

    bool mVertexArrayEnabled;

    bool mNormalArrayEnabled;

    bool mColorArrayEnabled;

    bool mPointSizeArrayEnabled;

    std::vector<bool> mTexCoordArrayEnabled;

    // Table 6.7-6.16 (IsEnabled)

    bool mLineSmoothEnabled;

    bool mPointSmoothEnabled;

    bool mPointSpriteEnabled;

    bool mAlphaTestEnabled;

    bool mLogicOpEnabled;

    bool mLightingEnabled;

    bool mFogEnabled;

    bool mRescaleNormalEnabled;

    bool mNormalizeEnabled;

    bool mColorMaterialEnabled;

    bool mReflectionMapEnabled;

    // Table 6.3

    ColorF mCurrentColor;

    angle::Vector3 mCurrentNormal;

    // Invariant: mCurrentTextureCoords size is == GL_MAX_TEXTURE_UNITS.

    std::vector<TextureCoordF> mCurrentTextureCoords;

    // Table 6.4

    unsigned int mClientActiveTexture;

    // Table 6.7

    MatrixType mMatrixMode;

    MatrixStack mProjectionMatrices;

    MatrixStack mModelviewMatrices;

    std::vector<MatrixStack> mTextureMatrices;

    // Table 6.15

    using TextureEnvironments = std::vector<TextureEnvironmentParameters>;

    TextureEnvironments mTextureEnvironments;

    // Table 6.9, 2.8

    MaterialParameters mMaterial;

    LightModelParameters mLightModel;

    // Table 6.10

    std::vector<LightParameters> mLights;

    // Table 6.8

    FogParameters mFog;

    ShadingModel mShadeModel;

    // Table 6.11

    PointParameters mPointParameters;

    // Table 6.16

    AlphaTestFunc mAlphaTestFunc;

    GLfloat mAlphaTestRef;

    LogicalOperation mLogicOp;

    // Table 6.7

    std::vector<ClipPlaneParameters> mClipPlanes;

    // Table 6.19

    HintSetting mLineSmoothHint;

    HintSetting mPointSmoothHint;

    HintSetting mPerspectiveCorrectionHint;

    HintSetting mFogHint;

};

}  // namespace gl

#endif  // LIBANGLE_GLES1STATE_H_