rrFragmentOperations.hpp revision 3c827367444ee418f129b2c238299f49d3264554 
1#ifndef _RRFRAGMENTOPERATIONS_HPP
2#define _RRFRAGMENTOPERATIONS_HPP
3/*-------------------------------------------------------------------------
4 * drawElements Quality Program Reference Renderer
5 * -----------------------------------------------
6 *
7 * Copyright 2014 The Android Open Source Project
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief Reference implementation for per-fragment operations.
24 *
25 * \note In this file, a multisample buffer means a tcu::PixelBufferAccess
26 *		 (or ConstPixelBufferAccess) where the x coordinate is the sample
27 *		 index and the y and z coordinates are the pixel's x and y
28 *		 coordinates, respectively. To prevent supplying a buffer in
29 *		 a wrong format the buffers are wrapped in rr::MultisamplePixelBufferAccess
30 *		 wrapper. FragmentProcessor::render() operates on
31 *		 this kind of buffers. The function fromSinglesampleAccess() can be
32 *		 used to get a one-sampled multisample access to a normal 2d
33 *		 buffer.
34 *//*--------------------------------------------------------------------*/
35
36#include "rrDefs.hpp"
37#include "tcuVector.hpp"
38#include "tcuTexture.hpp"
39#include "rrRenderState.hpp"
40#include "rrGenericVector.hpp"
41#include "rrMultisamplePixelBufferAccess.hpp"
42
43namespace rr
44{
45
46struct Fragment
47{
48	tcu::IVec2			pixelCoord;
49	GenericVec4			value;
50	GenericVec4			value1;
51	deUint32			coverage;
52	const float*		sampleDepths;
53
54	Fragment (const tcu::IVec2& pixelCoord_, const GenericVec4& value_, deUint32 coverage_, const float* sampleDepths_)
55		: pixelCoord	(pixelCoord_)
56		, value			(value_)
57		, value1		()
58		, coverage		(coverage_)
59		, sampleDepths	(sampleDepths_)
60	{
61	}
62
63	Fragment (const tcu::IVec2& pixelCoord_, const GenericVec4& value_, const GenericVec4& value1_, deUint32 coverage_, const float* sampleDepths_)
64		: pixelCoord	(pixelCoord_)
65		, value			(value_)
66		, value1		(value1_)
67		, coverage		(coverage_)
68		, sampleDepths	(sampleDepths_)
69	{
70	}
71
72	Fragment (void)
73		: pixelCoord	(0)
74		, value			()
75		, coverage		(0)
76		, sampleDepths	(DE_NULL)
77	{
78	}
79};
80
81// These functions are for clearing only a specific pixel rectangle in a multisample buffer.
82// When clearing the entire buffer, tcu::clear, tcu::clearDepth and tcu::clearStencil can be used.
83void clearMultisampleColorBuffer		(const tcu::PixelBufferAccess& dst, const tcu::Vec4&	value, const WindowRectangle& rect);
84void clearMultisampleColorBuffer		(const tcu::PixelBufferAccess& dst, const tcu::IVec4&	value, const WindowRectangle& rect);
85void clearMultisampleColorBuffer		(const tcu::PixelBufferAccess& dst, const tcu::UVec4&	value, const WindowRectangle& rect);
86void clearMultisampleDepthBuffer		(const tcu::PixelBufferAccess& dst, float				value, const WindowRectangle& rect);
87void clearMultisampleStencilBuffer		(const tcu::PixelBufferAccess& dst, int					value, const WindowRectangle& rect);
88
89/*--------------------------------------------------------------------*//*!
90 * \brief Reference fragment renderer.
91 *
92 * FragmentProcessor.render() draws a given set of fragments. No two
93 * fragments given in one render() call should have the same pixel
94 * coordinates coordinates, and they must all have the same facing.
95 *//*--------------------------------------------------------------------*/
96class FragmentProcessor
97{
98public:
99				FragmentProcessor	(void);
100
101	void		render				(const rr::MultisamplePixelBufferAccess&	colorMultisampleBuffer,
102									 const rr::MultisamplePixelBufferAccess&	depthMultisampleBuffer,
103									 const rr::MultisamplePixelBufferAccess&	stencilMultisampleBuffer,
104									 const Fragment*							fragments,
105									 int										numFragments,
106									 FaceType									fragmentFacing,
107									 const FragmentOperationState&				state);
108
109private:
110	enum
111	{
112		SAMPLE_REGISTER_SIZE = 64
113	};
114	struct SampleData
115	{
116		bool						isAlive;
117		bool						stencilPassed;
118		bool						depthPassed;
119		tcu::Vec4					clampedBlendSrcColor;
120		tcu::Vec4					clampedBlendSrc1Color;
121		tcu::Vec4					clampedBlendDstColor;
122		tcu::Vec3					blendSrcFactorRGB;
123		float						blendSrcFactorA;
124		tcu::Vec3					blendDstFactorRGB;
125		float						blendDstFactorA;
126		tcu::Vec3					blendedRGB;
127		float						blendedA;
128		tcu::Vector<deInt32,  4>	signedValue;		//!< integer targets
129		tcu::Vector<deUint32, 4>	unsignedValue;		//!< unsigned integer targets
130	};
131
132	// These functions operate on the values in m_sampleRegister and, in some cases, the buffers.
133
134	void		executeScissorTest				(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const WindowRectangle& scissorRect);
135	void		executeStencilCompare			(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::ConstPixelBufferAccess& stencilBuffer);
136	void		executeStencilSFail				(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::PixelBufferAccess& stencilBuffer);
137	void		executeDepthCompare				(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, TestFunc depthFunc, const tcu::ConstPixelBufferAccess& depthBuffer);
138	void		executeDepthWrite				(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::PixelBufferAccess& depthBuffer);
139	void		executeStencilDpFailAndPass		(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::PixelBufferAccess& stencilBuffer);
140	void		executeBlendFactorComputeRGB	(const tcu::Vec4& blendColor, const BlendState& blendRGBState);
141	void		executeBlendFactorComputeA		(const tcu::Vec4& blendColor, const BlendState& blendAState);
142	void		executeBlend					(const BlendState& blendRGBState, const BlendState& blendAState);
143	void		executeAdvancedBlend			(BlendEquationAdvanced equation);
144
145	void		executeColorWrite				(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, bool isSRGB, const tcu::PixelBufferAccess& colorBuffer);
146	void		executeRGBA8ColorWrite			(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::PixelBufferAccess& colorBuffer);
147	void		executeMaskedColorWrite			(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::Vec4& colorMaskFactor, const tcu::Vec4& colorMaskNegationFactor, bool isSRGB, const tcu::PixelBufferAccess& colorBuffer);
148	void		executeSignedValueWrite			(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::BVec4& colorMask, const tcu::PixelBufferAccess& colorBuffer);
149	void		executeUnsignedValueWrite		(int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::BVec4& colorMask, const tcu::PixelBufferAccess& colorBuffer);
150
151	SampleData	m_sampleRegister[SAMPLE_REGISTER_SIZE];
152};
153
154} // rr
155
156#endif // _RRFRAGMENTOPERATIONS_HPP
157