Quelle  GLES1State.h   Sprache: C

//
// 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 ¤tMatrixStack();
    const MatrixStack ¤tMatrixStack() 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_