| #ifndef _RRRENDERSTATE_HPP |
| #define _RRRENDERSTATE_HPP |
| /*------------------------------------------------------------------------- |
| * drawElements Quality Program Reference Renderer |
| * ----------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Reference renderer render state. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "rrDefs.hpp" |
| #include "rrMultisamplePixelBufferAccess.hpp" |
| #include "tcuTexture.hpp" |
| |
| namespace rr |
| { |
| |
| //! Horizontal fill rule |
| enum HorizontalFill |
| { |
| FILL_LEFT, |
| FILL_RIGHT |
| }; |
| |
| //! Vertical fill rule |
| enum VerticalFill |
| { |
| FILL_TOP, |
| FILL_BOTTOM, |
| }; |
| |
| //! Winding mode |
| enum Winding |
| { |
| WINDING_CCW = 0, //!< Counter-clockwise winding |
| WINDING_CW, //!< Clockwise winding |
| |
| WINDING_LAST |
| }; |
| |
| //! Triangle cull mode |
| enum CullMode |
| { |
| CULLMODE_NONE, |
| CULLMODE_BACK, |
| CULLMODE_FRONT, |
| |
| CULLMODE_LAST |
| }; |
| |
| //! Viewport Orientation of renderer this will be compared against |
| enum ViewportOrientation |
| { |
| VIEWPORTORIENTATION_LOWER_LEFT = 0, //<! Corresponds to GL |
| VIEWPORTORIENTATION_UPPER_LEFT, //<! Corresponds to Vulkan |
| |
| VIEWPORTORIENTATION_LAST |
| }; |
| |
| struct RasterizationState |
| { |
| RasterizationState(void) |
| : winding(WINDING_CCW) |
| , horizontalFill(FILL_LEFT) |
| , verticalFill(FILL_BOTTOM) |
| , viewportOrientation(VIEWPORTORIENTATION_LAST) |
| { |
| } |
| |
| Winding winding; |
| HorizontalFill horizontalFill; |
| VerticalFill verticalFill; |
| ViewportOrientation viewportOrientation; |
| }; |
| |
| enum TestFunc |
| { |
| TESTFUNC_NEVER = 0, |
| TESTFUNC_ALWAYS, |
| TESTFUNC_LESS, |
| TESTFUNC_LEQUAL, |
| TESTFUNC_GREATER, |
| TESTFUNC_GEQUAL, |
| TESTFUNC_EQUAL, |
| TESTFUNC_NOTEQUAL, |
| |
| TESTFUNC_LAST |
| }; |
| |
| enum StencilOp |
| { |
| STENCILOP_KEEP = 0, |
| STENCILOP_ZERO, |
| STENCILOP_REPLACE, |
| STENCILOP_INCR, //!< Increment with saturation. |
| STENCILOP_DECR, //!< Decrement with saturation. |
| STENCILOP_INCR_WRAP, |
| STENCILOP_DECR_WRAP, |
| STENCILOP_INVERT, |
| |
| STENCILOP_LAST |
| }; |
| |
| enum BlendMode |
| { |
| BLENDMODE_NONE = 0, //!< No blending. |
| BLENDMODE_STANDARD, //!< Standard blending. |
| BLENDMODE_ADVANCED, //!< Advanced blending mode, as defined in GL_KHR_blend_equation_advanced. |
| |
| BLENDMODE_LAST |
| }; |
| |
| enum BlendEquation |
| { |
| BLENDEQUATION_ADD = 0, |
| BLENDEQUATION_SUBTRACT, |
| BLENDEQUATION_REVERSE_SUBTRACT, |
| BLENDEQUATION_MIN, |
| BLENDEQUATION_MAX, |
| |
| BLENDEQUATION_LAST |
| }; |
| |
| enum BlendEquationAdvanced |
| { |
| BLENDEQUATION_ADVANCED_MULTIPLY = 0, |
| BLENDEQUATION_ADVANCED_SCREEN, |
| BLENDEQUATION_ADVANCED_OVERLAY, |
| BLENDEQUATION_ADVANCED_DARKEN, |
| BLENDEQUATION_ADVANCED_LIGHTEN, |
| BLENDEQUATION_ADVANCED_COLORDODGE, |
| BLENDEQUATION_ADVANCED_COLORBURN, |
| BLENDEQUATION_ADVANCED_HARDLIGHT, |
| BLENDEQUATION_ADVANCED_SOFTLIGHT, |
| BLENDEQUATION_ADVANCED_DIFFERENCE, |
| BLENDEQUATION_ADVANCED_EXCLUSION, |
| BLENDEQUATION_ADVANCED_HSL_HUE, |
| BLENDEQUATION_ADVANCED_HSL_SATURATION, |
| BLENDEQUATION_ADVANCED_HSL_COLOR, |
| BLENDEQUATION_ADVANCED_HSL_LUMINOSITY, |
| |
| BLENDEQUATION_ADVANCED_LAST |
| }; |
| |
| enum BlendFunc |
| { |
| BLENDFUNC_ZERO = 0, |
| BLENDFUNC_ONE, |
| BLENDFUNC_SRC_COLOR, |
| BLENDFUNC_ONE_MINUS_SRC_COLOR, |
| BLENDFUNC_DST_COLOR, |
| BLENDFUNC_ONE_MINUS_DST_COLOR, |
| BLENDFUNC_SRC_ALPHA, |
| BLENDFUNC_ONE_MINUS_SRC_ALPHA, |
| BLENDFUNC_DST_ALPHA, |
| BLENDFUNC_ONE_MINUS_DST_ALPHA, |
| BLENDFUNC_CONSTANT_COLOR, |
| BLENDFUNC_ONE_MINUS_CONSTANT_COLOR, |
| BLENDFUNC_CONSTANT_ALPHA, |
| BLENDFUNC_ONE_MINUS_CONSTANT_ALPHA, |
| BLENDFUNC_SRC_ALPHA_SATURATE, |
| BLENDFUNC_SRC1_COLOR, |
| BLENDFUNC_ONE_MINUS_SRC1_COLOR, |
| BLENDFUNC_SRC1_ALPHA, |
| BLENDFUNC_ONE_MINUS_SRC1_ALPHA, |
| |
| BLENDFUNC_LAST |
| }; |
| |
| struct StencilState |
| { |
| TestFunc func; |
| int ref; |
| uint32_t compMask; |
| StencilOp sFail; |
| StencilOp dpFail; |
| StencilOp dpPass; |
| uint32_t writeMask; |
| |
| StencilState(void) |
| : func(TESTFUNC_ALWAYS) |
| , ref(0) |
| , compMask(~0U) |
| , sFail(STENCILOP_KEEP) |
| , dpFail(STENCILOP_KEEP) |
| , dpPass(STENCILOP_KEEP) |
| , writeMask(~0U) |
| { |
| } |
| }; |
| |
| struct BlendState |
| { |
| BlendEquation equation; |
| BlendFunc srcFunc; |
| BlendFunc dstFunc; |
| |
| BlendState(void) : equation(BLENDEQUATION_ADD), srcFunc(BLENDFUNC_ONE), dstFunc(BLENDFUNC_ZERO) |
| { |
| } |
| }; |
| |
| struct WindowRectangle |
| { |
| int left; |
| int bottom; |
| int width; |
| int height; |
| |
| WindowRectangle(int left_, int bottom_, int width_, int height_) |
| : left(left_) |
| , bottom(bottom_) |
| , width(width_) |
| , height(height_) |
| { |
| } |
| }; |
| |
| struct FragmentOperationState |
| { |
| // Variables corresponding to GL state variables. |
| |
| bool scissorTestEnabled; |
| WindowRectangle scissorRectangle; |
| |
| bool stencilTestEnabled; |
| StencilState stencilStates[2]; //!< Indexed with FACETYPE_FRONT and FACETYPE_BACK. |
| |
| bool depthTestEnabled; |
| TestFunc depthFunc; |
| bool depthMask; |
| |
| bool depthBoundsTestEnabled; |
| float minDepthBound; |
| float maxDepthBound; |
| |
| BlendMode blendMode; |
| |
| // Standard blending state |
| BlendState blendRGBState; |
| BlendState blendAState; |
| tcu::Vec4 blendColor; //!< Components should be in range [0, 1]. |
| |
| BlendEquationAdvanced blendEquationAdvaced; |
| |
| bool sRGBEnabled; |
| |
| bool depthClampEnabled; |
| |
| bool polygonOffsetEnabled; |
| float polygonOffsetFactor; |
| float polygonOffsetUnits; |
| |
| tcu::BVec4 colorMask; |
| |
| // Variables not corresponding to configurable GL state, but other GL variables. |
| |
| int numStencilBits; |
| |
| FragmentOperationState(void) |
| : scissorTestEnabled(false) |
| , scissorRectangle(0, 0, 1, 1) |
| |
| , stencilTestEnabled(false) |
| // \note stencilStates[] members get default-constructed. |
| |
| , depthTestEnabled(false) |
| , depthFunc(TESTFUNC_LESS) |
| , depthMask(true) |
| |
| , depthBoundsTestEnabled(false) |
| , minDepthBound(0.0f) |
| , maxDepthBound(1.0f) |
| |
| , blendMode(BLENDMODE_NONE) |
| , blendRGBState() |
| , blendAState() |
| , blendColor(0.0f) |
| , blendEquationAdvaced(BLENDEQUATION_ADVANCED_LAST) |
| |
| , sRGBEnabled(true) |
| |
| , depthClampEnabled(false) |
| |
| , polygonOffsetEnabled(false) |
| , polygonOffsetFactor(0.0f) |
| , polygonOffsetUnits(0.0f) |
| |
| , colorMask(true) |
| |
| , numStencilBits(8) |
| { |
| } |
| }; |
| |
| struct PointState |
| { |
| float pointSize; |
| |
| PointState(void) : pointSize(1.0f) |
| { |
| } |
| }; |
| |
| struct LineState |
| { |
| float lineWidth; |
| |
| LineState(void) : lineWidth(1.0f) |
| { |
| } |
| }; |
| |
| struct ViewportState |
| { |
| WindowRectangle rect; |
| float zn; |
| float zf; |
| |
| explicit ViewportState(const WindowRectangle &rect_) : rect(rect_), zn(0.0f), zf(1.0f) |
| { |
| } |
| |
| explicit ViewportState(const rr::MultisampleConstPixelBufferAccess &multisampleBuffer) |
| : rect(0, 0, multisampleBuffer.raw().getHeight(), multisampleBuffer.raw().getDepth()) |
| , zn(0.0f) |
| , zf(1.0f) |
| { |
| } |
| }; |
| |
| struct RestartState |
| { |
| bool enabled; |
| uint32_t restartIndex; |
| |
| RestartState(void) : enabled(false), restartIndex(0xFFFFFFFFul) |
| { |
| } |
| }; |
| |
| //! Rasterizer configuration |
| struct RenderState |
| { |
| explicit RenderState(const ViewportState &viewport_, const int subpixelBits_, |
| ViewportOrientation viewportOrientation_ = VIEWPORTORIENTATION_LOWER_LEFT) |
| : cullMode(CULLMODE_NONE) |
| , provokingVertexConvention(PROVOKINGVERTEX_LAST) |
| , viewport(viewport_) |
| , viewportOrientation(viewportOrientation_) |
| , subpixelBits(subpixelBits_) |
| { |
| rasterization.viewportOrientation = viewportOrientation; |
| } |
| |
| enum |
| { |
| DEFAULT_SUBPIXEL_BITS = 8 |
| }; |
| |
| CullMode cullMode; |
| ProvokingVertex provokingVertexConvention; |
| RasterizationState rasterization; |
| FragmentOperationState fragOps; |
| PointState point; |
| ViewportState viewport; |
| LineState line; |
| RestartState restart; |
| ViewportOrientation viewportOrientation; |
| const int subpixelBits; |
| }; |
| |
| } // namespace rr |
| |
| #endif // _RRRENDERSTATE_HPP |