framework/referencerenderer/rrRasterizer.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program Reference Renderer
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Reference rasterizer
 *//*--------------------------------------------------------------------*/

#include "rrRasterizer.hpp"
#include "deMath.h"
#include "tcuVectorUtil.hpp"

namespace rr
{

inline int64_t toSubpixelCoord(float v, int bits)
{
    return (int64_t)(v * (float)(1 << bits) + (v < 0.f ? -0.5f : 0.5f));
}

inline int64_t toSubpixelCoord(int32_t v, int bits)
{
    return v << bits;
}

inline int32_t ceilSubpixelToPixelCoord(int64_t coord, int bits, bool fillEdge)
{
    if (coord >= 0)
        return (int32_t)((coord + ((1ll << bits) - (fillEdge ? 0 : 1))) >> bits);
    else
        return (int32_t)((coord + (fillEdge ? 1 : 0)) >> bits);
}

inline int32_t floorSubpixelToPixelCoord(int64_t coord, int bits, bool fillEdge)
{
    if (coord >= 0)
        return (int32_t)((coord - (fillEdge ? 1 : 0)) >> bits);
    else
        return (int32_t)((coord - ((1ll << bits) - (fillEdge ? 0 : 1))) >> bits);
}

static inline void initEdgeCCW(EdgeFunction &edge, const HorizontalFill horizontalFill, const VerticalFill verticalFill,
                               const int64_t x0, const int64_t y0, const int64_t x1, const int64_t y1)
{
    // \note See EdgeFunction documentation for details.

    const int64_t xd = x1 - x0;
    const int64_t yd = y1 - y0;
    bool inclusive   = false; //!< Inclusive in CCW orientation.

    if (yd == 0)
        inclusive = verticalFill == FILL_BOTTOM ? xd >= 0 : xd <= 0;
    else
        inclusive = horizontalFill == FILL_LEFT ? yd <= 0 : yd >= 0;

    edge.a         = (y0 - y1);
    edge.b         = (x1 - x0);
    edge.c         = x0 * y1 - y0 * x1;
    edge.inclusive = inclusive; //!< \todo [pyry] Swap for CW triangles
}

static inline void reverseEdge(EdgeFunction &edge)
{
    edge.a         = -edge.a;
    edge.b         = -edge.b;
    edge.c         = -edge.c;
    edge.inclusive = !edge.inclusive;
}

static inline int64_t evaluateEdge(const EdgeFunction &edge, const int64_t x, const int64_t y)
{
    return edge.a * x + edge.b * y + edge.c;
}

static inline bool isInsideCCW(const EdgeFunction &edge, const int64_t edgeVal)
{
    return edge.inclusive ? (edgeVal >= 0) : (edgeVal > 0);
}

namespace LineRasterUtil
{

struct SubpixelLineSegment
{
    const tcu::Vector<int64_t, 2> m_v0;
    const tcu::Vector<int64_t, 2> m_v1;

    SubpixelLineSegment(const tcu::Vector<int64_t, 2> &v0, const tcu::Vector<int64_t, 2> &v1) : m_v0(v0), m_v1(v1)
    {
    }

