1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program Reference Renderer
3 * -----------------------------------------------
5 * Copyright 2014 The Android Open Source Project
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief Reference rasterizer
22 *//*--------------------------------------------------------------------*/
24 #include "rrRasterizer.hpp"
26 #include "tcuVectorUtil.hpp"
31 inline deInt64 toSubpixelCoord (float v)
33 return (deInt64)(v * (1<<RASTERIZER_SUBPIXEL_BITS) + (v < 0.f ? -0.5f : 0.5f));
36 inline deInt64 toSubpixelCoord (deInt32 v)
38 return v << RASTERIZER_SUBPIXEL_BITS;
41 inline deInt32 ceilSubpixelToPixelCoord (deInt64 coord, bool fillEdge)
44 return (deInt32)((coord + ((1ll<<RASTERIZER_SUBPIXEL_BITS) - (fillEdge ? 0 : 1))) >> RASTERIZER_SUBPIXEL_BITS);
46 return (deInt32)((coord + (fillEdge ? 1 : 0)) >> RASTERIZER_SUBPIXEL_BITS);
49 inline deInt32 floorSubpixelToPixelCoord (deInt64 coord, bool fillEdge)
52 return (deInt32)((coord - (fillEdge ? 1 : 0)) >> RASTERIZER_SUBPIXEL_BITS);
54 return (deInt32)((coord - ((1ll<<RASTERIZER_SUBPIXEL_BITS) - (fillEdge ? 0 : 1))) >> RASTERIZER_SUBPIXEL_BITS);
57 static inline void initEdgeCCW (EdgeFunction& edge, const HorizontalFill horizontalFill, const VerticalFill verticalFill, const deInt64 x0, const deInt64 y0, const deInt64 x1, const deInt64 y1)
59 // \note See EdgeFunction documentation for details.
61 const deInt64 xd = x1-x0;
62 const deInt64 yd = y1-y0;
63 bool inclusive = false; //!< Inclusive in CCW orientation.
66 inclusive = verticalFill == FILL_BOTTOM ? xd >= 0 : xd <= 0;
68 inclusive = horizontalFill == FILL_LEFT ? yd <= 0 : yd >= 0;
72 edge.c = x0*y1 - y0*x1;
73 edge.inclusive = inclusive; //!< \todo [pyry] Swap for CW triangles
76 static inline void reverseEdge (EdgeFunction& edge)
81 edge.inclusive = !edge.inclusive;
84 static inline deInt64 evaluateEdge (const EdgeFunction& edge, const deInt64 x, const deInt64 y)
86 return edge.a*x + edge.b*y + edge.c;
89 static inline bool isInsideCCW (const EdgeFunction& edge, const deInt64 edgeVal)
91 return edge.inclusive ? (edgeVal >= 0) : (edgeVal > 0);
94 namespace LineRasterUtil
97 struct SubpixelLineSegment
99 const tcu::Vector<deInt64,2> m_v0;
100 const tcu::Vector<deInt64,2> m_v1;
102 SubpixelLineSegment (const tcu::Vector<deInt64,2>& v0, const tcu::Vector<deInt64,2>& v1)
108 tcu::Vector<deInt64,2> direction (void) const
116 LINE_SIDE_INTERSECT = 0,
121 static tcu::Vector<deInt64,2> toSubpixelVector (const tcu::Vec2& v)
123 return tcu::Vector<deInt64,2>(toSubpixelCoord(v.x()), toSubpixelCoord(v.y()));
126 static tcu::Vector<deInt64,2> toSubpixelVector (const tcu::IVec2& v)
128 return tcu::Vector<deInt64,2>(toSubpixelCoord(v.x()), toSubpixelCoord(v.y()));
131 #if defined(DE_DEBUG)
132 static bool isTheCenterOfTheFragment (const tcu::Vector<deInt64,2>& a)
134 const deUint64 pixelSize = 1ll << (RASTERIZER_SUBPIXEL_BITS);
135 const deUint64 halfPixel = 1ll << (RASTERIZER_SUBPIXEL_BITS-1);
136 return ((a.x() & (pixelSize-1)) == halfPixel &&
137 (a.y() & (pixelSize-1)) == halfPixel);
141 static bool inViewport (const tcu::IVec2& p, const tcu::IVec4& viewport)
143 return p.x() >= viewport.x() &&
144 p.y() >= viewport.y() &&
145 p.x() < viewport.x() + viewport.z() &&
146 p.y() < viewport.y() + viewport.w();
149 // returns true if vertex is on the left side of the line
150 static bool vertexOnLeftSideOfLine (const tcu::Vector<deInt64,2>& p, const SubpixelLineSegment& l)
152 const tcu::Vector<deInt64,2> u = l.direction();
153 const tcu::Vector<deInt64,2> v = ( p - l.m_v0);
154 const deInt64 crossProduct = (u.x() * v.y() - u.y() * v.x());
155 return crossProduct < 0;
158 // returns true if vertex is on the right side of the line
159 static bool vertexOnRightSideOfLine (const tcu::Vector<deInt64,2>& p, const SubpixelLineSegment& l)
161 const tcu::Vector<deInt64,2> u = l.direction();
162 const tcu::Vector<deInt64,2> v = ( p - l.m_v0);
163 const deInt64 crossProduct = (u.x() * v.y() - u.y() * v.x());
164 return crossProduct > 0;
167 // returns true if vertex is on the line
168 static bool vertexOnLine (const tcu::Vector<deInt64,2>& p, const SubpixelLineSegment& l)
170 const tcu::Vector<deInt64,2> u = l.direction();
171 const tcu::Vector<deInt64,2> v = ( p - l.m_v0);
172 const deInt64 crossProduct = (u.x() * v.y() - u.y() * v.x());
173 return crossProduct == 0; // cross product == 0
176 // returns true if vertex is on the line segment
177 static bool vertexOnLineSegment (const tcu::Vector<deInt64,2>& p, const SubpixelLineSegment& l)
179 if (!vertexOnLine(p, l))
182 const tcu::Vector<deInt64,2> v = l.direction();
183 const tcu::Vector<deInt64,2> u1 = ( p - l.m_v0);
184 const tcu::Vector<deInt64,2> u2 = ( p - l.m_v1);
186 if (v.x() == 0 && v.y() == 0)
189 return tcu::dot( v, u1) >= 0 &&
190 tcu::dot(-v, u2) >= 0; // dot (A->B, A->V) >= 0 and dot (B->A, B->V) >= 0
193 static LINE_SIDE getVertexSide (const tcu::Vector<deInt64,2>& v, const SubpixelLineSegment& l)
195 if (vertexOnLeftSideOfLine(v, l))
196 return LINE_SIDE_LEFT;
197 else if (vertexOnRightSideOfLine(v, l))
198 return LINE_SIDE_RIGHT;
199 else if (vertexOnLine(v, l))
200 return LINE_SIDE_INTERSECT;
204 return LINE_SIDE_INTERSECT;
208 // returns true if angle between line and given cornerExitNormal is in range (-45, 45)
209 bool lineInCornerAngleRange (const SubpixelLineSegment& line, const tcu::Vector<deInt64,2>& cornerExitNormal)
211 // v0 -> v1 has angle difference to cornerExitNormal in range (-45, 45)
212 const tcu::Vector<deInt64,2> v = line.direction();
213 const deInt64 dotProduct = dot(v, cornerExitNormal);
215 // dotProduct > |v1-v0|*|cornerExitNormal|/sqrt(2)
218 return 2 * dotProduct * dotProduct > tcu::lengthSquared(v)*tcu::lengthSquared(cornerExitNormal);
221 // returns true if angle between line and given cornerExitNormal is in range (-135, 135)
222 bool lineInCornerOutsideAngleRange (const SubpixelLineSegment& line, const tcu::Vector<deInt64,2>& cornerExitNormal)
224 // v0 -> v1 has angle difference to cornerExitNormal in range (-135, 135)
225 const tcu::Vector<deInt64,2> v = line.direction();
226 const deInt64 dotProduct = dot(v, cornerExitNormal);
228 // dotProduct > -|v1-v0|*|cornerExitNormal|/sqrt(2)
231 return 2 * (-dotProduct) * (-dotProduct) < tcu::lengthSquared(v)*tcu::lengthSquared(cornerExitNormal);
234 bool doesLineSegmentExitDiamond (const SubpixelLineSegment& line, const tcu::Vector<deInt64,2>& diamondCenter)
236 DE_ASSERT(isTheCenterOfTheFragment(diamondCenter));
238 // Diamond Center is at diamondCenter in subpixel coords
240 const deInt64 halfPixel = 1ll << (RASTERIZER_SUBPIXEL_BITS-1);
242 const struct DiamondBound
244 tcu::Vector<deInt64,2> p0;
245 tcu::Vector<deInt64,2> p1;
246 bool edgeInclusive; // would a point on the bound be inside of the region
249 { diamondCenter + tcu::Vector<deInt64,2>(0, -halfPixel), diamondCenter + tcu::Vector<deInt64,2>(-halfPixel, 0), false },
250 { diamondCenter + tcu::Vector<deInt64,2>(-halfPixel, 0), diamondCenter + tcu::Vector<deInt64,2>(0, halfPixel), false },
251 { diamondCenter + tcu::Vector<deInt64,2>(0, halfPixel), diamondCenter + tcu::Vector<deInt64,2>(halfPixel, 0), true },
252 { diamondCenter + tcu::Vector<deInt64,2>(halfPixel, 0), diamondCenter + tcu::Vector<deInt64,2>(0, -halfPixel), true },
255 const struct DiamondCorners
257 enum CORNER_EDGE_CASE_BEHAVIOR
259 CORNER_EDGE_CASE_NONE, // if the line intersects just a corner, no entering or exiting
260 CORNER_EDGE_CASE_HIT, // if the line intersects just a corner, entering and exit
261 CORNER_EDGE_CASE_HIT_FIRST_QUARTER, // if the line intersects just a corner and the line has either endpoint in (+X,-Y) direction (preturbing moves the line inside)
262 CORNER_EDGE_CASE_HIT_SECOND_QUARTER // if the line intersects just a corner and the line has either endpoint in (+X,+Y) direction (preturbing moves the line inside)
264 enum CORNER_START_CASE_BEHAVIOR
266 CORNER_START_CASE_NONE, // the line starting point is outside, no exiting
267 CORNER_START_CASE_OUTSIDE, // exit, if line does not intersect the region (preturbing moves the start point inside)
268 CORNER_START_CASE_POSITIVE_Y_45, // exit, if line the angle of line vector and X-axis is in range (0, 45] in positive Y side.
269 CORNER_START_CASE_NEGATIVE_Y_45 // exit, if line the angle of line vector and X-axis is in range [0, 45] in negative Y side.
271 enum CORNER_END_CASE_BEHAVIOR
273 CORNER_END_CASE_NONE, // end is inside, no exiting (preturbing moves the line end inside)
274 CORNER_END_CASE_DIRECTION, // exit, if line intersected the region (preturbing moves the line end outside)
275 CORNER_END_CASE_DIRECTION_AND_FIRST_QUARTER, // exit, if line intersected the region, or line originates from (+X,-Y) direction (preturbing moves the line end outside)
276 CORNER_END_CASE_DIRECTION_AND_SECOND_QUARTER // exit, if line intersected the region, or line originates from (+X,+Y) direction (preturbing moves the line end outside)
279 tcu::Vector<deInt64,2> dp;
280 bool pointInclusive; // would a point in this corner intersect with the region
281 CORNER_EDGE_CASE_BEHAVIOR lineBehavior; // would a line segment going through this corner intersect with the region
282 CORNER_START_CASE_BEHAVIOR startBehavior; // how the corner behaves if the start point at the corner
283 CORNER_END_CASE_BEHAVIOR endBehavior; // how the corner behaves if the end point at the corner
287 { tcu::Vector<deInt64,2>(0, -halfPixel), false, DiamondCorners::CORNER_EDGE_CASE_HIT_SECOND_QUARTER, DiamondCorners::CORNER_START_CASE_POSITIVE_Y_45, DiamondCorners::CORNER_END_CASE_DIRECTION_AND_SECOND_QUARTER},
288 { tcu::Vector<deInt64,2>(-halfPixel, 0), false, DiamondCorners::CORNER_EDGE_CASE_NONE, DiamondCorners::CORNER_START_CASE_NONE, DiamondCorners::CORNER_END_CASE_DIRECTION },
289 { tcu::Vector<deInt64,2>(0, halfPixel), false, DiamondCorners::CORNER_EDGE_CASE_HIT_FIRST_QUARTER, DiamondCorners::CORNER_START_CASE_NEGATIVE_Y_45, DiamondCorners::CORNER_END_CASE_DIRECTION_AND_FIRST_QUARTER },
290 { tcu::Vector<deInt64,2>(halfPixel, 0), true, DiamondCorners::CORNER_EDGE_CASE_HIT, DiamondCorners::CORNER_START_CASE_OUTSIDE, DiamondCorners::CORNER_END_CASE_NONE },
293 // Corner cases at the corners
294 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(corners); ++ndx)
296 const tcu::Vector<deInt64,2> p = diamondCenter + corners[ndx].dp;
297 const bool intersectsAtCorner = LineRasterUtil::vertexOnLineSegment(p, line);
299 if (!intersectsAtCorner)
302 // line segment body intersects with the corner
303 if (p != line.m_v0 && p != line.m_v1)
305 if (corners[ndx].lineBehavior == DiamondCorners::CORNER_EDGE_CASE_HIT)
308 // endpoint in (+X, -Y) (X or Y may be 0) direction <==> x*y <= 0
309 if (corners[ndx].lineBehavior == DiamondCorners::CORNER_EDGE_CASE_HIT_FIRST_QUARTER &&
310 (line.direction().x() * line.direction().y()) <= 0)
313 // endpoint in (+X, +Y) (Y > 0) direction <==> x*y > 0
314 if (corners[ndx].lineBehavior == DiamondCorners::CORNER_EDGE_CASE_HIT_SECOND_QUARTER &&
315 (line.direction().x() * line.direction().y()) > 0)
319 // line exits the area at the corner
320 if (lineInCornerAngleRange(line, corners[ndx].dp))
322 const bool startIsInside = corners[ndx].pointInclusive || p != line.m_v0;
323 const bool endIsOutside = !corners[ndx].pointInclusive || p != line.m_v1;
325 // starting point is inside the region and end endpoint is outside
326 if (startIsInside && endIsOutside)
330 // line end is at the corner
333 if (corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION ||
334 corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_FIRST_QUARTER ||
335 corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_SECOND_QUARTER)
337 // did the line intersect the region
338 if (lineInCornerAngleRange(line, corners[ndx].dp))
342 // due to the perturbed endpoint, lines at this the angle will cause and enter-exit pair
343 if (corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_FIRST_QUARTER &&
344 line.direction().x() < 0 &&
345 line.direction().y() > 0)
347 if (corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_SECOND_QUARTER &&
348 line.direction().x() > 0 &&
349 line.direction().y() > 0)
353 // line start is at the corner
356 if (corners[ndx].startBehavior == DiamondCorners::CORNER_START_CASE_OUTSIDE)
358 // if the line is not going inside, it will exit
359 if (lineInCornerOutsideAngleRange(line, corners[ndx].dp))
363 // exit, if line the angle between line vector and X-axis is in range (0, 45] in positive Y side.
364 if (corners[ndx].startBehavior == DiamondCorners::CORNER_START_CASE_POSITIVE_Y_45 &&
365 line.direction().x() > 0 &&
366 line.direction().y() > 0 &&
367 line.direction().y() <= line.direction().x())
370 // exit, if line the angle between line vector and X-axis is in range [0, 45] in negative Y side.
371 if (corners[ndx].startBehavior == DiamondCorners::CORNER_START_CASE_NEGATIVE_Y_45 &&
372 line.direction().x() > 0 &&
373 line.direction().y() <= 0 &&
374 -line.direction().y() <= line.direction().x())
379 // Does the line intersect boundary at the left == exits the diamond
380 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(bounds); ++ndx)
382 const bool startVertexInside = LineRasterUtil::vertexOnLeftSideOfLine (line.m_v0, LineRasterUtil::SubpixelLineSegment(bounds[ndx].p0, bounds[ndx].p1)) ||
383 (bounds[ndx].edgeInclusive && LineRasterUtil::vertexOnLine (line.m_v0, LineRasterUtil::SubpixelLineSegment(bounds[ndx].p0, bounds[ndx].p1)));
384 const bool endVertexInside = LineRasterUtil::vertexOnLeftSideOfLine (line.m_v1, LineRasterUtil::SubpixelLineSegment(bounds[ndx].p0, bounds[ndx].p1)) ||
385 (bounds[ndx].edgeInclusive && LineRasterUtil::vertexOnLine (line.m_v1, LineRasterUtil::SubpixelLineSegment(bounds[ndx].p0, bounds[ndx].p1)));
387 // start must be on inside this half space (left or at the inclusive boundary)
388 if (!startVertexInside)
391 // end must be outside of this half-space (right or at non-inclusive boundary)
395 // Does the line via v0 and v1 intersect the line segment p0-p1
396 // <==> p0 and p1 are the different sides (LEFT, RIGHT) of the v0-v1 line.
397 // Corners are not allowed, they are checked already
398 LineRasterUtil::LINE_SIDE sideP0 = LineRasterUtil::getVertexSide(bounds[ndx].p0, line);
399 LineRasterUtil::LINE_SIDE sideP1 = LineRasterUtil::getVertexSide(bounds[ndx].p1, line);
401 if (sideP0 != LineRasterUtil::LINE_SIDE_INTERSECT &&
402 sideP1 != LineRasterUtil::LINE_SIDE_INTERSECT &&
412 TriangleRasterizer::TriangleRasterizer (const tcu::IVec4& viewport, const int numSamples, const RasterizationState& state)
413 : m_viewport (viewport)
414 , m_numSamples (numSamples)
415 , m_winding (state.winding)
416 , m_horizontalFill (state.horizontalFill)
417 , m_verticalFill (state.verticalFill)
418 , m_face (FACETYPE_LAST)
422 /*--------------------------------------------------------------------*//*!
423 * \brief Initialize triangle rasterization
424 * \param v0 Screen-space coordinates (x, y, z) and 1/w for vertex 0.
425 * \param v1 Screen-space coordinates (x, y, z) and 1/w for vertex 1.
426 * \param v2 Screen-space coordinates (x, y, z) and 1/w for vertex 2.
427 *//*--------------------------------------------------------------------*/
428 void TriangleRasterizer::init (const tcu::Vec4& v0, const tcu::Vec4& v1, const tcu::Vec4& v2)
434 // Positions in fixed-point coordinates.
435 const deInt64 x0 = toSubpixelCoord(v0.x());
436 const deInt64 y0 = toSubpixelCoord(v0.y());
437 const deInt64 x1 = toSubpixelCoord(v1.x());
438 const deInt64 y1 = toSubpixelCoord(v1.y());
439 const deInt64 x2 = toSubpixelCoord(v2.x());
440 const deInt64 y2 = toSubpixelCoord(v2.y());
442 // Initialize edge functions.
443 if (m_winding == WINDING_CCW)
445 initEdgeCCW(m_edge01, m_horizontalFill, m_verticalFill, x0, y0, x1, y1);
446 initEdgeCCW(m_edge12, m_horizontalFill, m_verticalFill, x1, y1, x2, y2);
447 initEdgeCCW(m_edge20, m_horizontalFill, m_verticalFill, x2, y2, x0, y0);
452 initEdgeCCW(m_edge01, m_horizontalFill, m_verticalFill, x1, y1, x0, y0);
453 initEdgeCCW(m_edge12, m_horizontalFill, m_verticalFill, x2, y2, x1, y1);
454 initEdgeCCW(m_edge20, m_horizontalFill, m_verticalFill, x0, y0, x2, y2);
458 const deInt64 s = evaluateEdge(m_edge01, x2, y2);
459 const bool positiveArea = (m_winding == WINDING_CCW) ? (s > 0) : (s < 0);
460 m_face = positiveArea ? FACETYPE_FRONT : FACETYPE_BACK;
464 // Reverse edges so that we can use CCW area tests & interpolation
465 reverseEdge(m_edge01);
466 reverseEdge(m_edge12);
467 reverseEdge(m_edge20);
471 const deInt64 xMin = de::min(de::min(x0, x1), x2);
472 const deInt64 xMax = de::max(de::max(x0, x1), x2);
473 const deInt64 yMin = de::min(de::min(y0, y1), y2);
474 const deInt64 yMax = de::max(de::max(y0, y1), y2);
476 m_bboxMin.x() = floorSubpixelToPixelCoord (xMin, m_horizontalFill == FILL_LEFT);
477 m_bboxMin.y() = floorSubpixelToPixelCoord (yMin, m_verticalFill == FILL_BOTTOM);
478 m_bboxMax.x() = ceilSubpixelToPixelCoord (xMax, m_horizontalFill == FILL_RIGHT);
479 m_bboxMax.y() = ceilSubpixelToPixelCoord (yMax, m_verticalFill == FILL_TOP);
482 const int wX0 = m_viewport.x();
483 const int wY0 = m_viewport.y();
484 const int wX1 = wX0 + m_viewport.z() - 1;
485 const int wY1 = wY0 + m_viewport.w() -1;
487 m_bboxMin.x() = de::clamp(m_bboxMin.x(), wX0, wX1);
488 m_bboxMin.y() = de::clamp(m_bboxMin.y(), wY0, wY1);
489 m_bboxMax.x() = de::clamp(m_bboxMax.x(), wX0, wX1);
490 m_bboxMax.y() = de::clamp(m_bboxMax.y(), wY0, wY1);
492 m_curPos = m_bboxMin;
495 void TriangleRasterizer::rasterizeSingleSample (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized)
497 DE_ASSERT(maxFragmentPackets > 0);
499 const deUint64 halfPixel = 1ll << (RASTERIZER_SUBPIXEL_BITS-1);
502 while (m_curPos.y() <= m_bboxMax.y() && packetNdx < maxFragmentPackets)
504 const int x0 = m_curPos.x();
505 const int y0 = m_curPos.y();
508 const deInt64 sx0 = toSubpixelCoord(x0) + halfPixel;
509 const deInt64 sx1 = toSubpixelCoord(x0+1) + halfPixel;
510 const deInt64 sy0 = toSubpixelCoord(y0) + halfPixel;
511 const deInt64 sy1 = toSubpixelCoord(y0+1) + halfPixel;
513 const deInt64 sx[4] = { sx0, sx1, sx0, sx1 };
514 const deInt64 sy[4] = { sy0, sy0, sy1, sy1 };
517 const bool outX1 = x0+1 == m_viewport.x()+m_viewport.z();
518 const bool outY1 = y0+1 == m_viewport.y()+m_viewport.w();
520 DE_ASSERT(x0 < m_viewport.x()+m_viewport.z());
521 DE_ASSERT(y0 < m_viewport.y()+m_viewport.w());
524 tcu::Vector<deInt64, 4> e01;
525 tcu::Vector<deInt64, 4> e12;
526 tcu::Vector<deInt64, 4> e20;
529 deUint64 coverage = 0;
531 // Evaluate edge values
532 for (int i = 0; i < 4; i++)
534 e01[i] = evaluateEdge(m_edge01, sx[i], sy[i]);
535 e12[i] = evaluateEdge(m_edge12, sx[i], sy[i]);
536 e20[i] = evaluateEdge(m_edge20, sx[i], sy[i]);
539 // Compute coverage mask
540 coverage = setCoverageValue(coverage, 1, 0, 0, 0, isInsideCCW(m_edge01, e01[0]) && isInsideCCW(m_edge12, e12[0]) && isInsideCCW(m_edge20, e20[0]));
541 coverage = setCoverageValue(coverage, 1, 1, 0, 0, !outX1 && isInsideCCW(m_edge01, e01[1]) && isInsideCCW(m_edge12, e12[1]) && isInsideCCW(m_edge20, e20[1]));
542 coverage = setCoverageValue(coverage, 1, 0, 1, 0, !outY1 && isInsideCCW(m_edge01, e01[2]) && isInsideCCW(m_edge12, e12[2]) && isInsideCCW(m_edge20, e20[2]));
543 coverage = setCoverageValue(coverage, 1, 1, 1, 0, !outX1 && !outY1 && isInsideCCW(m_edge01, e01[3]) && isInsideCCW(m_edge12, e12[3]) && isInsideCCW(m_edge20, e20[3]));
545 // Advance to next location
547 if (m_curPos.x() > m_bboxMax.x())
550 m_curPos.x() = m_bboxMin.x();
554 continue; // Discard.
556 // Floating-point edge values for barycentrics etc.
557 const tcu::Vec4 e01f = e01.asFloat();
558 const tcu::Vec4 e12f = e12.asFloat();
559 const tcu::Vec4 e20f = e20.asFloat();
561 // Compute depth values.
564 const tcu::Vec4 ooSum = 1.0f / (e01f + e12f + e20f);
565 const tcu::Vec4 z0 = e12f * ooSum;
566 const tcu::Vec4 z1 = e20f * ooSum;
567 const tcu::Vec4 z2 = e01f * ooSum;
569 depthValues[packetNdx*4+0] = z0[0]*m_v0.z() + z1[0]*m_v1.z() + z2[0]*m_v2.z();
570 depthValues[packetNdx*4+1] = z0[1]*m_v0.z() + z1[1]*m_v1.z() + z2[1]*m_v2.z();
571 depthValues[packetNdx*4+2] = z0[2]*m_v0.z() + z1[2]*m_v1.z() + z2[2]*m_v2.z();
572 depthValues[packetNdx*4+3] = z0[3]*m_v0.z() + z1[3]*m_v1.z() + z2[3]*m_v2.z();
575 // Compute barycentrics and write out fragment packet
577 FragmentPacket& packet = fragmentPackets[packetNdx];
579 const tcu::Vec4 b0 = e12f * m_v0.w();
580 const tcu::Vec4 b1 = e20f * m_v1.w();
581 const tcu::Vec4 b2 = e01f * m_v2.w();
582 const tcu::Vec4 ooSum = 1.0f / (b0 + b1 + b2);
584 packet.position = tcu::IVec2(x0, y0);
585 packet.coverage = coverage;
586 packet.barycentric[0] = b0 * ooSum;
587 packet.barycentric[1] = b1 * ooSum;
588 packet.barycentric[2] = 1.0f - packet.barycentric[0] - packet.barycentric[1];
594 DE_ASSERT(packetNdx <= maxFragmentPackets);
595 numPacketsRasterized = packetNdx;
598 // Sample positions - ordered as (x, y) list.
600 // \note Macros are used to eliminate function calls even in debug builds.
601 #define SAMPLE_POS_TO_SUBPIXEL_COORD(POS) \
602 (deInt64)((POS) * (1<<RASTERIZER_SUBPIXEL_BITS) + 0.5f)
604 #define SAMPLE_POS(X, Y) \
605 SAMPLE_POS_TO_SUBPIXEL_COORD(X), SAMPLE_POS_TO_SUBPIXEL_COORD(Y)
607 static const deInt64 s_samplePos2[] =
609 SAMPLE_POS(0.3f, 0.3f),
610 SAMPLE_POS(0.7f, 0.7f)
613 static const deInt64 s_samplePos4[] =
615 SAMPLE_POS(0.25f, 0.25f),
616 SAMPLE_POS(0.75f, 0.25f),
617 SAMPLE_POS(0.25f, 0.75f),
618 SAMPLE_POS(0.75f, 0.75f)
620 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_samplePos4) == 4*2);
622 static const deInt64 s_samplePos8[] =
624 SAMPLE_POS( 7.f/16.f, 9.f/16.f),
625 SAMPLE_POS( 9.f/16.f, 13.f/16.f),
626 SAMPLE_POS(11.f/16.f, 3.f/16.f),
627 SAMPLE_POS(13.f/16.f, 11.f/16.f),
628 SAMPLE_POS( 1.f/16.f, 7.f/16.f),
629 SAMPLE_POS( 5.f/16.f, 1.f/16.f),
630 SAMPLE_POS(15.f/16.f, 5.f/16.f),
631 SAMPLE_POS( 3.f/16.f, 15.f/16.f)
633 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_samplePos8) == 8*2);
635 static const deInt64 s_samplePos16[] =
637 SAMPLE_POS(1.f/8.f, 1.f/8.f),
638 SAMPLE_POS(3.f/8.f, 1.f/8.f),
639 SAMPLE_POS(5.f/8.f, 1.f/8.f),
640 SAMPLE_POS(7.f/8.f, 1.f/8.f),
641 SAMPLE_POS(1.f/8.f, 3.f/8.f),
642 SAMPLE_POS(3.f/8.f, 3.f/8.f),
643 SAMPLE_POS(5.f/8.f, 3.f/8.f),
644 SAMPLE_POS(7.f/8.f, 3.f/8.f),
645 SAMPLE_POS(1.f/8.f, 5.f/8.f),
646 SAMPLE_POS(3.f/8.f, 5.f/8.f),
647 SAMPLE_POS(5.f/8.f, 5.f/8.f),
648 SAMPLE_POS(7.f/8.f, 5.f/8.f),
649 SAMPLE_POS(1.f/8.f, 7.f/8.f),
650 SAMPLE_POS(3.f/8.f, 7.f/8.f),
651 SAMPLE_POS(5.f/8.f, 7.f/8.f),
652 SAMPLE_POS(7.f/8.f, 7.f/8.f)
654 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_samplePos16) == 16*2);
657 #undef SAMPLE_POS_TO_SUBPIXEL_COORD
659 template<int NumSamples>
660 void TriangleRasterizer::rasterizeMultiSample (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized)
662 DE_ASSERT(maxFragmentPackets > 0);
664 const deInt64* samplePos = DE_NULL;
665 const deUint64 halfPixel = 1ll << (RASTERIZER_SUBPIXEL_BITS-1);
670 case 2: samplePos = s_samplePos2; break;
671 case 4: samplePos = s_samplePos4; break;
672 case 8: samplePos = s_samplePos8; break;
673 case 16: samplePos = s_samplePos16; break;
678 while (m_curPos.y() <= m_bboxMax.y() && packetNdx < maxFragmentPackets)
680 const int x0 = m_curPos.x();
681 const int y0 = m_curPos.y();
683 // Base subpixel coords
684 const deInt64 sx0 = toSubpixelCoord(x0);
685 const deInt64 sx1 = toSubpixelCoord(x0+1);
686 const deInt64 sy0 = toSubpixelCoord(y0);
687 const deInt64 sy1 = toSubpixelCoord(y0+1);
689 const deInt64 sx[4] = { sx0, sx1, sx0, sx1 };
690 const deInt64 sy[4] = { sy0, sy0, sy1, sy1 };
693 const bool outX1 = x0+1 == m_viewport.x()+m_viewport.z();
694 const bool outY1 = y0+1 == m_viewport.y()+m_viewport.w();
696 DE_ASSERT(x0 < m_viewport.x()+m_viewport.z());
697 DE_ASSERT(y0 < m_viewport.y()+m_viewport.w());
700 tcu::Vector<deInt64, 4> e01[NumSamples];
701 tcu::Vector<deInt64, 4> e12[NumSamples];
702 tcu::Vector<deInt64, 4> e20[NumSamples];
705 deUint64 coverage = 0;
707 // Evaluate edge values at sample positions
708 for (int sampleNdx = 0; sampleNdx < NumSamples; sampleNdx++)
710 const deInt64 ox = samplePos[sampleNdx*2 + 0];
711 const deInt64 oy = samplePos[sampleNdx*2 + 1];
713 for (int fragNdx = 0; fragNdx < 4; fragNdx++)
715 e01[sampleNdx][fragNdx] = evaluateEdge(m_edge01, sx[fragNdx] + ox, sy[fragNdx] + oy);
716 e12[sampleNdx][fragNdx] = evaluateEdge(m_edge12, sx[fragNdx] + ox, sy[fragNdx] + oy);
717 e20[sampleNdx][fragNdx] = evaluateEdge(m_edge20, sx[fragNdx] + ox, sy[fragNdx] + oy);
721 // Compute coverage mask
722 for (int sampleNdx = 0; sampleNdx < NumSamples; sampleNdx++)
724 coverage = setCoverageValue(coverage, NumSamples, 0, 0, sampleNdx, isInsideCCW(m_edge01, e01[sampleNdx][0]) && isInsideCCW(m_edge12, e12[sampleNdx][0]) && isInsideCCW(m_edge20, e20[sampleNdx][0]));
725 coverage = setCoverageValue(coverage, NumSamples, 1, 0, sampleNdx, !outX1 && isInsideCCW(m_edge01, e01[sampleNdx][1]) && isInsideCCW(m_edge12, e12[sampleNdx][1]) && isInsideCCW(m_edge20, e20[sampleNdx][1]));
726 coverage = setCoverageValue(coverage, NumSamples, 0, 1, sampleNdx, !outY1 && isInsideCCW(m_edge01, e01[sampleNdx][2]) && isInsideCCW(m_edge12, e12[sampleNdx][2]) && isInsideCCW(m_edge20, e20[sampleNdx][2]));
727 coverage = setCoverageValue(coverage, NumSamples, 1, 1, sampleNdx, !outX1 && !outY1 && isInsideCCW(m_edge01, e01[sampleNdx][3]) && isInsideCCW(m_edge12, e12[sampleNdx][3]) && isInsideCCW(m_edge20, e20[sampleNdx][3]));
730 // Advance to next location
732 if (m_curPos.x() > m_bboxMax.x())
735 m_curPos.x() = m_bboxMin.x();
739 continue; // Discard.
741 // Compute depth values.
744 for (int sampleNdx = 0; sampleNdx < NumSamples; sampleNdx++)
746 // Floating-point edge values at sample coordinates.
747 const tcu::Vec4& e01f = e01[sampleNdx].asFloat();
748 const tcu::Vec4& e12f = e12[sampleNdx].asFloat();
749 const tcu::Vec4& e20f = e20[sampleNdx].asFloat();
751 const tcu::Vec4 ooSum = 1.0f / (e01f + e12f + e20f);
752 const tcu::Vec4 z0 = e12f * ooSum;
753 const tcu::Vec4 z1 = e20f * ooSum;
754 const tcu::Vec4 z2 = e01f * ooSum;
756 depthValues[(packetNdx*4+0)*NumSamples + sampleNdx] = z0[0]*m_v0.z() + z1[0]*m_v1.z() + z2[0]*m_v2.z();
757 depthValues[(packetNdx*4+1)*NumSamples + sampleNdx] = z0[1]*m_v0.z() + z1[1]*m_v1.z() + z2[1]*m_v2.z();
758 depthValues[(packetNdx*4+2)*NumSamples + sampleNdx] = z0[2]*m_v0.z() + z1[2]*m_v1.z() + z2[2]*m_v2.z();
759 depthValues[(packetNdx*4+3)*NumSamples + sampleNdx] = z0[3]*m_v0.z() + z1[3]*m_v1.z() + z2[3]*m_v2.z();
763 // Compute barycentrics and write out fragment packet
765 FragmentPacket& packet = fragmentPackets[packetNdx];
767 // Floating-point edge values at pixel center.
772 for (int i = 0; i < 4; i++)
774 e01f[i] = float(evaluateEdge(m_edge01, sx[i] + halfPixel, sy[i] + halfPixel));
775 e12f[i] = float(evaluateEdge(m_edge12, sx[i] + halfPixel, sy[i] + halfPixel));
776 e20f[i] = float(evaluateEdge(m_edge20, sx[i] + halfPixel, sy[i] + halfPixel));
779 // Barycentrics & scale.
780 const tcu::Vec4 b0 = e12f * m_v0.w();
781 const tcu::Vec4 b1 = e20f * m_v1.w();
782 const tcu::Vec4 b2 = e01f * m_v2.w();
783 const tcu::Vec4 ooSum = 1.0f / (b0 + b1 + b2);
785 packet.position = tcu::IVec2(x0, y0);
786 packet.coverage = coverage;
787 packet.barycentric[0] = b0 * ooSum;
788 packet.barycentric[1] = b1 * ooSum;
789 packet.barycentric[2] = 1.0f - packet.barycentric[0] - packet.barycentric[1];
795 DE_ASSERT(packetNdx <= maxFragmentPackets);
796 numPacketsRasterized = packetNdx;
799 void TriangleRasterizer::rasterize (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized)
801 DE_ASSERT(maxFragmentPackets > 0);
803 switch (m_numSamples)
805 case 1: rasterizeSingleSample (fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized); break;
806 case 2: rasterizeMultiSample<2> (fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized); break;
807 case 4: rasterizeMultiSample<4> (fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized); break;
808 case 8: rasterizeMultiSample<8> (fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized); break;
809 case 16: rasterizeMultiSample<16> (fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized); break;
815 SingleSampleLineRasterizer::SingleSampleLineRasterizer (const tcu::IVec4& viewport)
816 : m_viewport (viewport)
817 , m_curRowFragment (0)
822 SingleSampleLineRasterizer::~SingleSampleLineRasterizer ()
826 void SingleSampleLineRasterizer::init (const tcu::Vec4& v0, const tcu::Vec4& v1, float lineWidth)
829 const deInt64 x0 = toSubpixelCoord(v0.x());
830 const deInt64 y0 = toSubpixelCoord(v0.y());
831 const deInt64 x1 = toSubpixelCoord(v1.x());
832 const deInt64 y1 = toSubpixelCoord(v1.y());
833 const deInt64 xMin = de::min(x0, x1);
834 const deInt64 xMax = de::max(x0, x1);
835 const deInt64 yMin = de::min(y0, y1);
836 const deInt64 yMax = de::max(y0, y1);
839 const deInt64 wX0 = toSubpixelCoord(m_viewport.x());
840 const deInt64 wY0 = toSubpixelCoord(m_viewport.y());
841 const deInt64 wX1 = toSubpixelCoord(m_viewport.x() + m_viewport.z() - 1);
842 const deInt64 wY1 = toSubpixelCoord(m_viewport.y() + m_viewport.w() - 1);
844 tcu::Vector<deInt64, 2> bboxMin, bboxMax;
845 bboxMin.x() = de::clamp(xMin, wX0, wX1);
846 bboxMin.y() = de::clamp(yMin, wY0, wY1);
847 bboxMax.x() = de::clamp(xMax, wX0, wX1);
848 bboxMax.y() = de::clamp(yMax, wY0, wY1);
850 // line will be moved (linewidth-1)/2 so take that into accound
851 bboxMin.x() -= toSubpixelCoord(lineWidth);
852 bboxMax.x() += toSubpixelCoord(lineWidth);
853 bboxMin.y() -= toSubpixelCoord(lineWidth);
854 bboxMax.y() += toSubpixelCoord(lineWidth);
856 // subpixels to pixels, set m_bbox*
857 m_bboxMin.x() = floorSubpixelToPixelCoord (bboxMin.x(), true);
858 m_bboxMin.y() = floorSubpixelToPixelCoord (bboxMin.y(), true);
859 m_bboxMax.x() = ceilSubpixelToPixelCoord (bboxMax.x(), true);
860 m_bboxMax.y() = ceilSubpixelToPixelCoord (bboxMax.y(), true);
862 m_lineWidth = lineWidth;
867 m_curPos = m_bboxMin;
868 m_curRowFragment = 0;
871 void SingleSampleLineRasterizer::rasterize (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized)
873 DE_ASSERT(maxFragmentPackets > 0);
875 const deInt64 halfPixel = 1ll << (RASTERIZER_SUBPIXEL_BITS-1);
876 const deInt32 lineWidth = (m_lineWidth > 1.0f) ? (deInt32)floor(m_lineWidth + 0.5f) : 1;
877 const bool isXMajor = de::abs((m_v1 - m_v0).x()) >= de::abs((m_v1 - m_v0).y());
878 const tcu::IVec2 minorDirection = (isXMajor ? tcu::IVec2(0, 1) : tcu::IVec2(1, 0));
879 const tcu::Vector<deInt64,2> widthOffset = (isXMajor ? tcu::Vector<deInt64,2>(0, -1) : tcu::Vector<deInt64,2>(-1, 0)) * (toSubpixelCoord(lineWidth - 1) / 2);
880 const tcu::Vector<deInt64,2> pa = LineRasterUtil::toSubpixelVector(m_v0.xy()) + widthOffset;
881 const tcu::Vector<deInt64,2> pb = LineRasterUtil::toSubpixelVector(m_v1.xy()) + widthOffset;
882 const LineRasterUtil::SubpixelLineSegment line = LineRasterUtil::SubpixelLineSegment(pa, pb);
885 while (m_curPos.y() <= m_bboxMax.y() && packetNdx < maxFragmentPackets)
887 const tcu::Vector<deInt64,2> diamondPosition = LineRasterUtil::toSubpixelVector(m_curPos) + tcu::Vector<deInt64,2>(halfPixel,halfPixel);
889 // Should current fragment be drawn? == does the segment exit this diamond?
890 if (LineRasterUtil::doesLineSegmentExitDiamond(line, diamondPosition))
892 const tcu::Vector<deInt64,2> pr = diamondPosition;
893 const float t = tcu::dot((pr - pa).asFloat(), (pb - pa).asFloat()) / tcu::lengthSquared(pb.asFloat() - pa.asFloat());
895 // Wide lines require multiple fragments.
896 for (; m_curRowFragment < lineWidth; m_curRowFragment++)
898 const tcu::IVec2 fragmentPos = m_curPos + minorDirection * m_curRowFragment;
901 if (!LineRasterUtil::inViewport(fragmentPos, m_viewport))
904 // Compute depth values.
907 const float za = m_v0.z();
908 const float zb = m_v1.z();
910 depthValues[packetNdx*4+0] = (1 - t) * za + t * zb;
911 depthValues[packetNdx*4+1] = 0;
912 depthValues[packetNdx*4+2] = 0;
913 depthValues[packetNdx*4+3] = 0;
917 // output this fragment
918 // \note In order to make consistent output with multisampled line rasterization, output "barycentric" coordinates
919 FragmentPacket& packet = fragmentPackets[packetNdx];
921 const tcu::Vec4 b0 = tcu::Vec4(1 - t);
922 const tcu::Vec4 b1 = tcu::Vec4(t);
923 const tcu::Vec4 ooSum = 1.0f / (b0 + b1);
925 packet.position = fragmentPos;
926 packet.coverage = getCoverageBit(1, 0, 0, 0);
927 packet.barycentric[0] = b0 * ooSum;
928 packet.barycentric[1] = b1 * ooSum;
929 packet.barycentric[2] = tcu::Vec4(0.0f);
934 if (packetNdx == maxFragmentPackets)
936 m_curRowFragment++; // don't redraw this fragment again next time
937 numPacketsRasterized = packetNdx;
942 m_curRowFragment = 0;
946 if (m_curPos.x() > m_bboxMax.x())
949 m_curPos.x() = m_bboxMin.x();
953 DE_ASSERT(packetNdx <= maxFragmentPackets);
954 numPacketsRasterized = packetNdx;
957 MultiSampleLineRasterizer::MultiSampleLineRasterizer (const int numSamples, const tcu::IVec4& viewport)
958 : m_numSamples (numSamples)
959 , m_triangleRasterizer0 (viewport, m_numSamples, RasterizationState())
960 , m_triangleRasterizer1 (viewport, m_numSamples, RasterizationState())
964 MultiSampleLineRasterizer::~MultiSampleLineRasterizer ()
968 void MultiSampleLineRasterizer::init (const tcu::Vec4& v0, const tcu::Vec4& v1, float lineWidth)
970 // allow creation of single sampled rasterizer objects but do not allow using them
971 DE_ASSERT(m_numSamples > 1);
973 const tcu::Vec2 lineVec = tcu::Vec2(tcu::Vec4(v1).xy()) - tcu::Vec2(tcu::Vec4(v0).xy());
974 const tcu::Vec2 normal2 = tcu::normalize(tcu::Vec2(-lineVec[1], lineVec[0]));
975 const tcu::Vec4 normal4 = tcu::Vec4(normal2.x(), normal2.y(), 0, 0);
976 const float offset = lineWidth / 2.0f;
978 const tcu::Vec4 p0 = v0 + normal4 * offset;
979 const tcu::Vec4 p1 = v0 - normal4 * offset;
980 const tcu::Vec4 p2 = v1 - normal4 * offset;
981 const tcu::Vec4 p3 = v1 + normal4 * offset;
983 // Edge 0 -> 1 is always along the line and edge 1 -> 2 is in 90 degree angle to the line
984 m_triangleRasterizer0.init(p0, p3, p2);
985 m_triangleRasterizer1.init(p2, p1, p0);
988 void MultiSampleLineRasterizer::rasterize (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized)
990 DE_ASSERT(maxFragmentPackets > 0);
992 m_triangleRasterizer0.rasterize(fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized);
994 // Remove 3rd barycentric value and rebalance. Lines do not have non-zero barycentric at index 2
995 for (int packNdx = 0; packNdx < numPacketsRasterized; ++packNdx)
996 for (int fragNdx = 0; fragNdx < 4; fragNdx++)
998 float removedValue = fragmentPackets[packNdx].barycentric[2][fragNdx];
999 fragmentPackets[packNdx].barycentric[2][fragNdx] = 0.0f;
1000 fragmentPackets[packNdx].barycentric[1][fragNdx] += removedValue;
1003 // rasterizer 0 filled the whole buffer?
1004 if (numPacketsRasterized == maxFragmentPackets)
1008 FragmentPacket* const nextFragmentPackets = fragmentPackets + numPacketsRasterized;
1009 float* nextDepthValues = (depthValues) ? (depthValues+4*numPacketsRasterized*m_numSamples) : (DE_NULL);
1010 int numPacketsRasterized2 = 0;
1012 m_triangleRasterizer1.rasterize(nextFragmentPackets, nextDepthValues, maxFragmentPackets - numPacketsRasterized, numPacketsRasterized2);
1014 numPacketsRasterized += numPacketsRasterized2;
1016 // Fix swapped barycentrics in the second triangle
1017 for (int packNdx = 0; packNdx < numPacketsRasterized2; ++packNdx)
1018 for (int fragNdx = 0; fragNdx < 4; fragNdx++)
1020 float removedValue = nextFragmentPackets[packNdx].barycentric[2][fragNdx];
1021 nextFragmentPackets[packNdx].barycentric[2][fragNdx] = 0.0f;
1022 nextFragmentPackets[packNdx].barycentric[1][fragNdx] += removedValue;
1024 // edge has reversed direction
1025 std::swap(nextFragmentPackets[packNdx].barycentric[0][fragNdx], nextFragmentPackets[packNdx].barycentric[1][fragNdx]);