1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program Reference Renderer
3 * -----------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Reference implementation for per-fragment operations.
22 *//*--------------------------------------------------------------------*/
23
24 #include "rrFragmentOperations.hpp"
25 #include "tcuVectorUtil.hpp"
26 #include "tcuTextureUtil.hpp"
27
28 using tcu::IVec2;
29 using tcu::Vec3;
30 using tcu::Vec4;
31 using tcu::IVec4;
32 using tcu::UVec4;
33 using tcu::min;
34 using tcu::max;
35 using tcu::clamp;
36 using de::min;
37 using de::max;
38 using de::clamp;
39
40 namespace rr
41 {
42
43 // Return oldValue with the bits indicated by mask replaced by corresponding bits of newValue.
maskedBitReplace(int oldValue,int newValue,deUint32 mask)44 static inline int maskedBitReplace (int oldValue, int newValue, deUint32 mask)
45 {
46 return (oldValue & ~mask) | (newValue & mask);
47 }
48
isInsideRect(const IVec2 & point,const WindowRectangle & rect)49 static inline bool isInsideRect (const IVec2& point, const WindowRectangle& rect)
50 {
51 return de::inBounds(point.x(), rect.left, rect.left + rect.width) &&
52 de::inBounds(point.y(), rect.bottom, rect.bottom + rect.height);
53 }
54
unpremultiply(const Vec4 & v)55 static inline Vec4 unpremultiply (const Vec4& v)
56 {
57 if (v.w() > 0.0f)
58 return Vec4(v.x()/v.w(), v.y()/v.w(), v.z()/v.w(), v.w());
59 else
60 {
61 DE_ASSERT(v.x() == 0.0f && v.y() == 0.0f && v.z() == 0.0f);
62 return Vec4(0.0f, 0.0f, 0.0f, 0.0f);
63 }
64 }
65
clearMultisampleColorBuffer(const tcu::PixelBufferAccess & dst,const Vec4 & v,const WindowRectangle & r)66 void clearMultisampleColorBuffer (const tcu::PixelBufferAccess& dst, const Vec4& v, const WindowRectangle& r) { tcu::clear(tcu::getSubregion(dst, 0, r.left, r.bottom, dst.getWidth(), r.width, r.height), v); }
clearMultisampleColorBuffer(const tcu::PixelBufferAccess & dst,const IVec4 & v,const WindowRectangle & r)67 void clearMultisampleColorBuffer (const tcu::PixelBufferAccess& dst, const IVec4& v, const WindowRectangle& r) { tcu::clear(tcu::getSubregion(dst, 0, r.left, r.bottom, dst.getWidth(), r.width, r.height), v); }
clearMultisampleColorBuffer(const tcu::PixelBufferAccess & dst,const UVec4 & v,const WindowRectangle & r)68 void clearMultisampleColorBuffer (const tcu::PixelBufferAccess& dst, const UVec4& v, const WindowRectangle& r) { tcu::clear(tcu::getSubregion(dst, 0, r.left, r.bottom, dst.getWidth(), r.width, r.height), v.cast<int>()); }
clearMultisampleDepthBuffer(const tcu::PixelBufferAccess & dst,float v,const WindowRectangle & r)69 void clearMultisampleDepthBuffer (const tcu::PixelBufferAccess& dst, float v, const WindowRectangle& r) { tcu::clearDepth(tcu::getSubregion(dst, 0, r.left, r.bottom, dst.getWidth(), r.width, r.height), v); }
clearMultisampleStencilBuffer(const tcu::PixelBufferAccess & dst,int v,const WindowRectangle & r)70 void clearMultisampleStencilBuffer (const tcu::PixelBufferAccess& dst, int v, const WindowRectangle& r) { tcu::clearStencil(tcu::getSubregion(dst, 0, r.left, r.bottom, dst.getWidth(), r.width, r.height), v); }
71
FragmentProcessor(void)72 FragmentProcessor::FragmentProcessor (void)
73 : m_sampleRegister()
74 {
75 }
76
executeScissorTest(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const WindowRectangle & scissorRect)77 void FragmentProcessor::executeScissorTest (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const WindowRectangle& scissorRect)
78 {
79 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
80 {
81 if (m_sampleRegister[regSampleNdx].isAlive)
82 {
83 int fragNdx = fragNdxOffset + regSampleNdx/numSamplesPerFragment;
84
85 if (!isInsideRect(inputFragments[fragNdx].pixelCoord, scissorRect))
86 m_sampleRegister[regSampleNdx].isAlive = false;
87 }
88 }
89 }
90
executeStencilCompare(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const StencilState & stencilState,int numStencilBits,const tcu::ConstPixelBufferAccess & stencilBuffer)91 void FragmentProcessor::executeStencilCompare (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::ConstPixelBufferAccess& stencilBuffer)
92 {
93 #define SAMPLE_REGISTER_STENCIL_COMPARE(COMPARE_EXPRESSION) \
94 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
95 { \
96 if (m_sampleRegister[regSampleNdx].isAlive) \
97 { \
98 int fragSampleNdx = regSampleNdx % numSamplesPerFragment; \
99 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment]; \
100 int stencilBufferValue = stencilBuffer.getPixStencil(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y()); \
101 int maskedRef = stencilState.compMask & clampedStencilRef; \
102 int maskedBuf = stencilState.compMask & stencilBufferValue; \
103 DE_UNREF(maskedRef); \
104 DE_UNREF(maskedBuf); \
105 \
106 m_sampleRegister[regSampleNdx].stencilPassed = (COMPARE_EXPRESSION); \
107 } \
108 }
109
110 int clampedStencilRef = de::clamp(stencilState.ref, 0, (1<<numStencilBits)-1);
111
112 switch (stencilState.func)
113 {
114 case TESTFUNC_NEVER: SAMPLE_REGISTER_STENCIL_COMPARE(false) break;
115 case TESTFUNC_ALWAYS: SAMPLE_REGISTER_STENCIL_COMPARE(true) break;
116 case TESTFUNC_LESS: SAMPLE_REGISTER_STENCIL_COMPARE(maskedRef < maskedBuf) break;
117 case TESTFUNC_LEQUAL: SAMPLE_REGISTER_STENCIL_COMPARE(maskedRef <= maskedBuf) break;
118 case TESTFUNC_GREATER: SAMPLE_REGISTER_STENCIL_COMPARE(maskedRef > maskedBuf) break;
119 case TESTFUNC_GEQUAL: SAMPLE_REGISTER_STENCIL_COMPARE(maskedRef >= maskedBuf) break;
120 case TESTFUNC_EQUAL: SAMPLE_REGISTER_STENCIL_COMPARE(maskedRef == maskedBuf) break;
121 case TESTFUNC_NOTEQUAL: SAMPLE_REGISTER_STENCIL_COMPARE(maskedRef != maskedBuf) break;
122 default:
123 DE_ASSERT(false);
124 }
125
126 #undef SAMPLE_REGISTER_STENCIL_COMPARE
127 }
128
executeStencilSFail(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const StencilState & stencilState,int numStencilBits,const tcu::PixelBufferAccess & stencilBuffer)129 void FragmentProcessor::executeStencilSFail (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::PixelBufferAccess& stencilBuffer)
130 {
131 #define SAMPLE_REGISTER_SFAIL(SFAIL_EXPRESSION) \
132 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
133 { \
134 if (m_sampleRegister[regSampleNdx].isAlive && !m_sampleRegister[regSampleNdx].stencilPassed) \
135 { \
136 int fragSampleNdx = regSampleNdx % numSamplesPerFragment; \
137 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment]; \
138 int stencilBufferValue = stencilBuffer.getPixStencil(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y()); \
139 \
140 stencilBuffer.setPixStencil(maskedBitReplace(stencilBufferValue, (SFAIL_EXPRESSION), stencilState.writeMask), fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y()); \
141 m_sampleRegister[regSampleNdx].isAlive = false; \
142 } \
143 }
144
145 int clampedStencilRef = de::clamp(stencilState.ref, 0, (1<<numStencilBits)-1);
146
147 switch (stencilState.sFail)
148 {
149 case STENCILOP_KEEP: SAMPLE_REGISTER_SFAIL(stencilBufferValue) break;
150 case STENCILOP_ZERO: SAMPLE_REGISTER_SFAIL(0) break;
151 case STENCILOP_REPLACE: SAMPLE_REGISTER_SFAIL(clampedStencilRef) break;
152 case STENCILOP_INCR: SAMPLE_REGISTER_SFAIL(de::clamp(stencilBufferValue+1, 0, (1<<numStencilBits) - 1)) break;
153 case STENCILOP_DECR: SAMPLE_REGISTER_SFAIL(de::clamp(stencilBufferValue-1, 0, (1<<numStencilBits) - 1)) break;
154 case STENCILOP_INCR_WRAP: SAMPLE_REGISTER_SFAIL((stencilBufferValue + 1) & ((1<<numStencilBits) - 1)) break;
155 case STENCILOP_DECR_WRAP: SAMPLE_REGISTER_SFAIL((stencilBufferValue - 1) & ((1<<numStencilBits) - 1)) break;
156 case STENCILOP_INVERT: SAMPLE_REGISTER_SFAIL((~stencilBufferValue) & ((1<<numStencilBits) - 1)) break;
157 default:
158 DE_ASSERT(false);
159 }
160
161 #undef SAMPLE_REGISTER_SFAIL
162 }
163
executeDepthCompare(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,TestFunc depthFunc,const tcu::ConstPixelBufferAccess & depthBuffer)164 void FragmentProcessor::executeDepthCompare (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, TestFunc depthFunc, const tcu::ConstPixelBufferAccess& depthBuffer)
165 {
166 #define SAMPLE_REGISTER_DEPTH_COMPARE_F(COMPARE_EXPRESSION) \
167 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
168 { \
169 if (m_sampleRegister[regSampleNdx].isAlive) \
170 { \
171 int fragSampleNdx = regSampleNdx % numSamplesPerFragment; \
172 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment]; \
173 float depthBufferValue = depthBuffer.getPixDepth(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y()); \
174 float sampleDepthFloat = frag.sampleDepths[fragSampleNdx]; \
175 float sampleDepth = de::clamp(sampleDepthFloat, 0.0f, 1.0f); \
176 \
177 m_sampleRegister[regSampleNdx].depthPassed = (COMPARE_EXPRESSION); \
178 \
179 DE_UNREF(depthBufferValue); \
180 DE_UNREF(sampleDepth); \
181 } \
182 }
183
184 #define SAMPLE_REGISTER_DEPTH_COMPARE_UI(COMPARE_EXPRESSION) \
185 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
186 { \
187 if (m_sampleRegister[regSampleNdx].isAlive) \
188 { \
189 int fragSampleNdx = regSampleNdx % numSamplesPerFragment; \
190 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment]; \
191 deUint32 depthBufferValue = depthBuffer.getPixelUint(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y()).x(); \
192 float sampleDepthFloat = frag.sampleDepths[fragSampleNdx]; \
193 \
194 /* Convert input float to target buffer format for comparison */ \
195 \
196 deUint32 buffer[2]; \
197 \
198 DE_ASSERT(sizeof(buffer) >= (size_t)depthBuffer.getFormat().getPixelSize()); \
199 \
200 tcu::PixelBufferAccess access(depthBuffer.getFormat(), 1, 1, 1, &buffer); \
201 access.setPixDepth(sampleDepthFloat, 0, 0, 0); \
202 deUint32 sampleDepth = access.getPixelUint(0, 0, 0).x(); \
203 \
204 m_sampleRegister[regSampleNdx].depthPassed = (COMPARE_EXPRESSION); \
205 \
206 DE_UNREF(depthBufferValue); \
207 DE_UNREF(sampleDepth); \
208 } \
209 }
210
211 if (depthBuffer.getFormat().type == tcu::TextureFormat::FLOAT || depthBuffer.getFormat().type == tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV)
212 {
213
214 switch (depthFunc)
215 {
216 case TESTFUNC_NEVER: SAMPLE_REGISTER_DEPTH_COMPARE_F(false) break;
217 case TESTFUNC_ALWAYS: SAMPLE_REGISTER_DEPTH_COMPARE_F(true) break;
218 case TESTFUNC_LESS: SAMPLE_REGISTER_DEPTH_COMPARE_F(sampleDepth < depthBufferValue) break;
219 case TESTFUNC_LEQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_F(sampleDepth <= depthBufferValue) break;
220 case TESTFUNC_GREATER: SAMPLE_REGISTER_DEPTH_COMPARE_F(sampleDepth > depthBufferValue) break;
221 case TESTFUNC_GEQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_F(sampleDepth >= depthBufferValue) break;
222 case TESTFUNC_EQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_F(sampleDepth == depthBufferValue) break;
223 case TESTFUNC_NOTEQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_F(sampleDepth != depthBufferValue) break;
224 default:
225 DE_ASSERT(false);
226 }
227
228 }
229 else
230 {
231 switch (depthFunc)
232 {
233 case TESTFUNC_NEVER: SAMPLE_REGISTER_DEPTH_COMPARE_UI(false) break;
234 case TESTFUNC_ALWAYS: SAMPLE_REGISTER_DEPTH_COMPARE_UI(true) break;
235 case TESTFUNC_LESS: SAMPLE_REGISTER_DEPTH_COMPARE_UI(sampleDepth < depthBufferValue) break;
236 case TESTFUNC_LEQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_UI(sampleDepth <= depthBufferValue) break;
237 case TESTFUNC_GREATER: SAMPLE_REGISTER_DEPTH_COMPARE_UI(sampleDepth > depthBufferValue) break;
238 case TESTFUNC_GEQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_UI(sampleDepth >= depthBufferValue) break;
239 case TESTFUNC_EQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_UI(sampleDepth == depthBufferValue) break;
240 case TESTFUNC_NOTEQUAL: SAMPLE_REGISTER_DEPTH_COMPARE_UI(sampleDepth != depthBufferValue) break;
241 default:
242 DE_ASSERT(false);
243 }
244 }
245
246 #undef SAMPLE_REGISTER_DEPTH_COMPARE_F
247 #undef SAMPLE_REGISTER_DEPTH_COMPARE_UI
248 }
249
executeDepthWrite(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const tcu::PixelBufferAccess & depthBuffer)250 void FragmentProcessor::executeDepthWrite (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::PixelBufferAccess& depthBuffer)
251 {
252 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
253 {
254 if (m_sampleRegister[regSampleNdx].isAlive && m_sampleRegister[regSampleNdx].depthPassed)
255 {
256 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
257 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment];
258 const float clampedDepth = de::clamp(frag.sampleDepths[fragSampleNdx], 0.0f, 1.0f);
259
260 depthBuffer.setPixDepth(clampedDepth, fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
261 }
262 }
263 }
264
executeStencilDpFailAndPass(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const StencilState & stencilState,int numStencilBits,const tcu::PixelBufferAccess & stencilBuffer)265 void FragmentProcessor::executeStencilDpFailAndPass (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::PixelBufferAccess& stencilBuffer)
266 {
267 #define SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, EXPRESSION) \
268 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
269 { \
270 if (m_sampleRegister[regSampleNdx].isAlive && (CONDITION)) \
271 { \
272 int fragSampleNdx = regSampleNdx % numSamplesPerFragment; \
273 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment]; \
274 int stencilBufferValue = stencilBuffer.getPixStencil(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y()); \
275 \
276 stencilBuffer.setPixStencil(maskedBitReplace(stencilBufferValue, (EXPRESSION), stencilState.writeMask), fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y()); \
277 } \
278 }
279
280 #define SWITCH_DPFAIL_OR_DPPASS(OP_NAME, CONDITION) \
281 switch (stencilState.OP_NAME) \
282 { \
283 case STENCILOP_KEEP: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, stencilBufferValue) break; \
284 case STENCILOP_ZERO: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, 0) break; \
285 case STENCILOP_REPLACE: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, clampedStencilRef) break; \
286 case STENCILOP_INCR: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, de::clamp(stencilBufferValue+1, 0, (1<<numStencilBits) - 1)) break; \
287 case STENCILOP_DECR: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, de::clamp(stencilBufferValue-1, 0, (1<<numStencilBits) - 1)) break; \
288 case STENCILOP_INCR_WRAP: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, (stencilBufferValue + 1) & ((1<<numStencilBits) - 1)) break; \
289 case STENCILOP_DECR_WRAP: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, (stencilBufferValue - 1) & ((1<<numStencilBits) - 1)) break; \
290 case STENCILOP_INVERT: SAMPLE_REGISTER_DPFAIL_OR_DPPASS(CONDITION, (~stencilBufferValue) & ((1<<numStencilBits) - 1)) break; \
291 default: \
292 DE_ASSERT(false); \
293 }
294
295 int clampedStencilRef = de::clamp(stencilState.ref, 0, (1<<numStencilBits)-1);
296
297 SWITCH_DPFAIL_OR_DPPASS(dpFail, !m_sampleRegister[regSampleNdx].depthPassed)
298 SWITCH_DPFAIL_OR_DPPASS(dpPass, m_sampleRegister[regSampleNdx].depthPassed)
299
300 #undef SWITCH_DPFAIL_OR_DPPASS
301 #undef SAMPLE_REGISTER_DPFAIL_OR_DPPASS
302 }
303
executeBlendFactorComputeRGB(const Vec4 & blendColor,const BlendState & blendRGBState)304 void FragmentProcessor::executeBlendFactorComputeRGB (const Vec4& blendColor, const BlendState& blendRGBState)
305 {
306 #define SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, FACTOR_EXPRESSION) \
307 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
308 { \
309 if (m_sampleRegister[regSampleNdx].isAlive) \
310 { \
311 const Vec4& src = m_sampleRegister[regSampleNdx].clampedBlendSrcColor; \
312 const Vec4& src1 = m_sampleRegister[regSampleNdx].clampedBlendSrc1Color; \
313 const Vec4& dst = m_sampleRegister[regSampleNdx].clampedBlendDstColor; \
314 DE_UNREF(src); \
315 DE_UNREF(src1); \
316 DE_UNREF(dst); \
317 \
318 m_sampleRegister[regSampleNdx].FACTOR_NAME = clamp((FACTOR_EXPRESSION), Vec3(0.0f), Vec3(1.0f)); \
319 } \
320 }
321
322 #define SWITCH_SRC_OR_DST_FACTOR_RGB(FUNC_NAME, FACTOR_NAME) \
323 switch (blendRGBState.FUNC_NAME) \
324 { \
325 case BLENDFUNC_ZERO: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(0.0f)) break; \
326 case BLENDFUNC_ONE: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f)) break; \
327 case BLENDFUNC_SRC_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, src.swizzle(0,1,2)) break; \
328 case BLENDFUNC_ONE_MINUS_SRC_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f) - src.swizzle(0,1,2)) break; \
329 case BLENDFUNC_DST_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, dst.swizzle(0,1,2)) break; \
330 case BLENDFUNC_ONE_MINUS_DST_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f) - dst.swizzle(0,1,2)) break; \
331 case BLENDFUNC_SRC_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(src.w())) break; \
332 case BLENDFUNC_ONE_MINUS_SRC_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f - src.w())) break; \
333 case BLENDFUNC_DST_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(dst.w())) break; \
334 case BLENDFUNC_ONE_MINUS_DST_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f - dst.w())) break; \
335 case BLENDFUNC_CONSTANT_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, blendColor.swizzle(0,1,2)) break; \
336 case BLENDFUNC_ONE_MINUS_CONSTANT_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f) - blendColor.swizzle(0,1,2)) break; \
337 case BLENDFUNC_CONSTANT_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(blendColor.w())) break; \
338 case BLENDFUNC_ONE_MINUS_CONSTANT_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f - blendColor.w())) break; \
339 case BLENDFUNC_SRC_ALPHA_SATURATE: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(de::min(src.w(), 1.0f - dst.w()))) break; \
340 case BLENDFUNC_SRC1_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, src1.swizzle(0,1,2)) break; \
341 case BLENDFUNC_ONE_MINUS_SRC1_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f) - src1.swizzle(0,1,2)) break; \
342 case BLENDFUNC_SRC1_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(src1.w())) break; \
343 case BLENDFUNC_ONE_MINUS_SRC1_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, Vec3(1.0f - src1.w())) break; \
344 default: \
345 DE_ASSERT(false); \
346 }
347
348 SWITCH_SRC_OR_DST_FACTOR_RGB(srcFunc, blendSrcFactorRGB)
349 SWITCH_SRC_OR_DST_FACTOR_RGB(dstFunc, blendDstFactorRGB)
350
351 #undef SWITCH_SRC_OR_DST_FACTOR_RGB
352 #undef SAMPLE_REGISTER_BLEND_FACTOR
353 }
354
executeBlendFactorComputeA(const Vec4 & blendColor,const BlendState & blendAState)355 void FragmentProcessor::executeBlendFactorComputeA (const Vec4& blendColor, const BlendState& blendAState)
356 {
357 #define SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, FACTOR_EXPRESSION) \
358 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
359 { \
360 if (m_sampleRegister[regSampleNdx].isAlive) \
361 { \
362 const Vec4& src = m_sampleRegister[regSampleNdx].clampedBlendSrcColor; \
363 const Vec4& src1 = m_sampleRegister[regSampleNdx].clampedBlendSrc1Color; \
364 const Vec4& dst = m_sampleRegister[regSampleNdx].clampedBlendDstColor; \
365 DE_UNREF(src); \
366 DE_UNREF(src1); \
367 DE_UNREF(dst); \
368 \
369 m_sampleRegister[regSampleNdx].FACTOR_NAME = clamp((FACTOR_EXPRESSION), 0.0f, 1.0f); \
370 } \
371 }
372
373 #define SWITCH_SRC_OR_DST_FACTOR_A(FUNC_NAME, FACTOR_NAME) \
374 switch (blendAState.FUNC_NAME) \
375 { \
376 case BLENDFUNC_ZERO: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 0.0f) break; \
377 case BLENDFUNC_ONE: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f) break; \
378 case BLENDFUNC_SRC_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, src.w()) break; \
379 case BLENDFUNC_ONE_MINUS_SRC_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - src.w()) break; \
380 case BLENDFUNC_DST_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, dst.w()) break; \
381 case BLENDFUNC_ONE_MINUS_DST_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - dst.w()) break; \
382 case BLENDFUNC_SRC_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, src.w()) break; \
383 case BLENDFUNC_ONE_MINUS_SRC_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - src.w()) break; \
384 case BLENDFUNC_DST_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, dst.w()) break; \
385 case BLENDFUNC_ONE_MINUS_DST_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - dst.w()) break; \
386 case BLENDFUNC_CONSTANT_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, blendColor.w()) break; \
387 case BLENDFUNC_ONE_MINUS_CONSTANT_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - blendColor.w()) break; \
388 case BLENDFUNC_CONSTANT_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, blendColor.w()) break; \
389 case BLENDFUNC_ONE_MINUS_CONSTANT_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - blendColor.w()) break; \
390 case BLENDFUNC_SRC_ALPHA_SATURATE: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f) break; \
391 case BLENDFUNC_SRC1_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, src1.w()) break; \
392 case BLENDFUNC_ONE_MINUS_SRC1_COLOR: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - src1.w()) break; \
393 case BLENDFUNC_SRC1_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, src1.w()) break; \
394 case BLENDFUNC_ONE_MINUS_SRC1_ALPHA: SAMPLE_REGISTER_BLEND_FACTOR(FACTOR_NAME, 1.0f - src1.w()) break; \
395 default: \
396 DE_ASSERT(false); \
397 }
398
399 SWITCH_SRC_OR_DST_FACTOR_A(srcFunc, blendSrcFactorA)
400 SWITCH_SRC_OR_DST_FACTOR_A(dstFunc, blendDstFactorA)
401
402 #undef SWITCH_SRC_OR_DST_FACTOR_A
403 #undef SAMPLE_REGISTER_BLEND_FACTOR
404 }
405
executeBlend(const BlendState & blendRGBState,const BlendState & blendAState)406 void FragmentProcessor::executeBlend (const BlendState& blendRGBState, const BlendState& blendAState)
407 {
408 #define SAMPLE_REGISTER_BLENDED_COLOR(COLOR_NAME, COLOR_EXPRESSION) \
409 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
410 { \
411 if (m_sampleRegister[regSampleNdx].isAlive) \
412 { \
413 SampleData& sample = m_sampleRegister[regSampleNdx]; \
414 const Vec4& srcColor = sample.clampedBlendSrcColor; \
415 const Vec4& dstColor = sample.clampedBlendDstColor; \
416 \
417 sample.COLOR_NAME = (COLOR_EXPRESSION); \
418 } \
419 }
420
421 switch (blendRGBState.equation)
422 {
423 case BLENDEQUATION_ADD: SAMPLE_REGISTER_BLENDED_COLOR(blendedRGB, srcColor.swizzle(0,1,2)*sample.blendSrcFactorRGB + dstColor.swizzle(0,1,2)*sample.blendDstFactorRGB) break;
424 case BLENDEQUATION_SUBTRACT: SAMPLE_REGISTER_BLENDED_COLOR(blendedRGB, srcColor.swizzle(0,1,2)*sample.blendSrcFactorRGB - dstColor.swizzle(0,1,2)*sample.blendDstFactorRGB) break;
425 case BLENDEQUATION_REVERSE_SUBTRACT: SAMPLE_REGISTER_BLENDED_COLOR(blendedRGB, dstColor.swizzle(0,1,2)*sample.blendDstFactorRGB - srcColor.swizzle(0,1,2)*sample.blendSrcFactorRGB) break;
426 case BLENDEQUATION_MIN: SAMPLE_REGISTER_BLENDED_COLOR(blendedRGB, min(srcColor.swizzle(0,1,2), dstColor.swizzle(0,1,2))) break;
427 case BLENDEQUATION_MAX: SAMPLE_REGISTER_BLENDED_COLOR(blendedRGB, max(srcColor.swizzle(0,1,2), dstColor.swizzle(0,1,2))) break;
428 default:
429 DE_ASSERT(false);
430 }
431
432 switch (blendAState.equation)
433 {
434 case BLENDEQUATION_ADD: SAMPLE_REGISTER_BLENDED_COLOR(blendedA, srcColor.w()*sample.blendSrcFactorA + dstColor.w()*sample.blendDstFactorA) break;
435 case BLENDEQUATION_SUBTRACT: SAMPLE_REGISTER_BLENDED_COLOR(blendedA, srcColor.w()*sample.blendSrcFactorA - dstColor.w()*sample.blendDstFactorA) break;
436 case BLENDEQUATION_REVERSE_SUBTRACT: SAMPLE_REGISTER_BLENDED_COLOR(blendedA, dstColor.w()*sample.blendDstFactorA - srcColor.w()*sample.blendSrcFactorA) break;
437 case BLENDEQUATION_MIN: SAMPLE_REGISTER_BLENDED_COLOR(blendedA, min(srcColor.w(), dstColor.w())) break;
438 case BLENDEQUATION_MAX: SAMPLE_REGISTER_BLENDED_COLOR(blendedA, max(srcColor.w(), dstColor.w())) break;
439 default:
440 DE_ASSERT(false);
441 }
442 #undef SAMPLE_REGISTER_BLENDED_COLOR
443 }
444
445 namespace advblend
446 {
447
multiply(float src,float dst)448 inline float multiply (float src, float dst) { return src*dst; }
screen(float src,float dst)449 inline float screen (float src, float dst) { return src + dst - src*dst; }
darken(float src,float dst)450 inline float darken (float src, float dst) { return de::min(src, dst); }
lighten(float src,float dst)451 inline float lighten (float src, float dst) { return de::max(src, dst); }
difference(float src,float dst)452 inline float difference (float src, float dst) { return de::abs(dst-src); }
exclusion(float src,float dst)453 inline float exclusion (float src, float dst) { return src + dst - 2.0f*src*dst; }
454
overlay(float src,float dst)455 inline float overlay (float src, float dst)
456 {
457 if (dst <= 0.5f)
458 return 2.0f*src*dst;
459 else
460 return 1.0f - 2.0f*(1.0f-src)*(1.0f-dst);
461 }
462
colordodge(float src,float dst)463 inline float colordodge (float src, float dst)
464 {
465 if (dst <= 0.0f)
466 return 0.0f;
467 else if (src < 1.0f)
468 return de::min(1.0f, dst/(1.0f-src));
469 else
470 return 1.0f;
471 }
472
colorburn(float src,float dst)473 inline float colorburn (float src, float dst)
474 {
475 if (dst >= 1.0f)
476 return 1.0f;
477 else if (src > 0.0f)
478 return 1.0f - de::min(1.0f, (1.0f-dst)/src);
479 else
480 return 0.0f;
481 }
482
hardlight(float src,float dst)483 inline float hardlight (float src, float dst)
484 {
485 if (src <= 0.5f)
486 return 2.0f*src*dst;
487 else
488 return 1.0f - 2.0f*(1.0f-src)*(1.0f-dst);
489 }
490
softlight(float src,float dst)491 inline float softlight (float src, float dst)
492 {
493 if (src <= 0.5f)
494 return dst - (1.0f - 2.0f*src)*dst*(1.0f-dst);
495 else if (dst <= 0.25f)
496 return dst + (2.0f*src - 1.0f)*dst*((16.0f*dst - 12.0f)*dst + 3.0f);
497 else
498 return dst + (2.0f*src - 1.0f)*(deFloatSqrt(dst)-dst);
499 }
500
minComp(const Vec3 & v)501 inline float minComp (const Vec3& v)
502 {
503 return de::min(de::min(v.x(), v.y()), v.z());
504 }
505
maxComp(const Vec3 & v)506 inline float maxComp (const Vec3& v)
507 {
508 return de::max(de::max(v.x(), v.y()), v.z());
509 }
510
luminosity(const Vec3 & rgb)511 inline float luminosity (const Vec3& rgb)
512 {
513 return dot(rgb, Vec3(0.3f, 0.59f, 0.11f));
514 }
515
saturation(const Vec3 & rgb)516 inline float saturation (const Vec3& rgb)
517 {
518 return maxComp(rgb) - minComp(rgb);
519 }
520
setLum(const Vec3 & cbase,const Vec3 & clum)521 Vec3 setLum (const Vec3& cbase, const Vec3& clum)
522 {
523 const float lbase = luminosity(cbase);
524 const float llum = luminosity(clum);
525 const float ldiff = llum - lbase;
526 const Vec3 color = cbase + Vec3(ldiff);
527 const float minC = minComp(color);
528 const float maxC = maxComp(color);
529
530 if (minC < 0.0f)
531 return llum + ((color-llum)*llum / (llum != minC ? (llum-minC) : 1.0f));
532 else if (maxC > 1.0f)
533 return llum + ((color-llum)*(1.0f-llum) / (llum != maxC ? (maxC-llum) : 1.0f));
534 else
535 return color;
536 }
537
setLumSat(const Vec3 & cbase,const Vec3 & csat,const Vec3 & clum)538 Vec3 setLumSat (const Vec3& cbase, const Vec3& csat, const Vec3& clum)
539 {
540 const float minbase = minComp(cbase);
541 const float sbase = saturation(cbase);
542 const float ssat = saturation(csat);
543 Vec3 color = Vec3(0.0f);
544
545 if (sbase > 0.0f)
546 color = (cbase - minbase) * ssat / sbase;
547 else
548 color = color;
549
550 return setLum(color, clum);
551 }
552
553 } // advblend
554
executeAdvancedBlend(BlendEquationAdvanced equation)555 void FragmentProcessor::executeAdvancedBlend (BlendEquationAdvanced equation)
556 {
557 using namespace advblend;
558
559 #define SAMPLE_REGISTER_ADV_BLEND(FUNCTION_NAME) \
560 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
561 { \
562 if (m_sampleRegister[regSampleNdx].isAlive) \
563 { \
564 SampleData& sample = m_sampleRegister[regSampleNdx]; \
565 const Vec4& srcColor = sample.clampedBlendSrcColor; \
566 const Vec4& dstColor = sample.clampedBlendDstColor; \
567 const Vec3& bias = sample.blendSrcFactorRGB; \
568 const float p0 = sample.blendSrcFactorA; \
569 const float r = FUNCTION_NAME(srcColor[0], dstColor[0])*p0 + bias[0]; \
570 const float g = FUNCTION_NAME(srcColor[1], dstColor[1])*p0 + bias[1]; \
571 const float b = FUNCTION_NAME(srcColor[2], dstColor[2])*p0 + bias[2]; \
572 \
573 sample.blendedRGB = Vec3(r, g, b); \
574 } \
575 }
576
577 #define SAMPLE_REGISTER_ADV_BLEND_HSL(COLOR_EXPRESSION) \
578 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++) \
579 { \
580 if (m_sampleRegister[regSampleNdx].isAlive) \
581 { \
582 SampleData& sample = m_sampleRegister[regSampleNdx]; \
583 const Vec3 srcColor = sample.clampedBlendSrcColor.swizzle(0,1,2); \
584 const Vec3 dstColor = sample.clampedBlendDstColor.swizzle(0,1,2); \
585 const Vec3& bias = sample.blendSrcFactorRGB; \
586 const float p0 = sample.blendSrcFactorA; \
587 \
588 sample.blendedRGB = (COLOR_EXPRESSION)*p0 + bias; \
589 } \
590 }
591
592 // Pre-compute factors & compute alpha \todo [2014-03-18 pyry] Re-using variable names.
593 // \note clampedBlend*Color contains clamped & unpremultiplied colors
594 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
595 {
596 if (m_sampleRegister[regSampleNdx].isAlive)
597 {
598 SampleData& sample = m_sampleRegister[regSampleNdx];
599 const Vec4& srcColor = sample.clampedBlendSrcColor;
600 const Vec4& dstColor = sample.clampedBlendDstColor;
601 const float srcA = srcColor.w();
602 const float dstA = dstColor.w();
603 const float p0 = srcA*dstA;
604 const float p1 = srcA*(1.0f-dstA);
605 const float p2 = dstA*(1.0f-srcA);
606 const Vec3 bias (srcColor[0]*p1 + dstColor[0]*p2,
607 srcColor[1]*p1 + dstColor[1]*p2,
608 srcColor[2]*p1 + dstColor[2]*p2);
609
610 sample.blendSrcFactorRGB = bias;
611 sample.blendSrcFactorA = p0;
612 sample.blendedA = p0 + p1 + p2;
613 }
614 }
615
616 switch (equation)
617 {
618 case BLENDEQUATION_ADVANCED_MULTIPLY: SAMPLE_REGISTER_ADV_BLEND(multiply); break;
619 case BLENDEQUATION_ADVANCED_SCREEN: SAMPLE_REGISTER_ADV_BLEND(screen); break;
620 case BLENDEQUATION_ADVANCED_OVERLAY: SAMPLE_REGISTER_ADV_BLEND(overlay); break;
621 case BLENDEQUATION_ADVANCED_DARKEN: SAMPLE_REGISTER_ADV_BLEND(darken); break;
622 case BLENDEQUATION_ADVANCED_LIGHTEN: SAMPLE_REGISTER_ADV_BLEND(lighten); break;
623 case BLENDEQUATION_ADVANCED_COLORDODGE: SAMPLE_REGISTER_ADV_BLEND(colordodge); break;
624 case BLENDEQUATION_ADVANCED_COLORBURN: SAMPLE_REGISTER_ADV_BLEND(colorburn); break;
625 case BLENDEQUATION_ADVANCED_HARDLIGHT: SAMPLE_REGISTER_ADV_BLEND(hardlight); break;
626 case BLENDEQUATION_ADVANCED_SOFTLIGHT: SAMPLE_REGISTER_ADV_BLEND(softlight); break;
627 case BLENDEQUATION_ADVANCED_DIFFERENCE: SAMPLE_REGISTER_ADV_BLEND(difference); break;
628 case BLENDEQUATION_ADVANCED_EXCLUSION: SAMPLE_REGISTER_ADV_BLEND(exclusion); break;
629 case BLENDEQUATION_ADVANCED_HSL_HUE: SAMPLE_REGISTER_ADV_BLEND_HSL(setLumSat(srcColor, dstColor, dstColor)); break;
630 case BLENDEQUATION_ADVANCED_HSL_SATURATION: SAMPLE_REGISTER_ADV_BLEND_HSL(setLumSat(dstColor, srcColor, dstColor)); break;
631 case BLENDEQUATION_ADVANCED_HSL_COLOR: SAMPLE_REGISTER_ADV_BLEND_HSL(setLum(srcColor, dstColor)); break;
632 case BLENDEQUATION_ADVANCED_HSL_LUMINOSITY: SAMPLE_REGISTER_ADV_BLEND_HSL(setLum(dstColor, srcColor)); break;
633 default:
634 DE_ASSERT(false);
635 }
636
637 #undef SAMPLE_REGISTER_ADV_BLEND
638 #undef SAMPLE_REGISTER_ADV_BLEND_HSL
639 }
640
executeColorWrite(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,bool isSRGB,const tcu::PixelBufferAccess & colorBuffer)641 void FragmentProcessor::executeColorWrite (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, bool isSRGB, const tcu::PixelBufferAccess& colorBuffer)
642 {
643 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
644 {
645 if (m_sampleRegister[regSampleNdx].isAlive)
646 {
647 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
648 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment];
649 Vec4 combinedColor;
650
651 combinedColor.xyz() = m_sampleRegister[regSampleNdx].blendedRGB;
652 combinedColor.w() = m_sampleRegister[regSampleNdx].blendedA;
653
654 if (isSRGB)
655 combinedColor = tcu::linearToSRGB(combinedColor);
656
657 colorBuffer.setPixel(combinedColor, fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
658 }
659 }
660 }
661
executeRGBA8ColorWrite(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const tcu::PixelBufferAccess & colorBuffer)662 void FragmentProcessor::executeRGBA8ColorWrite (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::PixelBufferAccess& colorBuffer)
663 {
664 const int fragStride = 4;
665 const int xStride = colorBuffer.getRowPitch();
666 const int yStride = colorBuffer.getSlicePitch();
667 deUint8* const basePtr = (deUint8*)colorBuffer.getDataPtr();
668
669 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
670 {
671 if (m_sampleRegister[regSampleNdx].isAlive)
672 {
673 const int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
674 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment];
675 Vec4 combinedColor;
676 deUint8* dstPtr = basePtr + fragSampleNdx*fragStride + frag.pixelCoord.x()*xStride + frag.pixelCoord.y()*yStride;
677
678 dstPtr[0] = tcu::floatToU8(m_sampleRegister[regSampleNdx].blendedRGB.x());
679 dstPtr[1] = tcu::floatToU8(m_sampleRegister[regSampleNdx].blendedRGB.y());
680 dstPtr[2] = tcu::floatToU8(m_sampleRegister[regSampleNdx].blendedRGB.z());
681 dstPtr[3] = tcu::floatToU8(m_sampleRegister[regSampleNdx].blendedA);
682 }
683 }
684 }
685
executeMaskedColorWrite(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const Vec4 & colorMaskFactor,const Vec4 & colorMaskNegationFactor,bool isSRGB,const tcu::PixelBufferAccess & colorBuffer)686 void FragmentProcessor::executeMaskedColorWrite (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const Vec4& colorMaskFactor, const Vec4& colorMaskNegationFactor, bool isSRGB, const tcu::PixelBufferAccess& colorBuffer)
687 {
688 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
689 {
690 if (m_sampleRegister[regSampleNdx].isAlive)
691 {
692 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
693 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment];
694 Vec4 originalColor = colorBuffer.getPixel(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
695 Vec4 newColor;
696
697 newColor.xyz() = m_sampleRegister[regSampleNdx].blendedRGB;
698 newColor.w() = m_sampleRegister[regSampleNdx].blendedA;
699
700 if (isSRGB)
701 newColor = tcu::linearToSRGB(newColor);
702
703 newColor = colorMaskFactor*newColor + colorMaskNegationFactor*originalColor;
704
705 colorBuffer.setPixel(newColor, fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
706 }
707 }
708 }
709
executeSignedValueWrite(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const tcu::BVec4 & colorMask,const tcu::PixelBufferAccess & colorBuffer)710 void FragmentProcessor::executeSignedValueWrite (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::BVec4& colorMask, const tcu::PixelBufferAccess& colorBuffer)
711 {
712 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
713 {
714 if (m_sampleRegister[regSampleNdx].isAlive)
715 {
716 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
717 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment];
718 const IVec4 originalValue = colorBuffer.getPixelInt(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
719
720 colorBuffer.setPixel(tcu::select(m_sampleRegister[regSampleNdx].signedValue, originalValue, colorMask), fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
721 }
722 }
723 }
724
executeUnsignedValueWrite(int fragNdxOffset,int numSamplesPerFragment,const Fragment * inputFragments,const tcu::BVec4 & colorMask,const tcu::PixelBufferAccess & colorBuffer)725 void FragmentProcessor::executeUnsignedValueWrite (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::BVec4& colorMask, const tcu::PixelBufferAccess& colorBuffer)
726 {
727 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
728 {
729 if (m_sampleRegister[regSampleNdx].isAlive)
730 {
731 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
732 const Fragment& frag = inputFragments[fragNdxOffset + regSampleNdx/numSamplesPerFragment];
733 const UVec4 originalValue = colorBuffer.getPixelUint(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
734
735 colorBuffer.setPixel(tcu::select(m_sampleRegister[regSampleNdx].unsignedValue, originalValue, colorMask), fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
736 }
737 }
738 }
739
render(const rr::MultisamplePixelBufferAccess & msColorBuffer,const rr::MultisamplePixelBufferAccess & msDepthBuffer,const rr::MultisamplePixelBufferAccess & msStencilBuffer,const Fragment * inputFragments,int numFragments,FaceType fragmentFacing,const FragmentOperationState & state)740 void FragmentProcessor::render (const rr::MultisamplePixelBufferAccess& msColorBuffer,
741 const rr::MultisamplePixelBufferAccess& msDepthBuffer,
742 const rr::MultisamplePixelBufferAccess& msStencilBuffer,
743 const Fragment* inputFragments,
744 int numFragments,
745 FaceType fragmentFacing,
746 const FragmentOperationState& state)
747 {
748 DE_ASSERT(fragmentFacing < FACETYPE_LAST);
749
750 const tcu::PixelBufferAccess& colorBuffer = msColorBuffer.raw();
751 const tcu::PixelBufferAccess& depthBuffer = msDepthBuffer.raw();
752 const tcu::PixelBufferAccess& stencilBuffer = msStencilBuffer.raw();
753
754 bool hasDepth = depthBuffer.getWidth() > 0 && depthBuffer.getHeight() > 0 && depthBuffer.getDepth() > 0;
755 bool hasStencil = stencilBuffer.getWidth() > 0 && stencilBuffer.getHeight() > 0 && stencilBuffer.getDepth() > 0;
756 bool doDepthTest = hasDepth && state.depthTestEnabled;
757 bool doStencilTest = hasStencil && state.stencilTestEnabled;
758
759 tcu::TextureChannelClass colorbufferClass = tcu::getTextureChannelClass(msColorBuffer.raw().getFormat().type);
760 rr::GenericVecType fragmentDataType = (colorbufferClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) ? (rr::GENERICVECTYPE_INT32) : ((colorbufferClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) ? (rr::GENERICVECTYPE_UINT32) : (rr::GENERICVECTYPE_FLOAT));
761
762 DE_ASSERT((!hasDepth || colorBuffer.getWidth() == depthBuffer.getWidth()) && (!hasStencil || colorBuffer.getWidth() == stencilBuffer.getWidth()));
763 DE_ASSERT((!hasDepth || colorBuffer.getHeight() == depthBuffer.getHeight()) && (!hasStencil || colorBuffer.getHeight() == stencilBuffer.getHeight()));
764 DE_ASSERT((!hasDepth || colorBuffer.getDepth() == depthBuffer.getDepth()) && (!hasStencil || colorBuffer.getDepth() == stencilBuffer.getDepth()));
765
766 int numSamplesPerFragment = colorBuffer.getWidth();
767 int totalNumSamples = numFragments*numSamplesPerFragment;
768 int numSampleGroups = (totalNumSamples - 1) / SAMPLE_REGISTER_SIZE + 1; // \note totalNumSamples/SAMPLE_REGISTER_SIZE rounded up.
769 const StencilState& stencilState = state.stencilStates[fragmentFacing];
770 Vec4 colorMaskFactor (state.colorMask[0] ? 1.0f : 0.0f, state.colorMask[1] ? 1.0f : 0.0f, state.colorMask[2] ? 1.0f : 0.0f, state.colorMask[3] ? 1.0f : 0.0f);
771 Vec4 colorMaskNegationFactor (state.colorMask[0] ? 0.0f : 1.0f, state.colorMask[1] ? 0.0f : 1.0f, state.colorMask[2] ? 0.0f : 1.0f, state.colorMask[3] ? 0.0f : 1.0f);
772 bool sRGBTarget = state.sRGBEnabled && (colorBuffer.getFormat().order == tcu::TextureFormat::sRGBA ||
773 colorBuffer.getFormat().order == tcu::TextureFormat::sRGB);
774
775 DE_ASSERT(SAMPLE_REGISTER_SIZE % numSamplesPerFragment == 0);
776
777 // Divide the fragments' samples into groups of size SAMPLE_REGISTER_SIZE, and perform
778 // the per-sample operations for one group at a time.
779
780 for (int sampleGroupNdx = 0; sampleGroupNdx < numSampleGroups; sampleGroupNdx++)
781 {
782 // The index of the fragment of the sample at the beginning of m_sampleRegisters.
783 int groupFirstFragNdx = (sampleGroupNdx*SAMPLE_REGISTER_SIZE) / numSamplesPerFragment;
784
785 // Initialize sample data in the sample register.
786
787 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
788 {
789 int fragNdx = groupFirstFragNdx + regSampleNdx/numSamplesPerFragment;
790 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
791
792 if (fragNdx < numFragments)
793 {
794 m_sampleRegister[regSampleNdx].isAlive = (inputFragments[fragNdx].coverage & (1u << fragSampleNdx)) != 0;
795 m_sampleRegister[regSampleNdx].depthPassed = true; // \note This will stay true if depth test is disabled.
796 }
797 else
798 m_sampleRegister[regSampleNdx].isAlive = false;
799 }
800
801 // Scissor test.
802
803 if (state.scissorTestEnabled)
804 executeScissorTest(groupFirstFragNdx, numSamplesPerFragment, inputFragments, state.scissorRectangle);
805
806 // Stencil test.
807
808 if (doStencilTest)
809 {
810 executeStencilCompare(groupFirstFragNdx, numSamplesPerFragment, inputFragments, stencilState, state.numStencilBits, stencilBuffer);
811 executeStencilSFail(groupFirstFragNdx, numSamplesPerFragment, inputFragments, stencilState, state.numStencilBits, stencilBuffer);
812 }
813
814 // Depth test.
815 // \note Current value of isAlive is needed for dpPass and dpFail, so it's only updated after them and not right after depth test.
816
817 if (doDepthTest)
818 {
819 executeDepthCompare(groupFirstFragNdx, numSamplesPerFragment, inputFragments, state.depthFunc, depthBuffer);
820
821 if (state.depthMask)
822 executeDepthWrite(groupFirstFragNdx, numSamplesPerFragment, inputFragments, depthBuffer);
823 }
824
825 // Do dpFail and dpPass stencil writes.
826
827 if (doStencilTest)
828 executeStencilDpFailAndPass(groupFirstFragNdx, numSamplesPerFragment, inputFragments, stencilState, state.numStencilBits, stencilBuffer);
829
830 // Kill the samples that failed depth test.
831
832 if (doDepthTest)
833 {
834 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
835 m_sampleRegister[regSampleNdx].isAlive = m_sampleRegister[regSampleNdx].isAlive && m_sampleRegister[regSampleNdx].depthPassed;
836 }
837
838 // Paint fragments to target
839
840 switch (fragmentDataType)
841 {
842 case rr::GENERICVECTYPE_FLOAT:
843 // Blend calculation - only if using blend.
844 if (state.blendMode == BLENDMODE_STANDARD)
845 {
846 // Put dst color to register, doing srgb-to-linear conversion if needed.
847 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
848 {
849 if (m_sampleRegister[regSampleNdx].isAlive)
850 {
851 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
852 const Fragment& frag = inputFragments[groupFirstFragNdx + regSampleNdx/numSamplesPerFragment];
853 Vec4 dstColor = colorBuffer.getPixel(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
854
855 m_sampleRegister[regSampleNdx].clampedBlendSrcColor = clamp(frag.value.get<float>(), Vec4(0.0f), Vec4(1.0f));
856 m_sampleRegister[regSampleNdx].clampedBlendSrc1Color = clamp(frag.value1.get<float>(), Vec4(0.0f), Vec4(1.0f));
857 m_sampleRegister[regSampleNdx].clampedBlendDstColor = clamp(sRGBTarget ? tcu::sRGBToLinear(dstColor) : dstColor, Vec4(0.0f), Vec4(1.0f));
858 }
859 }
860
861 // Calculate blend factors to register.
862 executeBlendFactorComputeRGB(state.blendColor, state.blendRGBState);
863 executeBlendFactorComputeA(state.blendColor, state.blendAState);
864
865 // Compute blended color.
866 executeBlend(state.blendRGBState, state.blendAState);
867 }
868 else if (state.blendMode == BLENDMODE_ADVANCED)
869 {
870 // Unpremultiply colors for blending, and do sRGB->linear if necessary
871 // \todo [2014-03-17 pyry] Re-consider clampedBlend*Color var names
872 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
873 {
874 if (m_sampleRegister[regSampleNdx].isAlive)
875 {
876 int fragSampleNdx = regSampleNdx % numSamplesPerFragment;
877 const Fragment& frag = inputFragments[groupFirstFragNdx + regSampleNdx/numSamplesPerFragment];
878 const Vec4 srcColor = frag.value.get<float>();
879 const Vec4 dstColor = colorBuffer.getPixel(fragSampleNdx, frag.pixelCoord.x(), frag.pixelCoord.y());
880
881 m_sampleRegister[regSampleNdx].clampedBlendSrcColor = unpremultiply(clamp(srcColor, Vec4(0.0f), Vec4(1.0f)));
882 m_sampleRegister[regSampleNdx].clampedBlendDstColor = unpremultiply(clamp(sRGBTarget ? tcu::sRGBToLinear(dstColor) : dstColor, Vec4(0.0f), Vec4(1.0f)));
883 }
884 }
885
886 executeAdvancedBlend(state.blendEquationAdvaced);
887 }
888 else
889 {
890 // Not using blend - just put values to register as-is.
891 DE_ASSERT(state.blendMode == BLENDMODE_NONE);
892
893 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
894 {
895 if (m_sampleRegister[regSampleNdx].isAlive)
896 {
897 const Fragment& frag = inputFragments[groupFirstFragNdx + regSampleNdx/numSamplesPerFragment];
898
899 m_sampleRegister[regSampleNdx].blendedRGB = frag.value.get<float>().xyz();
900 m_sampleRegister[regSampleNdx].blendedA = frag.value.get<float>().w();
901 }
902 }
903 }
904
905 // Finally, write the colors to the color buffer.
906
907 if (state.colorMask[0] && state.colorMask[1] && state.colorMask[2] && state.colorMask[3])
908 {
909 if (colorBuffer.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8))
910 executeRGBA8ColorWrite(groupFirstFragNdx, numSamplesPerFragment, inputFragments, colorBuffer);
911 else
912 executeColorWrite(groupFirstFragNdx, numSamplesPerFragment, inputFragments, sRGBTarget, colorBuffer);
913 }
914 else if (state.colorMask[0] || state.colorMask[1] || state.colorMask[2] || state.colorMask[3])
915 executeMaskedColorWrite(groupFirstFragNdx, numSamplesPerFragment, inputFragments, colorMaskFactor, colorMaskNegationFactor, sRGBTarget, colorBuffer);
916 break;
917
918 case rr::GENERICVECTYPE_INT32:
919 // Write fragments
920 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
921 {
922 if (m_sampleRegister[regSampleNdx].isAlive)
923 {
924 const Fragment& frag = inputFragments[groupFirstFragNdx + regSampleNdx/numSamplesPerFragment];
925
926 m_sampleRegister[regSampleNdx].signedValue = frag.value.get<deInt32>();
927 }
928 }
929
930 if (state.colorMask[0] || state.colorMask[1] || state.colorMask[2] || state.colorMask[3])
931 executeSignedValueWrite(groupFirstFragNdx, numSamplesPerFragment, inputFragments, state.colorMask, colorBuffer);
932 break;
933
934 case rr::GENERICVECTYPE_UINT32:
935 // Write fragments
936 for (int regSampleNdx = 0; regSampleNdx < SAMPLE_REGISTER_SIZE; regSampleNdx++)
937 {
938 if (m_sampleRegister[regSampleNdx].isAlive)
939 {
940 const Fragment& frag = inputFragments[groupFirstFragNdx + regSampleNdx/numSamplesPerFragment];
941
942 m_sampleRegister[regSampleNdx].unsignedValue = frag.value.get<deUint32>();
943 }
944 }
945
946 if (state.colorMask[0] || state.colorMask[1] || state.colorMask[2] || state.colorMask[3])
947 executeUnsignedValueWrite(groupFirstFragNdx, numSamplesPerFragment, inputFragments, state.colorMask, colorBuffer);
948 break;
949
950 default:
951 DE_ASSERT(DE_FALSE);
952 }
953 }
954 }
955
956 } // rr
957