    tcu::Vector<int64_t, 2> direction(void) const
    {
        return m_v1 - m_v0;
    }
};

enum LINE_SIDE
{
    LINE_SIDE_INTERSECT = 0,
    LINE_SIDE_LEFT,
    LINE_SIDE_RIGHT
};

static tcu::Vector<int64_t, 2> toSubpixelVector(const tcu::Vec2 &v, int bits)
{
    return tcu::Vector<int64_t, 2>(toSubpixelCoord(v.x(), bits), toSubpixelCoord(v.y(), bits));
}

static tcu::Vector<int64_t, 2> toSubpixelVector(const tcu::IVec2 &v, int bits)
{
    return tcu::Vector<int64_t, 2>(toSubpixelCoord(v.x(), bits), toSubpixelCoord(v.y(), bits));
}

#if defined(DE_DEBUG)
static bool isTheCenterOfTheFragment(const tcu::Vector<int64_t, 2> &a, int bits)
{
    const uint64_t pixelSize = 1ll << bits;
    const uint64_t halfPixel = 1ll << (bits - 1);
    return ((a.x() & (pixelSize - 1)) == halfPixel && (a.y() & (pixelSize - 1)) == halfPixel);
}

static bool inViewport(const tcu::IVec2 &p, const tcu::IVec4 &viewport)
{
    return p.x() >= viewport.x() && p.y() >= viewport.y() && p.x() < viewport.x() + viewport.z() &&
           p.y() < viewport.y() + viewport.w();
}
#endif // DE_DEBUG

// returns true if vertex is on the left side of the line
static bool vertexOnLeftSideOfLine(const tcu::Vector<int64_t, 2> &p, const SubpixelLineSegment &l)
{
    const tcu::Vector<int64_t, 2> u = l.direction();
    const tcu::Vector<int64_t, 2> v = (p - l.m_v0);
    const int64_t crossProduct      = (u.x() * v.y() - u.y() * v.x());
    return crossProduct < 0;
}

// returns true if vertex is on the right side of the line
static bool vertexOnRightSideOfLine(const tcu::Vector<int64_t, 2> &p, const SubpixelLineSegment &l)
{
    const tcu::Vector<int64_t, 2> u = l.direction();
    const tcu::Vector<int64_t, 2> v = (p - l.m_v0);
    const int64_t crossProduct      = (u.x() * v.y() - u.y() * v.x());
    return crossProduct > 0;
}

// returns true if vertex is on the line
static bool vertexOnLine(const tcu::Vector<int64_t, 2> &p, const SubpixelLineSegment &l)
{
    const tcu::Vector<int64_t, 2> u = l.direction();
    const tcu::Vector<int64_t, 2> v = (p - l.m_v0);
    const int64_t crossProduct      = (u.x() * v.y() - u.y() * v.x());
    return crossProduct == 0; // cross product == 0
}

// returns true if vertex is on the line segment
static bool vertexOnLineSegment(const tcu::Vector<int64_t, 2> &p, const SubpixelLineSegment &l)
{
    if (!vertexOnLine(p, l))
        return false;

    const tcu::Vector<int64_t, 2> v  = l.direction();
    const tcu::Vector<int64_t, 2> u1 = (p - l.m_v0);
    const tcu::Vector<int64_t, 2> u2 = (p - l.m_v1);

    if (v.x() == 0 && v.y() == 0)
        return false;

    return tcu::dot(v, u1) >= 0 && tcu::dot(-v, u2) >= 0; // dot (A->B, A->V) >= 0 and dot (B->A, B->V) >= 0
}

static LINE_SIDE getVertexSide(const tcu::Vector<int64_t, 2> &v, const SubpixelLineSegment &l)
{
    if (vertexOnLeftSideOfLine(v, l))
        return LINE_SIDE_LEFT;
    else if (vertexOnRightSideOfLine(v, l))
        return LINE_SIDE_RIGHT;
    else if (vertexOnLine(v, l))
        return LINE_SIDE_INTERSECT;
    else
    {
        DE_ASSERT(false);
        return LINE_SIDE_INTERSECT;
    }
}

// returns true if angle between line and given cornerExitNormal is in range (-45, 45)
bool lineInCornerAngleRange(const SubpixelLineSegment &line, const tcu::Vector<int64_t, 2> &cornerExitNormal)
{
    // v0 -> v1 has angle difference to cornerExitNormal in range (-45, 45)
    const tcu::Vector<int64_t, 2> v = line.direction();
    const int64_t dotProduct        = dot(v, cornerExitNormal);

    // dotProduct > |v1-v0|*|cornerExitNormal|/sqrt(2)
    if (dotProduct < 0)
        return false;
    return 2 * dotProduct * dotProduct > tcu::lengthSquared(v) * tcu::lengthSquared(cornerExitNormal);
}

// returns true if angle between line and given cornerExitNormal is in range (-135, 135)
bool lineInCornerOutsideAngleRange(const SubpixelLineSegment &line, const tcu::Vector<int64_t, 2> &cornerExitNormal)
{
    // v0 -> v1 has angle difference to cornerExitNormal in range (-135, 135)
    const tcu::Vector<int64_t, 2> v = line.direction();
    const int64_t dotProduct        = dot(v, cornerExitNormal);

    // dotProduct > -|v1-v0|*|cornerExitNormal|/sqrt(2)
    if (dotProduct >= 0)
        return true;
    return 2 * (-dotProduct) * (-dotProduct) < tcu::lengthSquared(v) * tcu::lengthSquared(cornerExitNormal);
}

bool doesLineSegmentExitDiamond(const SubpixelLineSegment &line, const tcu::Vector<int64_t, 2> &diamondCenter, int bits)
{
    DE_ASSERT(isTheCenterOfTheFragment(diamondCenter, bits));

    // Diamond Center is at diamondCenter in subpixel coords

    const int64_t halfPixel = 1ll << (bits - 1);

    // Reject distant diamonds early
    {
        const tcu::Vector<int64_t, 2> u = line.direction();
        const tcu::Vector<int64_t, 2> v = (diamondCenter - line.m_v0);
        const int64_t crossProduct      = (u.x() * v.y() - u.y() * v.x());

        // crossProduct = |p| |l| sin(theta)
        // distanceFromLine = |p| sin(theta)
        // => distanceFromLine = crossProduct / |l|
        //
        // |distanceFromLine| > C
        // => distanceFromLine^2 > C^2
        // => crossProduct^2 / |l|^2 > C^2
        // => crossProduct^2 > |l|^2 * C^2

        const int64_t floorSqrtMaxInt64 = 3037000499LL; //!< floor(sqrt(MAX_INT64))

        const int64_t broadRejectDistance        = 2 * halfPixel;
        const int64_t broadRejectDistanceSquared = broadRejectDistance * broadRejectDistance;
        const bool crossProductOverflows = (crossProduct > floorSqrtMaxInt64 || crossProduct < -floorSqrtMaxInt64);
        const int64_t crossProductSquared =
            (crossProductOverflows) ? (0) : (crossProduct * crossProduct); // avoid overflow
        const int64_t lineLengthSquared = tcu::lengthSquared(u);
        const bool limitValueCouldOverflow =
            ((64 - deClz64(lineLengthSquared)) + (64 - deClz64(broadRejectDistanceSquared))) > 63;
        const int64_t limitValue =
            (limitValueCouldOverflow) ? (0) : (lineLengthSquared * broadRejectDistanceSquared); // avoid overflow

        // only cross overflows
        if (crossProductOverflows && !limitValueCouldOverflow)
            return false;

        // both representable
        if (!crossProductOverflows && !limitValueCouldOverflow)
        {
            if (crossProductSquared > limitValue)
                return false;
        }
    }

    const struct DiamondBound
    {
        tcu::Vector<int64_t, 2> p0;
        tcu::Vector<int64_t, 2> p1;
        bool edgeInclusive; // would a point on the bound be inside of the region
    } bounds[] = {
        {diamondCenter + tcu::Vector<int64_t, 2>(0, -halfPixel), diamondCenter + tcu::Vector<int64_t, 2>(-halfPixel, 0),
         false},
        {diamondCenter + tcu::Vector<int64_t, 2>(-halfPixel, 0), diamondCenter + tcu::Vector<int64_t, 2>(0, halfPixel),
         false},
        {diamondCenter + tcu::Vector<int64_t, 2>(0, halfPixel), diamondCenter + tcu::Vector<int64_t, 2>(halfPixel, 0),
         true},
        {diamondCenter + tcu::Vector<int64_t, 2>(halfPixel, 0), diamondCenter + tcu::Vector<int64_t, 2>(0, -halfPixel),
         true},
    };

    const struct DiamondCorners
    {
        enum CORNER_EDGE_CASE_BEHAVIOR
        {
            CORNER_EDGE_CASE_NONE,              // if the line intersects just a corner, no entering or exiting
            CORNER_EDGE_CASE_HIT,               // if the line intersects just a corner, entering and exit
            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)
            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)
        };
        enum CORNER_START_CASE_BEHAVIOR
        {
            CORNER_START_CASE_NONE, // the line starting point is outside, no exiting
            CORNER_START_CASE_OUTSIDE, // exit, if line does not intersect the region (preturbing moves the start point inside)
            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.
            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.
        };
        enum CORNER_END_CASE_BEHAVIOR
        {
            CORNER_END_CASE_NONE,      // end is inside, no exiting (preturbing moves the line end inside)
            CORNER_END_CASE_DIRECTION, // exit, if line intersected the region (preturbing moves the line end outside)
            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)
            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)
        };

        tcu::Vector<int64_t, 2> dp;
        bool pointInclusive; // would a point in this corner intersect with the region
        CORNER_EDGE_CASE_BEHAVIOR
        lineBehavior; // would a line segment going through this corner intersect with the region
        CORNER_START_CASE_BEHAVIOR startBehavior; // how the corner behaves if the start point at the corner
        CORNER_END_CASE_BEHAVIOR endBehavior;     // how the corner behaves if the end point at the corner
    } corners[] = {
        {tcu::Vector<int64_t, 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},
        {tcu::Vector<int64_t, 2>(-halfPixel, 0), false, DiamondCorners::CORNER_EDGE_CASE_NONE,
         DiamondCorners::CORNER_START_CASE_NONE, DiamondCorners::CORNER_END_CASE_DIRECTION},
        {tcu::Vector<int64_t, 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},
        {tcu::Vector<int64_t, 2>(halfPixel, 0), true, DiamondCorners::CORNER_EDGE_CASE_HIT,
         DiamondCorners::CORNER_START_CASE_OUTSIDE, DiamondCorners::CORNER_END_CASE_NONE},
    };

    // Corner cases at the corners
    for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(corners); ++ndx)
    {
        const tcu::Vector<int64_t, 2> p = diamondCenter + corners[ndx].dp;
        const bool intersectsAtCorner   = LineRasterUtil::vertexOnLineSegment(p, line);

        if (!intersectsAtCorner)
            continue;

        // line segment body intersects with the corner
        if (p != line.m_v0 && p != line.m_v1)
        {
            if (corners[ndx].lineBehavior == DiamondCorners::CORNER_EDGE_CASE_HIT)
                return true;

            // endpoint in (+X, -Y) (X or Y may be 0) direction <==> x*y <= 0
            if (corners[ndx].lineBehavior == DiamondCorners::CORNER_EDGE_CASE_HIT_FIRST_QUARTER &&
                (line.direction().x() * line.direction().y()) <= 0)
                return true;

            // endpoint in (+X, +Y) (Y > 0) direction <==> x*y > 0
            if (corners[ndx].lineBehavior == DiamondCorners::CORNER_EDGE_CASE_HIT_SECOND_QUARTER &&
                (line.direction().x() * line.direction().y()) > 0)
                return true;
        }

        // line exits the area at the corner
        if (lineInCornerAngleRange(line, corners[ndx].dp))
        {
            const bool startIsInside = corners[ndx].pointInclusive || p != line.m_v0;
            const bool endIsOutside  = !corners[ndx].pointInclusive || p != line.m_v1;

            // starting point is inside the region and end endpoint is outside
            if (startIsInside && endIsOutside)
                return true;
        }

        // line end is at the corner
        if (p == line.m_v1)
        {
            if (corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION ||
                corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_FIRST_QUARTER ||
                corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_SECOND_QUARTER)
            {
                // did the line intersect the region
                if (lineInCornerAngleRange(line, corners[ndx].dp))
                    return true;
            }

            // due to the perturbed endpoint, lines at this the angle will cause and enter-exit pair
            if (corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_FIRST_QUARTER &&
                line.direction().x() < 0 && line.direction().y() > 0)
                return true;
            if (corners[ndx].endBehavior == DiamondCorners::CORNER_END_CASE_DIRECTION_AND_SECOND_QUARTER &&
                line.direction().x() > 0 && line.direction().y() > 0)
                return true;
        }

        // line start is at the corner
        if (p == line.m_v0)
        {
            if (corners[ndx].startBehavior == DiamondCorners::CORNER_START_CASE_OUTSIDE)
            {
                // if the line is not going inside, it will exit
                if (lineInCornerOutsideAngleRange(line, corners[ndx].dp))
                    return true;
            }

            // exit, if line the angle between line vector and X-axis is in range (0, 45] in positive Y side.
            if (corners[ndx].startBehavior == DiamondCorners::CORNER_START_CASE_POSITIVE_Y_45 &&
                line.direction().x() > 0 && line.direction().y() > 0 && line.direction().y() <= line.direction().x())
                return true;

            // exit, if line the angle between line vector and X-axis is in range [0, 45] in negative Y side.
            if (corners[ndx].startBehavior == DiamondCorners::CORNER_START_CASE_NEGATIVE_Y_45 &&
                line.direction().x() > 0 && line.direction().y() <= 0 && -line.direction().y() <= line.direction().x())
                return true;
        }
    }

    // Does the line intersect boundary at the left == exits the diamond
    for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(bounds); ++ndx)
    {
        const bool startVertexInside =
            LineRasterUtil::vertexOnLeftSideOfLine(
                line.m_v0, LineRasterUtil::SubpixelLineSegment(bounds[ndx].p0, bounds[ndx].p1)) ||
            (bounds[ndx].edgeInclusive && LineRasterUtil::vertexOnLine(line.m_v0, LineRasterUtil::SubpixelLineSegment(
                                                                                      bounds[ndx].p0, bounds[ndx].p1)));
        const bool endVertexInside =
            LineRasterUtil::vertexOnLeftSideOfLine(
                line.m_v1, LineRasterUtil::SubpixelLineSegment(bounds[ndx].p0, bounds[ndx].p1)) ||
            (bounds[ndx].edgeInclusive && LineRasterUtil::vertexOnLine(line.m_v1, LineRasterUtil::SubpixelLineSegment(
                                                                                      bounds[ndx].p0, bounds[ndx].p1)));

        // start must be on inside this half space (left or at the inclusive boundary)
        if (!startVertexInside)
            continue;

        // end must be outside of this half-space (right or at non-inclusive boundary)
        if (endVertexInside)
            continue;

        // Does the line via v0 and v1 intersect the line segment p0-p1
        // <==> p0 and p1 are the different sides (LEFT, RIGHT) of the v0-v1 line.
        // Corners are not allowed, they are checked already
        LineRasterUtil::LINE_SIDE sideP0 = LineRasterUtil::getVertexSide(bounds[ndx].p0, line);
        LineRasterUtil::LINE_SIDE sideP1 = LineRasterUtil::getVertexSide(bounds[ndx].p1, line);

        if (sideP0 != LineRasterUtil::LINE_SIDE_INTERSECT && sideP1 != LineRasterUtil::LINE_SIDE_INTERSECT &&
            sideP0 != sideP1)
            return true;
    }

    return false;
}

} // namespace LineRasterUtil

