blob: a591a0e165b9610996f703cb87f30d5e36482fa6 [file] [log] [blame]
#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;
deUint32 compMask;
StencilOp sFail;
StencilOp dpFail;
StencilOp dpPass;
deUint32 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;
deUint32 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;
};
} // rr
#endif // _RRRENDERSTATE_HPP