diff options
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/GLES1State.h')
| -rw-r--r-- | gfx/angle/checkout/src/libANGLE/GLES1State.h | 351 |
1 files changed, 351 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/GLES1State.h b/gfx/angle/checkout/src/libANGLE/GLES1State.h new file mode 100644 index 0000000000..e9c108b58b --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/GLES1State.h @@ -0,0 +1,351 @@ +// +// 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_ |