TriangleRasterizer::TriangleRasterizer(const tcu::IVec4 &viewport, const int numSamples,
                                       const RasterizationState &state, const int subpixelBits)
    : m_viewport(viewport)
    , m_numSamples(numSamples)
    , m_winding(state.winding)
    , m_horizontalFill(state.horizontalFill)
    , m_verticalFill(state.verticalFill)
    , m_subpixelBits(subpixelBits)
    , m_face(FACETYPE_LAST)
    , m_viewportOrientation(state.viewportOrientation)
{
}

/*--------------------------------------------------------------------*//*!
 * \brief Initialize triangle rasterization
 * \param v0 Screen-space coordinates (x, y, z) and 1/w for vertex 0.
 * \param v1 Screen-space coordinates (x, y, z) and 1/w for vertex 1.
 * \param v2 Screen-space coordinates (x, y, z) and 1/w for vertex 2.
 *//*--------------------------------------------------------------------*/
void TriangleRasterizer::init(const tcu::Vec4 &v0, const tcu::Vec4 &v1, const tcu::Vec4 &v2)
{
    m_v0 = v0;
    m_v1 = v1;
    m_v2 = v2;

    // Positions in fixed-point coordinates.
    const int64_t x0 = toSubpixelCoord(v0.x(), m_subpixelBits);
    const int64_t y0 = toSubpixelCoord(v0.y(), m_subpixelBits);
    const int64_t x1 = toSubpixelCoord(v1.x(), m_subpixelBits);
    const int64_t y1 = toSubpixelCoord(v1.y(), m_subpixelBits);
    const int64_t x2 = toSubpixelCoord(v2.x(), m_subpixelBits);
    const int64_t y2 = toSubpixelCoord(v2.y(), m_subpixelBits);

    // Initialize edge functions.
    if (m_winding == WINDING_CCW)
    {
        initEdgeCCW(m_edge01, m_horizontalFill, m_verticalFill, x0, y0, x1, y1);
        initEdgeCCW(m_edge12, m_horizontalFill, m_verticalFill, x1, y1, x2, y2);
        initEdgeCCW(m_edge20, m_horizontalFill, m_verticalFill, x2, y2, x0, y0);
    }
    else
    {
        // Reverse edges
        initEdgeCCW(m_edge01, m_horizontalFill, m_verticalFill, x1, y1, x0, y0);
        initEdgeCCW(m_edge12, m_horizontalFill, m_verticalFill, x2, y2, x1, y1);
        initEdgeCCW(m_edge20, m_horizontalFill, m_verticalFill, x0, y0, x2, y2);
    }

    // Determine face.
    const int64_t s         = evaluateEdge(m_edge01, x2, y2);
    const bool positiveArea = (m_winding == WINDING_CCW) ? (s > 0) : (s < 0);

    if (m_viewportOrientation == VIEWPORTORIENTATION_UPPER_LEFT)
        m_face = positiveArea ? FACETYPE_BACK : FACETYPE_FRONT;
    else
        m_face = positiveArea ? FACETYPE_FRONT : FACETYPE_BACK;

    if (!positiveArea)
    {
        // Reverse edges so that we can use CCW area tests & interpolation
        reverseEdge(m_edge01);
        reverseEdge(m_edge12);
        reverseEdge(m_edge20);
    }

    // Bounding box
    const int64_t xMin = de::min(de::min(x0, x1), x2);
    const int64_t xMax = de::max(de::max(x0, x1), x2);
    const int64_t yMin = de::min(de::min(y0, y1), y2);
    const int64_t yMax = de::max(de::max(y0, y1), y2);

    m_bboxMin.x() = floorSubpixelToPixelCoord(xMin, m_subpixelBits, m_horizontalFill == FILL_LEFT);
    m_bboxMin.y() = floorSubpixelToPixelCoord(yMin, m_subpixelBits, m_verticalFill == FILL_BOTTOM);
    m_bboxMax.x() = ceilSubpixelToPixelCoord(xMax, m_subpixelBits, m_horizontalFill == FILL_RIGHT);
    m_bboxMax.y() = ceilSubpixelToPixelCoord(yMax, m_subpixelBits, m_verticalFill == FILL_TOP);

    // Clamp to viewport
    const int wX0 = m_viewport.x();
    const int wY0 = m_viewport.y();
    const int wX1 = wX0 + m_viewport.z() - 1;
    const int wY1 = wY0 + m_viewport.w() - 1;

    m_bboxMin.x() = de::clamp(m_bboxMin.x(), wX0, wX1);
    m_bboxMin.y() = de::clamp(m_bboxMin.y(), wY0, wY1);
    m_bboxMax.x() = de::clamp(m_bboxMax.x(), wX0, wX1);
    m_bboxMax.y() = de::clamp(m_bboxMax.y(), wY0, wY1);

    m_curPos = m_bboxMin;
}

