diff options
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/GLES1State.cpp')
| -rw-r--r-- | gfx/angle/checkout/src/libANGLE/GLES1State.cpp | 609 |
1 files changed, 609 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/GLES1State.cpp b/gfx/angle/checkout/src/libANGLE/GLES1State.cpp new file mode 100644 index 0000000000..17ad0de3ad --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/GLES1State.cpp @@ -0,0 +1,609 @@ +// +// 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.cpp: Implements the GLES1State class, tracking state +// for GLES1 contexts. + +#include "libANGLE/GLES1State.h" + +#include "libANGLE/Context.h" +#include "libANGLE/GLES1Renderer.h" + +namespace gl +{ + +TextureCoordF::TextureCoordF() = default; + +TextureCoordF::TextureCoordF(float _s, float _t, float _r, float _q) : s(_s), t(_t), r(_r), q(_q) {} + +bool TextureCoordF::operator==(const TextureCoordF &other) const +{ + return s == other.s && t == other.t && r == other.r && q == other.q; +} + +MaterialParameters::MaterialParameters() = default; + +LightModelParameters::LightModelParameters() = default; + +LightParameters::LightParameters() = default; + +LightParameters::LightParameters(const LightParameters &other) = default; + +FogParameters::FogParameters() = default; + +TextureEnvironmentParameters::TextureEnvironmentParameters() = default; + +TextureEnvironmentParameters::TextureEnvironmentParameters( + const TextureEnvironmentParameters &other) = default; + +PointParameters::PointParameters() = default; + +PointParameters::PointParameters(const PointParameters &other) = default; + +ClipPlaneParameters::ClipPlaneParameters() = default; + +ClipPlaneParameters::ClipPlaneParameters(bool enabled, const angle::Vector4 &equation) + : enabled(enabled), equation(equation) +{} + +ClipPlaneParameters::ClipPlaneParameters(const ClipPlaneParameters &other) = default; + +ClipPlaneParameters &ClipPlaneParameters::operator=(const ClipPlaneParameters &other) = default; + +GLES1State::GLES1State() + : mGLState(nullptr), + mVertexArrayEnabled(false), + mNormalArrayEnabled(false), + mColorArrayEnabled(false), + mPointSizeArrayEnabled(false), + mLineSmoothEnabled(false), + mPointSmoothEnabled(false), + mPointSpriteEnabled(false), + mAlphaTestEnabled(false), + mLogicOpEnabled(false), + mLightingEnabled(false), + mFogEnabled(false), + mRescaleNormalEnabled(false), + mNormalizeEnabled(false), + mColorMaterialEnabled(false), + mReflectionMapEnabled(false), + mCurrentColor({0.0f, 0.0f, 0.0f, 0.0f}), + mCurrentNormal({0.0f, 0.0f, 0.0f}), + mClientActiveTexture(0), + mMatrixMode(MatrixType::Modelview), + mShadeModel(ShadingModel::Smooth), + mAlphaTestFunc(AlphaTestFunc::AlwaysPass), + mAlphaTestRef(0.0f), + mLogicOp(LogicalOperation::Copy), + mLineSmoothHint(HintSetting::DontCare), + mPointSmoothHint(HintSetting::DontCare), + mPerspectiveCorrectionHint(HintSetting::DontCare), + mFogHint(HintSetting::DontCare) +{} + +GLES1State::~GLES1State() = default; + +// Taken from the GLES 1.x spec which specifies all initial state values. +void GLES1State::initialize(const Context *context, const State *state) +{ + mGLState = state; + + const Caps &caps = context->getCaps(); + + mTexUnitEnables.resize(caps.maxMultitextureUnits); + for (auto &enables : mTexUnitEnables) + { + enables.reset(); + } + + mVertexArrayEnabled = false; + mNormalArrayEnabled = false; + mColorArrayEnabled = false; + mPointSizeArrayEnabled = false; + mTexCoordArrayEnabled.resize(caps.maxMultitextureUnits, false); + + mLineSmoothEnabled = false; + mPointSmoothEnabled = false; + mPointSpriteEnabled = false; + mLogicOpEnabled = false; + mAlphaTestEnabled = false; + mLightingEnabled = false; + mFogEnabled = false; + mRescaleNormalEnabled = false; + mNormalizeEnabled = false; + mColorMaterialEnabled = false; + mReflectionMapEnabled = false; + + mMatrixMode = MatrixType::Modelview; + + mCurrentColor = {1.0f, 1.0f, 1.0f, 1.0f}; + mCurrentNormal = {0.0f, 0.0f, 1.0f}; + mCurrentTextureCoords.resize(caps.maxMultitextureUnits); + mClientActiveTexture = 0; + + mTextureEnvironments.resize(caps.maxMultitextureUnits); + + mModelviewMatrices.push_back(angle::Mat4()); + mProjectionMatrices.push_back(angle::Mat4()); + mTextureMatrices.resize(caps.maxMultitextureUnits); + for (auto &stack : mTextureMatrices) + { + stack.push_back(angle::Mat4()); + } + + mMaterial.ambient = {0.2f, 0.2f, 0.2f, 1.0f}; + mMaterial.diffuse = {0.8f, 0.8f, 0.8f, 1.0f}; + mMaterial.specular = {0.0f, 0.0f, 0.0f, 1.0f}; + mMaterial.emissive = {0.0f, 0.0f, 0.0f, 1.0f}; + + mMaterial.specularExponent = 0.0f; + + mLightModel.color = {0.2f, 0.2f, 0.2f, 1.0f}; + mLightModel.twoSided = false; + + mLights.resize(caps.maxLights); + + // GL_LIGHT0 is special and has default state that avoids all-black renderings. + mLights[0].diffuse = {1.0f, 1.0f, 1.0f, 1.0f}; + mLights[0].specular = {1.0f, 1.0f, 1.0f, 1.0f}; + + mFog.mode = FogMode::Exp; + mFog.density = 1.0f; + mFog.start = 0.0f; + mFog.end = 1.0f; + + mFog.color = {0.0f, 0.0f, 0.0f, 0.0f}; + + mShadeModel = ShadingModel::Smooth; + + mAlphaTestFunc = AlphaTestFunc::AlwaysPass; + mAlphaTestRef = 0.0f; + + mLogicOp = LogicalOperation::Copy; + + mClipPlanes.resize(caps.maxClipPlanes, + ClipPlaneParameters(false, angle::Vector4(0.0f, 0.0f, 0.0f, 0.0f))); + + mLineSmoothHint = HintSetting::DontCare; + mPointSmoothHint = HintSetting::DontCare; + mPerspectiveCorrectionHint = HintSetting::DontCare; + mFogHint = HintSetting::DontCare; + + // The user-specified point size, GL_POINT_SIZE_MAX, + // is initially equal to the implementation maximum. + mPointParameters.pointSizeMax = caps.maxAliasedPointSize; + + mDirtyBits.set(); +} + +void GLES1State::setAlphaFunc(AlphaTestFunc func, GLfloat ref) +{ + setDirty(DIRTY_GLES1_ALPHA_TEST); + mAlphaTestFunc = func; + mAlphaTestRef = ref; +} + +void GLES1State::setClientTextureUnit(unsigned int unit) +{ + setDirty(DIRTY_GLES1_CLIENT_ACTIVE_TEXTURE); + mClientActiveTexture = unit; +} + +unsigned int GLES1State::getClientTextureUnit() const +{ + return mClientActiveTexture; +} + +void GLES1State::setCurrentColor(const ColorF &color) +{ + setDirty(DIRTY_GLES1_CURRENT_VECTOR); + mCurrentColor = color; + + // > When enabled, both the ambient (acm) and diffuse (dcm) properties of both the front and + // > back material are immediately set to the value of the current color, and will track changes + // > to the current color resulting from either the Color commands or drawing vertex arrays with + // > the color array enabled. + // > The replacements made to material properties are permanent; the replaced values remain + // > until changed by either sending a new color or by setting a new material value when + // > COLOR_MATERIAL is not currently enabled, to override that particular value. + if (isColorMaterialEnabled()) + { + mMaterial.ambient = color; + mMaterial.diffuse = color; + } +} + +const ColorF &GLES1State::getCurrentColor() const +{ + return mCurrentColor; +} + +void GLES1State::setCurrentNormal(const angle::Vector3 &normal) +{ + setDirty(DIRTY_GLES1_CURRENT_VECTOR); + mCurrentNormal = normal; +} + +const angle::Vector3 &GLES1State::getCurrentNormal() const +{ + return mCurrentNormal; +} + +bool GLES1State::shouldHandleDirtyProgram() +{ + bool ret = isDirty(DIRTY_GLES1_PROGRAM); + clearDirtyBits(DIRTY_GLES1_PROGRAM); + return ret; +} + +void GLES1State::setCurrentTextureCoords(unsigned int unit, const TextureCoordF &coords) +{ + setDirty(DIRTY_GLES1_CURRENT_VECTOR); + mCurrentTextureCoords[unit] = coords; +} + +const TextureCoordF &GLES1State::getCurrentTextureCoords(unsigned int unit) const +{ + return mCurrentTextureCoords[unit]; +} + +void GLES1State::setMatrixMode(MatrixType mode) +{ + setDirty(DIRTY_GLES1_MATRICES); + mMatrixMode = mode; +} + +MatrixType GLES1State::getMatrixMode() const +{ + return mMatrixMode; +} + +GLint GLES1State::getCurrentMatrixStackDepth(GLenum queryType) const +{ + switch (queryType) + { + case GL_MODELVIEW_STACK_DEPTH: + return clampCast<GLint>(mModelviewMatrices.size()); + case GL_PROJECTION_STACK_DEPTH: + return clampCast<GLint>(mProjectionMatrices.size()); + case GL_TEXTURE_STACK_DEPTH: + return clampCast<GLint>(mTextureMatrices[mGLState->getActiveSampler()].size()); + default: + UNREACHABLE(); + return 0; + } +} + +void GLES1State::pushMatrix() +{ + setDirty(DIRTY_GLES1_MATRICES); + auto &stack = currentMatrixStack(); + stack.push_back(stack.back()); +} + +void GLES1State::popMatrix() +{ + setDirty(DIRTY_GLES1_MATRICES); + auto &stack = currentMatrixStack(); + stack.pop_back(); +} + +GLES1State::MatrixStack &GLES1State::currentMatrixStack() +{ + setDirty(DIRTY_GLES1_MATRICES); + switch (mMatrixMode) + { + case MatrixType::Modelview: + return mModelviewMatrices; + case MatrixType::Projection: + return mProjectionMatrices; + case MatrixType::Texture: + return mTextureMatrices[mGLState->getActiveSampler()]; + default: + UNREACHABLE(); + return mModelviewMatrices; + } +} + +const angle::Mat4 &GLES1State::getModelviewMatrix() const +{ + return mModelviewMatrices.back(); +} + +const GLES1State::MatrixStack &GLES1State::getMatrixStack(MatrixType mode) const +{ + switch (mode) + { + case MatrixType::Modelview: + return mModelviewMatrices; + case MatrixType::Projection: + return mProjectionMatrices; + case MatrixType::Texture: + return mTextureMatrices[mGLState->getActiveSampler()]; + default: + UNREACHABLE(); + return mModelviewMatrices; + } +} + +const GLES1State::MatrixStack &GLES1State::currentMatrixStack() const +{ + return getMatrixStack(mMatrixMode); +} + +void GLES1State::loadMatrix(const angle::Mat4 &m) +{ + setDirty(DIRTY_GLES1_MATRICES); + currentMatrixStack().back() = m; +} + +void GLES1State::multMatrix(const angle::Mat4 &m) +{ + setDirty(DIRTY_GLES1_MATRICES); + angle::Mat4 currentMatrix = currentMatrixStack().back(); + currentMatrixStack().back() = currentMatrix.product(m); +} + +void GLES1State::setLogicOpEnabled(bool enabled) +{ + setDirty(DIRTY_GLES1_LOGIC_OP); + mLogicOpEnabled = enabled; +} + +void GLES1State::setLogicOp(LogicalOperation opcodePacked) +{ + setDirty(DIRTY_GLES1_LOGIC_OP); + mLogicOp = opcodePacked; +} + +void GLES1State::setClientStateEnabled(ClientVertexArrayType clientState, bool enable) +{ + setDirty(DIRTY_GLES1_CLIENT_STATE_ENABLE); + switch (clientState) + { + case ClientVertexArrayType::Vertex: + mVertexArrayEnabled = enable; + break; + case ClientVertexArrayType::Normal: + mNormalArrayEnabled = enable; + break; + case ClientVertexArrayType::Color: + mColorArrayEnabled = enable; + break; + case ClientVertexArrayType::PointSize: + mPointSizeArrayEnabled = enable; + break; + case ClientVertexArrayType::TextureCoord: + mTexCoordArrayEnabled[mClientActiveTexture] = enable; + break; + default: + UNREACHABLE(); + break; + } +} + +void GLES1State::setTexCoordArrayEnabled(unsigned int unit, bool enable) +{ + setDirty(DIRTY_GLES1_CLIENT_STATE_ENABLE); + mTexCoordArrayEnabled[unit] = enable; +} + +bool GLES1State::isClientStateEnabled(ClientVertexArrayType clientState) const +{ + switch (clientState) + { + case ClientVertexArrayType::Vertex: + return mVertexArrayEnabled; + case ClientVertexArrayType::Normal: + return mNormalArrayEnabled; + case ClientVertexArrayType::Color: + return mColorArrayEnabled; + case ClientVertexArrayType::PointSize: + return mPointSizeArrayEnabled; + case ClientVertexArrayType::TextureCoord: + return mTexCoordArrayEnabled[mClientActiveTexture]; + default: + UNREACHABLE(); + return false; + } +} + +bool GLES1State::isTexCoordArrayEnabled(unsigned int unit) const +{ + ASSERT(unit < mTexCoordArrayEnabled.size()); + return mTexCoordArrayEnabled[unit]; +} + +bool GLES1State::isTextureTargetEnabled(unsigned int unit, const TextureType type) const +{ + if (mTexUnitEnables.empty()) + { + return false; + } + return mTexUnitEnables[unit].test(type); +} + +LightModelParameters &GLES1State::lightModelParameters() +{ + setDirty(DIRTY_GLES1_LIGHTS); + return mLightModel; +} + +const LightModelParameters &GLES1State::lightModelParameters() const +{ + return mLightModel; +} + +LightParameters &GLES1State::lightParameters(unsigned int light) +{ + setDirty(DIRTY_GLES1_LIGHTS); + return mLights[light]; +} + +const LightParameters &GLES1State::lightParameters(unsigned int light) const +{ + return mLights[light]; +} + +MaterialParameters &GLES1State::materialParameters() +{ + setDirty(DIRTY_GLES1_MATERIAL); + return mMaterial; +} + +const MaterialParameters &GLES1State::materialParameters() const +{ + return mMaterial; +} + +bool GLES1State::isColorMaterialEnabled() const +{ + return mColorMaterialEnabled; +} + +void GLES1State::setShadeModel(ShadingModel model) +{ + setDirty(DIRTY_GLES1_SHADE_MODEL); + mShadeModel = model; +} + +void GLES1State::setClipPlane(unsigned int plane, const GLfloat *equation) +{ + setDirty(DIRTY_GLES1_CLIP_PLANES); + assert(plane < mClipPlanes.size()); + mClipPlanes[plane].equation[0] = equation[0]; + mClipPlanes[plane].equation[1] = equation[1]; + mClipPlanes[plane].equation[2] = equation[2]; + mClipPlanes[plane].equation[3] = equation[3]; +} + +void GLES1State::getClipPlane(unsigned int plane, GLfloat *equation) const +{ + assert(plane < mClipPlanes.size()); + equation[0] = mClipPlanes[plane].equation[0]; + equation[1] = mClipPlanes[plane].equation[1]; + equation[2] = mClipPlanes[plane].equation[2]; + equation[3] = mClipPlanes[plane].equation[3]; +} + +FogParameters &GLES1State::fogParameters() +{ + setDirty(DIRTY_GLES1_FOG); + return mFog; +} + +const FogParameters &GLES1State::fogParameters() const +{ + return mFog; +} + +TextureEnvironmentParameters &GLES1State::textureEnvironment(unsigned int unit) +{ + setDirty(DIRTY_GLES1_TEXTURE_ENVIRONMENT); + assert(unit < mTextureEnvironments.size()); + return mTextureEnvironments[unit]; +} + +const TextureEnvironmentParameters &GLES1State::textureEnvironment(unsigned int unit) const +{ + assert(unit < mTextureEnvironments.size()); + return mTextureEnvironments[unit]; +} + +bool operator==(const TextureEnvironmentParameters &a, const TextureEnvironmentParameters &b) +{ + return a.tie() == b.tie(); +} + +bool operator!=(const TextureEnvironmentParameters &a, const TextureEnvironmentParameters &b) +{ + return !(a == b); +} + +PointParameters &GLES1State::pointParameters() +{ + setDirty(DIRTY_GLES1_POINT_PARAMETERS); + return mPointParameters; +} + +const PointParameters &GLES1State::pointParameters() const +{ + return mPointParameters; +} + +AttributesMask GLES1State::getVertexArraysAttributeMask() const +{ + AttributesMask attribsMask; + + ClientVertexArrayType nonTexcoordArrays[] = { + ClientVertexArrayType::Vertex, + ClientVertexArrayType::Normal, + ClientVertexArrayType::Color, + ClientVertexArrayType::PointSize, + }; + + for (const ClientVertexArrayType attrib : nonTexcoordArrays) + { + attribsMask.set(GLES1Renderer::VertexArrayIndex(attrib, *this), + isClientStateEnabled(attrib)); + } + + for (unsigned int i = 0; i < kTexUnitCount; i++) + { + attribsMask.set(GLES1Renderer::TexCoordArrayIndex(i), isTexCoordArrayEnabled(i)); + } + + return attribsMask; +} + +AttributesMask GLES1State::getActiveAttributesMask() const +{ + // The program always has 8 attributes enabled. + return AttributesMask(0xFF); +} + +void GLES1State::setHint(GLenum target, GLenum mode) +{ + setDirty(DIRTY_GLES1_HINT_SETTING); + HintSetting setting = FromGLenum<HintSetting>(mode); + switch (target) + { + case GL_PERSPECTIVE_CORRECTION_HINT: + mPerspectiveCorrectionHint = setting; + break; + case GL_POINT_SMOOTH_HINT: + mPointSmoothHint = setting; + break; + case GL_LINE_SMOOTH_HINT: + mLineSmoothHint = setting; + break; + case GL_FOG_HINT: + mFogHint = setting; + break; + default: + UNREACHABLE(); + } +} + +GLenum GLES1State::getHint(GLenum target) const +{ + switch (target) + { + case GL_PERSPECTIVE_CORRECTION_HINT: + return ToGLenum(mPerspectiveCorrectionHint); + case GL_POINT_SMOOTH_HINT: + return ToGLenum(mPointSmoothHint); + case GL_LINE_SMOOTH_HINT: + return ToGLenum(mLineSmoothHint); + case GL_FOG_HINT: + return ToGLenum(mFogHint); + default: + UNREACHABLE(); + return 0; + } +} + +} // namespace gl |