void TriangleRasterizer::rasterizeSingleSample(FragmentPacket *const fragmentPackets, float *const depthValues,
                                               const int maxFragmentPackets, int &numPacketsRasterized)
{
    DE_ASSERT(maxFragmentPackets > 0);

    const uint64_t halfPixel = 1ll << (m_subpixelBits - 1);
    int packetNdx            = 0;

    // For depth interpolation; given barycentrics A, B, C = (1 - A - B)
    // we can reformulate the usual z = z0*A + z1*B + z2*C into more
    // stable equation z = A*(z0 - z2) + B*(z1 - z2) + z2.
    const float za = m_v0.z() - m_v2.z();
    const float zb = m_v1.z() - m_v2.z();
    const float zc = m_v2.z();

    while (m_curPos.y() <= m_bboxMax.y() && packetNdx < maxFragmentPackets)
    {
        const int x0 = m_curPos.x();
        const int y0 = m_curPos.y();

        // Subpixel coords
        const int64_t sx0 = toSubpixelCoord(x0, m_subpixelBits) + halfPixel;
        const int64_t sx1 = toSubpixelCoord(x0 + 1, m_subpixelBits) + halfPixel;
        const int64_t sy0 = toSubpixelCoord(y0, m_subpixelBits) + halfPixel;
        const int64_t sy1 = toSubpixelCoord(y0 + 1, m_subpixelBits) + halfPixel;

        const int64_t sx[4] = {sx0, sx1, sx0, sx1};
        const int64_t sy[4] = {sy0, sy0, sy1, sy1};

        // Viewport test
        const bool outX1 = x0 + 1 == m_viewport.x() + m_viewport.z();
        const bool outY1 = y0 + 1 == m_viewport.y() + m_viewport.w();

        DE_ASSERT(x0 < m_viewport.x() + m_viewport.z());
        DE_ASSERT(y0 < m_viewport.y() + m_viewport.w());

        // Edge values
        tcu::Vector<int64_t, 4> e01;
        tcu::Vector<int64_t, 4> e12;
        tcu::Vector<int64_t, 4> e20;

        // Coverage
        uint64_t coverage = 0;

        // Evaluate edge values
        for (int i = 0; i < 4; i++)
        {
            e01[i] = evaluateEdge(m_edge01, sx[i], sy[i]);
            e12[i] = evaluateEdge(m_edge12, sx[i], sy[i]);
            e20[i] = evaluateEdge(m_edge20, sx[i], sy[i]);
        }

        // Compute coverage mask
        coverage = setCoverageValue(coverage, 1, 0, 0, 0,
                                    isInsideCCW(m_edge01, e01[0]) && isInsideCCW(m_edge12, e12[0]) &&
                                        isInsideCCW(m_edge20, e20[0]));
        coverage = setCoverageValue(coverage, 1, 1, 0, 0,
                                    !outX1 && isInsideCCW(m_edge01, e01[1]) && isInsideCCW(m_edge12, e12[1]) &&
                                        isInsideCCW(m_edge20, e20[1]));
        coverage = setCoverageValue(coverage, 1, 0, 1, 0,
                                    !outY1 && isInsideCCW(m_edge01, e01[2]) && isInsideCCW(m_edge12, e12[2]) &&
                                        isInsideCCW(m_edge20, e20[2]));
        coverage = setCoverageValue(coverage, 1, 1, 1, 0,
                                    !outX1 && !outY1 && isInsideCCW(m_edge01, e01[3]) &&
                                        isInsideCCW(m_edge12, e12[3]) && isInsideCCW(m_edge20, e20[3]));

        // Advance to next location
        m_curPos.x() += 2;
        if (m_curPos.x() > m_bboxMax.x())
        {
            m_curPos.y() += 2;
            m_curPos.x() = m_bboxMin.x();
        }

        if (coverage == 0)
            continue; // Discard.

        // Floating-point edge values for barycentrics etc.
        const tcu::Vec4 e01f = e01.asFloat();
        const tcu::Vec4 e12f = e12.asFloat();
        const tcu::Vec4 e20f = e20.asFloat();

        // Compute depth values.
        if (depthValues)
        {
            const tcu::Vec4 edgeSum = e01f + e12f + e20f;
            const tcu::Vec4 z0      = e12f / edgeSum;
            const tcu::Vec4 z1      = e20f / edgeSum;

            depthValues[packetNdx * 4 + 0] = z0[0] * za + z1[0] * zb + zc;
            depthValues[packetNdx * 4 + 1] = z0[1] * za + z1[1] * zb + zc;
            depthValues[packetNdx * 4 + 2] = z0[2] * za + z1[2] * zb + zc;
            depthValues[packetNdx * 4 + 3] = z0[3] * za + z1[3] * zb + zc;
        }

        // Compute barycentrics and write out fragment packet
        {
            FragmentPacket &packet = fragmentPackets[packetNdx];

            const tcu::Vec4 b0   = e12f * m_v0.w();
            const tcu::Vec4 b1   = e20f * m_v1.w();
            const tcu::Vec4 b2   = e01f * m_v2.w();
            const tcu::Vec4 bSum = b0 + b1 + b2;

            packet.position       = tcu::IVec2(x0, y0);
            packet.coverage       = coverage;
            packet.barycentric[0] = b0 / bSum;
            packet.barycentric[1] = b1 / bSum;
            packet.barycentric[2] = 1.0f - packet.barycentric[0] - packet.barycentric[1];

            packetNdx += 1;
        }
    }

    DE_ASSERT(packetNdx <= maxFragmentPackets);
    numPacketsRasterized = packetNdx;
}

// Sample positions - ordered as (x, y) list.
static const float s_samplePts2[] = {0.3f, 0.3f, 0.7f, 0.7f};

static const float s_samplePts4[] = {0.25f, 0.25f, 0.75f, 0.25f, 0.25f, 0.75f, 0.75f, 0.75f};

static const float s_samplePts8[] = {7.f / 16.f,  9.f / 16.f,  9.f / 16.f, 13.f / 16.f, 11.f / 16.f, 3.f / 16.f,
                                     13.f / 16.f, 11.f / 16.f, 1.f / 16.f, 7.f / 16.f,  5.f / 16.f,  1.f / 16.f,
                                     15.f / 16.f, 5.f / 16.f,  3.f / 16.f, 15.f / 16.f};

static const float s_samplePts16[] = {1.f / 8.f, 1.f / 8.f, 3.f / 8.f, 1.f / 8.f, 5.f / 8.f, 1.f / 8.f, 7.f / 8.f,
                                      1.f / 8.f, 1.f / 8.f, 3.f / 8.f, 3.f / 8.f, 3.f / 8.f, 5.f / 8.f, 3.f / 8.f,
                                      7.f / 8.f, 3.f / 8.f, 1.f / 8.f, 5.f / 8.f, 3.f / 8.f, 5.f / 8.f, 5.f / 8.f,
                                      5.f / 8.f, 7.f / 8.f, 5.f / 8.f, 1.f / 8.f, 7.f / 8.f, 3.f / 8.f, 7.f / 8.f,
                                      5.f / 8.f, 7.f / 8.f, 7.f / 8.f, 7.f / 8.f};

template <int NumSamples>
void TriangleRasterizer::rasterizeMultiSample(FragmentPacket *const fragmentPackets, float *const depthValues,
                                              const int maxFragmentPackets, int &numPacketsRasterized)
{
    DE_ASSERT(maxFragmentPackets > 0);

    // Big enough to hold maximum multisample count
    int64_t samplePos[DE_LENGTH_OF_ARRAY(s_samplePts16)];
    const float *samplePts   = DE_NULL;
    const uint64_t halfPixel = 1ll << (m_subpixelBits - 1);
    int packetNdx            = 0;

    // For depth interpolation, see rasterizeSingleSample
    const float za = m_v0.z() - m_v2.z();
    const float zb = m_v1.z() - m_v2.z();
    const float zc = m_v2.z();

    switch (NumSamples)
    {
    case 2:
        samplePts = s_samplePts2;
        break;
    case 4:
        samplePts = s_samplePts4;
        break;
    case 8:
        samplePts = s_samplePts8;
        break;
    case 16:
        samplePts = s_samplePts16;
        break;
    default:
        DE_ASSERT(false);
    }

    for (int c = 0; c < NumSamples * 2; ++c)
        samplePos[c] = toSubpixelCoord(samplePts[c], m_subpixelBits);

    while (m_curPos.y() <= m_bboxMax.y() && packetNdx < maxFragmentPackets)
    {
        const int x0 = m_curPos.x();
        const int y0 = m_curPos.y();

        // Base subpixel coords
        const int64_t sx0 = toSubpixelCoord(x0, m_subpixelBits);
        const int64_t sx1 = toSubpixelCoord(x0 + 1, m_subpixelBits);
        const int64_t sy0 = toSubpixelCoord(y0, m_subpixelBits);
        const int64_t sy1 = toSubpixelCoord(y0 + 1, m_subpixelBits);

        const int64_t sx[4] = {sx0, sx1, sx0, sx1};
        const int64_t sy[4] = {sy0, sy0, sy1, sy1};

        // Viewport test
        const bool outX1 = x0 + 1 == m_viewport.x() + m_viewport.z();
        const bool outY1 = y0 + 1 == m_viewport.y() + m_viewport.w();

        DE_ASSERT(x0 < m_viewport.x() + m_viewport.z());
        DE_ASSERT(y0 < m_viewport.y() + m_viewport.w());

        // Edge values
        tcu::Vector<int64_t, 4> e01[NumSamples];
        tcu::Vector<int64_t, 4> e12[NumSamples];
        tcu::Vector<int64_t, 4> e20[NumSamples];

        // Coverage
        uint64_t coverage = 0;

        // Evaluate edge values at sample positions
        for (int sampleNdx = 0; sampleNdx < NumSamples; sampleNdx++)
        {
            const int64_t ox = samplePos[sampleNdx * 2 + 0];
            const int64_t oy = samplePos[sampleNdx * 2 + 1];

            for (int fragNdx = 0; fragNdx < 4; fragNdx++)
            {
                e01[sampleNdx][fragNdx] = evaluateEdge(m_edge01, sx[fragNdx] + ox, sy[fragNdx] + oy);
                e12[sampleNdx][fragNdx] = evaluateEdge(m_edge12, sx[fragNdx] + ox, sy[fragNdx] + oy);
                e20[sampleNdx][fragNdx] = evaluateEdge(m_edge20, sx[fragNdx] + ox, sy[fragNdx] + oy);
            }
        }

        // Compute coverage mask
        for (int sampleNdx = 0; sampleNdx < NumSamples; sampleNdx++)
        {
            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]));
            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]));
            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]));
            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]));
        }

        // Advance to next location
        m_curPos.x() += 2;
        if (m_curPos.x() > m_bboxMax.x())
        {
            m_curPos.y() += 2;
            m_curPos.x() = m_bboxMin.x();
        }

        if (coverage == 0)
            continue; // Discard.

        // Compute depth values.
        if (depthValues)
        {
            for (int sampleNdx = 0; sampleNdx < NumSamples; sampleNdx++)
            {
                // Floating-point edge values at sample coordinates.
                const tcu::Vec4 &e01f = e01[sampleNdx].asFloat();
                const tcu::Vec4 &e12f = e12[sampleNdx].asFloat();
                const tcu::Vec4 &e20f = e20[sampleNdx].asFloat();

                const tcu::Vec4 edgeSum = e01f + e12f + e20f;
                const tcu::Vec4 z0      = e12f / edgeSum;
                const tcu::Vec4 z1      = e20f / edgeSum;

                depthValues[(packetNdx * 4 + 0) * NumSamples + sampleNdx] = z0[0] * za + z1[0] * zb + zc;
                depthValues[(packetNdx * 4 + 1) * NumSamples + sampleNdx] = z0[1] * za + z1[1] * zb + zc;
                depthValues[(packetNdx * 4 + 2) * NumSamples + sampleNdx] = z0[2] * za + z1[2] * zb + zc;
                depthValues[(packetNdx * 4 + 3) * NumSamples + sampleNdx] = z0[3] * za + z1[3] * zb + zc;
            }
        }

        // Compute barycentrics and write out fragment packet
        {
            FragmentPacket &packet = fragmentPackets[packetNdx];

            // Floating-point edge values at pixel center.
            tcu::Vec4 e01f;
            tcu::Vec4 e12f;
            tcu::Vec4 e20f;

            for (int i = 0; i < 4; i++)
            {
                e01f[i] = float(evaluateEdge(m_edge01, sx[i] + halfPixel, sy[i] + halfPixel));
                e12f[i] = float(evaluateEdge(m_edge12, sx[i] + halfPixel, sy[i] + halfPixel));
                e20f[i] = float(evaluateEdge(m_edge20, sx[i] + halfPixel, sy[i] + halfPixel));
            }

            // Barycentrics & scale.
            const tcu::Vec4 b0   = e12f * m_v0.w();
            const tcu::Vec4 b1   = e20f * m_v1.w();
            const tcu::Vec4 b2   = e01f * m_v2.w();
            const tcu::Vec4 bSum = b0 + b1 + b2;

            packet.position       = tcu::IVec2(x0, y0);
            packet.coverage       = coverage;
            packet.barycentric[0] = b0 / bSum;
            packet.barycentric[1] = b1 / bSum;
            packet.barycentric[2] = 1.0f - packet.barycentric[0] - packet.barycentric[1];

            packetNdx += 1;
        }
    }

    DE_ASSERT(packetNdx <= maxFragmentPackets);
    numPacketsRasterized = packetNdx;
}

void TriangleRasterizer::rasterize(FragmentPacket *const fragmentPackets, float *const depthValues,
                                   const int maxFragmentPackets, int &numPacketsRasterized)
{
    DE_ASSERT(maxFragmentPackets > 0);

    switch (m_numSamples)
    {
    case 1:
        rasterizeSingleSample(fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized);
        break;
    case 2:
        rasterizeMultiSample<2>(fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized);
        break;
    case 4:
        rasterizeMultiSample<4>(fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized);
        break;
    case 8:
        rasterizeMultiSample<8>(fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized);
        break;
    case 16:
        rasterizeMultiSample<16>(fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized);
        break;
    default:
        DE_ASSERT(false);
    }
}

SingleSampleLineRasterizer::SingleSampleLineRasterizer(const tcu::IVec4 &viewport, const int subpixelBits)
    : m_viewport(viewport)
    , m_subpixelBits(subpixelBits)
    , m_curRowFragment(0)
    , m_lineWidth(0.0f)
    , m_stippleCounter(0)
{
}

SingleSampleLineRasterizer::~SingleSampleLineRasterizer(void)
{
}

void SingleSampleLineRasterizer::init(const tcu::Vec4 &v0, const tcu::Vec4 &v1, float lineWidth, uint32_t stippleFactor,
                                      uint16_t stipplePattern)
{
    const bool isXMajor = de::abs((v1 - v0).x()) >= de::abs((v1 - v0).y());

    // Bounding box \note: with wide lines, the line is actually moved as in the spec
    const int32_t lineWidthPixels = (lineWidth > 1.0f) ? (int32_t)floor(lineWidth + 0.5f) : 1;

    const tcu::Vector<int64_t, 2> widthOffset =
        (isXMajor ? tcu::Vector<int64_t, 2>(0, -1) : tcu::Vector<int64_t, 2>(-1, 0)) *
        (toSubpixelCoord(lineWidthPixels - 1, m_subpixelBits) / 2);

    const int64_t x0 = toSubpixelCoord(v0.x(), m_subpixelBits) + widthOffset.x();
    const int64_t y0 = toSubpixelCoord(v0.y(), m_subpixelBits) + widthOffset.y();
    const int64_t x1 = toSubpixelCoord(v1.x(), m_subpixelBits) + widthOffset.x();
    const int64_t y1 = toSubpixelCoord(v1.y(), m_subpixelBits) + widthOffset.y();

    // line endpoints might be perturbed, add some margin
    const int64_t xMin = de::min(x0, x1) - toSubpixelCoord(1, m_subpixelBits);
    const int64_t xMax = de::max(x0, x1) + toSubpixelCoord(1, m_subpixelBits);
    const int64_t yMin = de::min(y0, y1) - toSubpixelCoord(1, m_subpixelBits);
    const int64_t yMax = de::max(y0, y1) + toSubpixelCoord(1, m_subpixelBits);

    // Remove invisible area

    if (isXMajor)
    {
        // clamp to viewport in major direction
        m_bboxMin.x() = de::clamp(floorSubpixelToPixelCoord(xMin, m_subpixelBits, true), m_viewport.x(),
                                  m_viewport.x() + m_viewport.z() - 1);
        m_bboxMax.x() = de::clamp(ceilSubpixelToPixelCoord(xMax, m_subpixelBits, true), m_viewport.x(),
                                  m_viewport.x() + m_viewport.z() - 1);

        // clamp to padded viewport in minor direction (wide lines might bleed over viewport in minor direction)
        m_bboxMin.y() = de::clamp(floorSubpixelToPixelCoord(yMin, m_subpixelBits, true),
                                  m_viewport.y() - lineWidthPixels, m_viewport.y() + m_viewport.w() - 1);
        m_bboxMax.y() = de::clamp(ceilSubpixelToPixelCoord(yMax, m_subpixelBits, true),
                                  m_viewport.y() - lineWidthPixels, m_viewport.y() + m_viewport.w() - 1);
    }
    else
    {
        // clamp to viewport in major direction
        m_bboxMin.y() = de::clamp(floorSubpixelToPixelCoord(yMin, m_subpixelBits, true), m_viewport.y(),
                                  m_viewport.y() + m_viewport.w() - 1);
        m_bboxMax.y() = de::clamp(ceilSubpixelToPixelCoord(yMax, m_subpixelBits, true), m_viewport.y(),
                                  m_viewport.y() + m_viewport.w() - 1);

        // clamp to padded viewport in minor direction (wide lines might bleed over viewport in minor direction)
        m_bboxMin.x() = de::clamp(floorSubpixelToPixelCoord(xMin, m_subpixelBits, true),
                                  m_viewport.x() - lineWidthPixels, m_viewport.x() + m_viewport.z() - 1);
        m_bboxMax.x() = de::clamp(ceilSubpixelToPixelCoord(xMax, m_subpixelBits, true),
                                  m_viewport.x() - lineWidthPixels, m_viewport.x() + m_viewport.z() - 1);
    }

    m_lineWidth = lineWidth;

    m_v0 = v0;
    m_v1 = v1;

    // Choose direction of traversal and whether to start at bbox min or max. Direction matters
    // for the stipple counter.
    int xDelta = (m_v1 - m_v0).x() > 0 ? 1 : -1;
    int yDelta = (m_v1 - m_v0).y() > 0 ? 1 : -1;

    m_curPos.x() = xDelta > 0 ? m_bboxMin.x() : m_bboxMax.x();
    m_curPos.y() = yDelta > 0 ? m_bboxMin.y() : m_bboxMax.y();

    m_curRowFragment = 0;
    m_stippleFactor  = stippleFactor;
    m_stipplePattern = stipplePattern;
}

void SingleSampleLineRasterizer::rasterize(FragmentPacket *const fragmentPackets, float *const depthValues,
                                           const int maxFragmentPackets, int &numPacketsRasterized)
{
    DE_ASSERT(maxFragmentPackets > 0);

    const int64_t halfPixel         = 1ll << (m_subpixelBits - 1);
    const int32_t lineWidth         = (m_lineWidth > 1.0f) ? deFloorFloatToInt32(m_lineWidth + 0.5f) : 1;
    const bool isXMajor             = de::abs((m_v1 - m_v0).x()) >= de::abs((m_v1 - m_v0).y());
    const tcu::IVec2 minorDirection = (isXMajor) ? (tcu::IVec2(0, 1)) : (tcu::IVec2(1, 0));
    const int minViewportLimit      = (isXMajor) ? (m_viewport.y()) : (m_viewport.x());
    const int maxViewportLimit = (isXMajor) ? (m_viewport.y() + m_viewport.w()) : (m_viewport.x() + m_viewport.z());
    const tcu::Vector<int64_t, 2> widthOffset =
        -minorDirection.cast<int64_t>() * (toSubpixelCoord(lineWidth - 1, m_subpixelBits) / 2);
    const tcu::Vector<int64_t, 2> pa = LineRasterUtil::toSubpixelVector(m_v0.xy(), m_subpixelBits) + widthOffset;
    const tcu::Vector<int64_t, 2> pb = LineRasterUtil::toSubpixelVector(m_v1.xy(), m_subpixelBits) + widthOffset;
    const LineRasterUtil::SubpixelLineSegment line = LineRasterUtil::SubpixelLineSegment(pa, pb);

    int packetNdx = 0;
    int xDelta    = (m_v1 - m_v0).x() > 0 ? 1 : -1;
    int yDelta    = (m_v1 - m_v0).y() > 0 ? 1 : -1;

    while (m_curPos.y() <= m_bboxMax.y() && m_curPos.y() >= m_bboxMin.y() && packetNdx < maxFragmentPackets)
    {
        const tcu::Vector<int64_t, 2> diamondPosition =
            LineRasterUtil::toSubpixelVector(m_curPos, m_subpixelBits) + tcu::Vector<int64_t, 2>(halfPixel, halfPixel);

        // Should current fragment be drawn? == does the segment exit this diamond?
        if (LineRasterUtil::doesLineSegmentExitDiamond(line, diamondPosition, m_subpixelBits))
        {
            const tcu::Vector<int64_t, 2> pr = diamondPosition;
            const float t =
                tcu::dot((pr - pa).asFloat(), (pb - pa).asFloat()) / tcu::lengthSquared(pb.asFloat() - pa.asFloat());

            // Rasterize on only fragments that are would end up in the viewport (i.e. visible)
            const int fragmentLocation = (isXMajor) ? (m_curPos.y()) : (m_curPos.x());
            const int rowFragBegin     = de::max(0, minViewportLimit - fragmentLocation);
            const int rowFragEnd       = de::min(maxViewportLimit - fragmentLocation, lineWidth);

            int stippleBit   = (m_stippleCounter / m_stippleFactor) % 16;
            bool stipplePass = (m_stipplePattern & (1 << stippleBit)) != 0;
            m_stippleCounter++;

            if (stipplePass)
            {
                // Wide lines require multiple fragments.
                for (; rowFragBegin + m_curRowFragment < rowFragEnd; m_curRowFragment++)
                {
                    const int replicationId      = rowFragBegin + m_curRowFragment;
                    const tcu::IVec2 fragmentPos = m_curPos + minorDirection * replicationId;

                    // We only rasterize visible area
                    DE_ASSERT(LineRasterUtil::inViewport(fragmentPos, m_viewport));

                    // Compute depth values.
                    if (depthValues)
                    {
                        const float za = m_v0.z();
                        const float zb = m_v1.z();

                        depthValues[packetNdx * 4 + 0] = (1 - t) * za + t * zb;
                        depthValues[packetNdx * 4 + 1] = 0;
                        depthValues[packetNdx * 4 + 2] = 0;
                        depthValues[packetNdx * 4 + 3] = 0;
                    }

                    {
                        // output this fragment
                        // \note In order to make consistent output with multisampled line rasterization, output "barycentric" coordinates
                        FragmentPacket &packet = fragmentPackets[packetNdx];

                        const tcu::Vec4 b0    = tcu::Vec4(1 - t);
                        const tcu::Vec4 b1    = tcu::Vec4(t);
                        const tcu::Vec4 ooSum = 1.0f / (b0 + b1);

                        packet.position       = fragmentPos;
                        packet.coverage       = getCoverageBit(1, 0, 0, 0);
                        packet.barycentric[0] = b0 * ooSum;
                        packet.barycentric[1] = b1 * ooSum;
                        packet.barycentric[2] = tcu::Vec4(0.0f);

                        packetNdx += 1;
                    }

                    if (packetNdx == maxFragmentPackets)
                    {
                        m_curRowFragment++; // don't redraw this fragment again next time
                        m_stippleCounter--; // reuse same stipple counter next time
                        numPacketsRasterized = packetNdx;
                        return;
                    }
                }

                m_curRowFragment = 0;
            }
        }

        m_curPos.x() += xDelta;
        if (m_curPos.x() > m_bboxMax.x() || m_curPos.x() < m_bboxMin.x())
        {
            m_curPos.y() += yDelta;
            m_curPos.x() = xDelta > 0 ? m_bboxMin.x() : m_bboxMax.x();
        }
    }

    DE_ASSERT(packetNdx <= maxFragmentPackets);
    numPacketsRasterized = packetNdx;
}

MultiSampleLineRasterizer::MultiSampleLineRasterizer(const int numSamples, const tcu::IVec4 &viewport,
                                                     const int subpixelBits)
    : m_numSamples(numSamples)
    , m_triangleRasterizer0(viewport, m_numSamples, RasterizationState(), subpixelBits)
    , m_triangleRasterizer1(viewport, m_numSamples, RasterizationState(), subpixelBits)
{
}

MultiSampleLineRasterizer::~MultiSampleLineRasterizer()
{
}

void MultiSampleLineRasterizer::init(const tcu::Vec4 &v0, const tcu::Vec4 &v1, float lineWidth)
{
    // allow creation of single sampled rasterizer objects but do not allow using them
    DE_ASSERT(m_numSamples > 1);

    const tcu::Vec2 lineVec = tcu::Vec2(tcu::Vec4(v1).xy()) - tcu::Vec2(tcu::Vec4(v0).xy());
    const tcu::Vec2 normal2 = tcu::normalize(tcu::Vec2(-lineVec[1], lineVec[0]));
    const tcu::Vec4 normal4 = tcu::Vec4(normal2.x(), normal2.y(), 0, 0);
    const float offset      = lineWidth / 2.0f;

    const tcu::Vec4 p0 = v0 + normal4 * offset;
    const tcu::Vec4 p1 = v0 - normal4 * offset;
    const tcu::Vec4 p2 = v1 - normal4 * offset;
    const tcu::Vec4 p3 = v1 + normal4 * offset;

    // Edge 0 -> 1 is always along the line and edge 1 -> 2 is in 90 degree angle to the line
    m_triangleRasterizer0.init(p0, p3, p2);
    m_triangleRasterizer1.init(p2, p1, p0);
}

void MultiSampleLineRasterizer::rasterize(FragmentPacket *const fragmentPackets, float *const depthValues,
                                          const int maxFragmentPackets, int &numPacketsRasterized)
{
    DE_ASSERT(maxFragmentPackets > 0);

    m_triangleRasterizer0.rasterize(fragmentPackets, depthValues, maxFragmentPackets, numPacketsRasterized);

    // Remove 3rd barycentric value and rebalance. Lines do not have non-zero barycentric at index 2
    for (int packNdx = 0; packNdx < numPacketsRasterized; ++packNdx)
        for (int fragNdx = 0; fragNdx < 4; fragNdx++)
        {
            float removedValue                               = fragmentPackets[packNdx].barycentric[2][fragNdx];
            fragmentPackets[packNdx].barycentric[2][fragNdx] = 0.0f;
            fragmentPackets[packNdx].barycentric[1][fragNdx] += removedValue;
        }

    // rasterizer 0 filled the whole buffer?
    if (numPacketsRasterized == maxFragmentPackets)
        return;

    {
        FragmentPacket *const nextFragmentPackets = fragmentPackets + numPacketsRasterized;
        float *nextDepthValues    = (depthValues) ? (depthValues + 4 * numPacketsRasterized * m_numSamples) : (DE_NULL);
        int numPacketsRasterized2 = 0;

        m_triangleRasterizer1.rasterize(nextFragmentPackets, nextDepthValues, maxFragmentPackets - numPacketsRasterized,
                                        numPacketsRasterized2);

        numPacketsRasterized += numPacketsRasterized2;

        // Fix swapped barycentrics in the second triangle
        for (int packNdx = 0; packNdx < numPacketsRasterized2; ++packNdx)
            for (int fragNdx = 0; fragNdx < 4; fragNdx++)
            {
                float removedValue = nextFragmentPackets[packNdx].barycentric[2][fragNdx];
                nextFragmentPackets[packNdx].barycentric[2][fragNdx] = 0.0f;
                nextFragmentPackets[packNdx].barycentric[1][fragNdx] += removedValue;

                // edge has reversed direction
                std::swap(nextFragmentPackets[packNdx].barycentric[0][fragNdx],
                          nextFragmentPackets[packNdx].barycentric[1][fragNdx]);
            }
    }
}

LineExitDiamondGenerator::LineExitDiamondGenerator(const int subpixelBits) : m_subpixelBits(subpixelBits)
{
}

LineExitDiamondGenerator::~LineExitDiamondGenerator(void)
{
}

void LineExitDiamondGenerator::init(const tcu::Vec4 &v0, const tcu::Vec4 &v1)
{
    const int64_t x0 = toSubpixelCoord(v0.x(), m_subpixelBits);
    const int64_t y0 = toSubpixelCoord(v0.y(), m_subpixelBits);
    const int64_t x1 = toSubpixelCoord(v1.x(), m_subpixelBits);
    const int64_t y1 = toSubpixelCoord(v1.y(), m_subpixelBits);

    // line endpoints might be perturbed, add some margin
    const int64_t xMin = de::min(x0, x1) - toSubpixelCoord(1, m_subpixelBits);
    const int64_t xMax = de::max(x0, x1) + toSubpixelCoord(1, m_subpixelBits);
    const int64_t yMin = de::min(y0, y1) - toSubpixelCoord(1, m_subpixelBits);
    const int64_t yMax = de::max(y0, y1) + toSubpixelCoord(1, m_subpixelBits);

    m_bboxMin.x() = floorSubpixelToPixelCoord(xMin, m_subpixelBits, true);
    m_bboxMin.y() = floorSubpixelToPixelCoord(yMin, m_subpixelBits, true);
    m_bboxMax.x() = ceilSubpixelToPixelCoord(xMax, m_subpixelBits, true);
    m_bboxMax.y() = ceilSubpixelToPixelCoord(yMax, m_subpixelBits, true);

    m_v0 = v0;
    m_v1 = v1;

    m_curPos = m_bboxMin;
}

void LineExitDiamondGenerator::rasterize(LineExitDiamond *const lineDiamonds, const int maxDiamonds, int &numWritten)
{
    DE_ASSERT(maxDiamonds > 0);

    const int64_t halfPixel                        = 1ll << (m_subpixelBits - 1);
    const tcu::Vector<int64_t, 2> pa               = LineRasterUtil::toSubpixelVector(m_v0.xy(), m_subpixelBits);
    const tcu::Vector<int64_t, 2> pb               = LineRasterUtil::toSubpixelVector(m_v1.xy(), m_subpixelBits);
    const LineRasterUtil::SubpixelLineSegment line = LineRasterUtil::SubpixelLineSegment(pa, pb);

    int diamondNdx = 0;

    while (m_curPos.y() <= m_bboxMax.y() && diamondNdx < maxDiamonds)
    {
        const tcu::Vector<int64_t, 2> diamondPosition =
            LineRasterUtil::toSubpixelVector(m_curPos, m_subpixelBits) + tcu::Vector<int64_t, 2>(halfPixel, halfPixel);

        if (LineRasterUtil::doesLineSegmentExitDiamond(line, diamondPosition, m_subpixelBits))
        {
            LineExitDiamond &packet = lineDiamonds[diamondNdx];
            packet.position         = m_curPos;
            ++diamondNdx;
        }

        ++m_curPos.x();
        if (m_curPos.x() > m_bboxMax.x())
        {
            ++m_curPos.y();
            m_curPos.x() = m_bboxMin.x();
        }
    }

    DE_ASSERT(diamondNdx <= maxDiamonds);
    numWritten = diamondNdx;
}

} // namespace rr