Copy code from the holdingarea into the target locations.
Some initial rework of CMakeLists.txt files, but not yet tested.
/*------------------------------------------------------------------------
*
* OpenVG 1.1 Reference Implementation
* -----------------------------------
*
* Copyright (c) 2007 The Khronos Group Inc.
* Portions copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and /or associated documentation files
* (the "Materials "), to deal in the Materials without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Materials,
* and to permit persons to whom the Materials are furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
* THE USE OR OTHER DEALINGS IN THE MATERIALS.
*
*//**
* \file
* \brief Implementation of polygon rasterizer.
* \note
*//*-------------------------------------------------------------------*/
#include "riRasterizer.h"
// TEMP!
#ifndef __SFCOMPILER_H
# include "sfCompiler.h"
#endif
namespace OpenVGRI
{
/*-------------------------------------------------------------------*//*!
* \brief Rasterizer constructor.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/
Rasterizer::Rasterizer() :
m_covBuffer(NULL),
m_covBufferSz(0),
m_edges(),
m_scissorEdges(),
m_scissor(false),
m_aa(true),
m_vpx(0),
m_vpy(0),
m_vpwidth(0),
m_vpheight(0),
m_fillRule(VG_EVEN_ODD),
m_pixelPipe(NULL),
m_nSpans(0)
{}
/*-------------------------------------------------------------------*//*!
* \brief Rasterizer destructor.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/
Rasterizer::~Rasterizer()
{
if(m_covBuffer)
RI_DELETE_ARRAY(m_covBuffer);
}
/*-------------------------------------------------------------------*//*!
* \brief Removes all appended edges.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/
#define EDGE_TERMINATOR 0xFFFFFFFFu
void Rasterizer::clear()
{
//m_edges.clear();
for (int i = 0; i < m_edges.size(); i++)
m_edges[i] = EDGE_TERMINATOR;
m_edgePool.clear();
m_edgeMin.set(0x7fffffffu, 0x7fffffffu);
m_edgeMax.set(0x80000000, 0x80000000);
}
/*-------------------------------------------------------------------*//*!
* \brief Appends an edge to the rasterizer.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/
void Rasterizer::addBBox(const IVector2& v)
{
if(v.x < m_edgeMin.x) m_edgeMin.x = v.x;
if(v.y < m_edgeMin.y) m_edgeMin.y = v.y;
if(v.x > m_edgeMax.x) m_edgeMax.x = v.x;
if(v.y > m_edgeMax.y) m_edgeMax.y = v.y;
}
void Rasterizer::pushEdge(const Edge& edge)
{
addBBox(edge.v0);
addBBox(edge.v1);
// Only add processed edges.
RI_ASSERT(edge.v0.y >= 0);
RI_ASSERT(edge.v0.y < edge.v1.y); //horizontal edges should have been dropped already
ActiveEdge ae;
ae.direction = edge.direction;
// \todo Adjust for non-AA cases
// \todo verySteep is temporary. Either clip to right edge also, or validate that a proper slope can be
// calculated here.
const int slope = RI_SAT_SHL((edge.v1.x - edge.v0.x), RASTERIZER_BITS - X_BITS) / (edge.v1.y - edge.v0.y);
//const bool verySteep = RI_INT_ABS(edge.v1.x - edge.v0.x) > (1 << (30-RASTERIZER_BITS)) ? true : false;
//const int slope = verySteep ? 1 << 30 : RI_SHL((edge.v1.x - edge.v0.x), RASTERIZER_BITS - X_BITS) / (edge.v1.y - edge.v0.y);
// slope: SI.(RASTERIZER_BITS - Y_BITS)
const int yF = edge.v0.y & Y_MASK;
// \todo See verySteep note for this hack also. (Clip to right edge?)
const int xRef = RI_SAT_SHL(edge.v0.x, RASTERIZER_BITS - X_BITS) - (yF * slope);
//const int xRef = edge.v0.x > (1<<(30-RASTERIZER_BITS)) ? 1<<30 : RI_SHL(edge.v0.x, RASTERIZER_BITS - X_BITS) - (yF * slope);
RI_ASSERT(RI_INT_ABS(edge.v0.y <= 32767));
RI_ASSERT(RI_INT_ABS(edge.v1.y <= 32767));
ae.yStart = (RIint16)edge.v0.y;
ae.yEnd = (RIint16)edge.v1.y;
ae.xRef = xRef;
ae.slope = slope;
// Scanline range.
ae.minx = xRef >> RASTERIZER_BITS;
ae.maxx = (xRef + slope * (1<<Y_BITS)) >> RASTERIZER_BITS;
if (ae.minx > ae.maxx)
RI_ANY_SWAP(ActiveEdge::XCoord, ae.minx, ae.maxx);
if (ae.maxx < 0)
ae.minx = ae.maxx = LEFT_DISCARD_SHORT;
if (m_edges[ae.yStart>>Y_BITS] == EDGE_TERMINATOR)
ae.next = EDGE_TERMINATOR;
else
ae.next = m_edges[ae.yStart>>Y_BITS];
m_edgePool.push_back(ae); //throws bad_alloc
RI_ASSERT(m_edgePool.size() > 0);
m_edges[ae.yStart>>Y_BITS] = m_edgePool.size()-1;
}
/**
* \brief Clips an edge and if something remains, adds it to the list of edges.
* \todo Enhance precision: Currently this just uses doubles and gets away with
* it in most cases.
*/
void Rasterizer::clipAndAddEdge(Edge& edge)
{
//if (m_edges.size() > 48)
//return;
// Check y-clips
// \todo Reduce amount of clips.
bool outLeft[2] = {(edge.v0.x < m_vpMinx), (edge.v1.x < m_vpMinx)};
bool outRight[2] = {(edge.v0.x > m_vpMaxx), (edge.v1.x > m_vpMaxx)};
bool outTop[2] = {(edge.v0.y < m_vpMiny), (edge.v1.y < m_vpMiny)};
bool outBottom[2] = {(edge.v0.y > m_vpMaxy), (edge.v1.y > m_vpMaxy)};
if (!(outLeft[0] || outLeft[1] || outRight[0] || outRight[1] || outTop[0] || outTop[1] || outBottom[0] || outBottom[1]))
{
pushEdge(edge);
return;
}
// \todo Make sure that checking out-of-right works with the scanconverter.
if ((outBottom[0] && outBottom[1]) || (outTop[0] && outTop[1]))
return; // Out of bounds
// \todo Clip to right edge of screen.
// \todo Make slope-calculation and signs consistent.
//
if (outTop[0] || outBottom[1])
{
// Clip to top/bottom.
double slope = (double)(edge.v1.x - edge.v0.x)/(edge.v1.y - edge.v0.y);
if (outTop[0])
{
RI_ASSERT(-(RIint64)edge.v0.y >= 0);
RIint32 dx = RI_ROUND_TO_INT(-slope * edge.v0.y);
edge.v0.y = 0;
edge.v0.x += dx;
}
if (outBottom[1])
{
RIint32 dy = edge.v1.y - m_vpMaxy;
RI_ASSERT(dy >= 0);
RIint32 dx = -RI_ROUND_TO_INT(slope * dy);
edge.v1.y = m_vpMaxy;
edge.v1.x += dx;
}
}
if (edge.v0.y >= edge.v1.y)
return;
// \todo Recheck left/right.
outLeft[0] = (edge.v0.x < m_vpMinx); outLeft[1] = (edge.v1.x < m_vpMinx);
outRight[1] = (edge.v0.x > m_vpMaxx); outRight[1] = (edge.v1.x > m_vpMaxx);
if (outLeft[0] && outLeft[1])
{
edge.v0.x = m_vpMinx;
edge.v1.x = m_vpMinx;
pushEdge(edge);
return;
}
if (outRight[0] && outRight[1])
{
edge.v0.x = m_vpMaxx;
edge.v1.x = m_vpMaxx;
pushEdge(edge);
return;
}
// From outside -> screen
if (outLeft[0] || outRight[1])
{
// infinite slope?
double slope = (double)((RIint64)edge.v1.y - edge.v0.y)/((RIint64)edge.v1.x - edge.v0.x);
if (outLeft[0])
{
RIint32 dx = edge.v0.x;
//RI_ASSERT(dx >= 0);
// Note the sign.
RIint32 dy = RI_ROUND_TO_INT(-slope * dx);
Edge vpart = edge;
vpart.v1.y = edge.v0.y + dy;
//vpart.v1.x = edge.v0.x; // = 0?
// \note This should be flagged instead of setting the smallest possible
// value because of extremely gentle slopes may cause bugs:
vpart.v1.x = vpart.v0.x = -0x100000;
if (vpart.v1.y > vpart.v0.y)
pushEdge(vpart);
edge.v0.y += dy;
edge.v0.x = 0;
}
}
// From screen -> outside
if (outLeft[1] || outRight[0])
{
// infinite slope?
double slope = (double)((RIint64)edge.v1.y - edge.v0.y)/((RIint64)edge.v1.x - edge.v0.x);
if (outLeft[1])
{
RIint32 dx = edge.v0.x;
RI_ASSERT(dx >= 0);
RIint32 dy = RI_ROUND_TO_INT(-slope * dx);
Edge vpart = edge;
vpart.v0.y = edge.v0.y + dy;
vpart.v1.x = vpart.v0.x = LEFT_DISCARD;
if (vpart.v1.y > vpart.v0.y)
pushEdge(vpart);
edge.v1.y = edge.v0.y + dy;
edge.v1.x = 0;
}
}
if (edge.v0.y >= edge.v1.y)
return;
// Finally, add the edge:
pushEdge(edge);
}
void Rasterizer::addEdge(const Vector2& v0, const Vector2& v1)
{
if( m_edges.size() >= RI_MAX_EDGES )
throw std::bad_alloc(); //throw an out of memory error if there are too many edges
Edge e;
{
IVector2 i0(RI_ROUND_TO_INT(v0.x * (1<<X_BITS)), RI_ROUND_TO_INT(v0.y * (1<<Y_BITS)));
IVector2 i1(RI_ROUND_TO_INT(v1.x * (1<<X_BITS)), RI_ROUND_TO_INT(v1.y * (1<<Y_BITS)));
if(i0.y == i1.y)
return; //skip horizontal edges (they don't affect rasterization since we scan horizontally)
if (i0.y < i1.y)
{
// Edge is going upward
e.v0 = i0;
e.v1 = i1;
e.direction = 1;
}
else
{
// Edge is going downward
e.v0 = i1;
e.v1 = i0;
e.direction = -1;
}
}
// Clip and insert.
clipAndAddEdge(e);
}
/*-------------------------------------------------------------------*//*!
* \brief Set up rasterizer
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/
void Rasterizer::setup(int vpx, int vpy, int vpwidth, int vpheight, VGFillRule fillRule, const PixelPipe* pixelPipe)
{
RI_ASSERT(vpwidth >= 0 && vpheight >= 0);
RI_ASSERT(vpx + vpwidth >= vpx && vpy + vpheight >= vpy);
RI_ASSERT(fillRule == VG_EVEN_ODD || fillRule == VG_NON_ZERO);
RI_ASSERT(pixelPipe);
clear();
m_vpx = vpx;
m_vpy = vpy;
m_vpwidth = vpwidth;
m_vpheight = vpheight;
if (m_vpheight > m_edges.size())
{
int os = m_edges.size();
m_edges.resize(m_vpheight);
for (int i = os; i < m_edges.size(); i++)
m_edges[i] = EDGE_TERMINATOR;
}
m_vpMinx = RI_SHL(vpx, X_BITS);
m_vpMiny = RI_SHL(vpy, Y_BITS);
m_vpMaxx = RI_SHL(vpx + vpwidth, X_BITS);
m_vpMaxy = RI_SHL(vpy + vpheight, Y_BITS);
m_fillRule = fillRule;
RIuint32 fillRuleMask = fillRule == VG_NON_ZERO ? 0xffffffffu : 1;
m_fillRuleMask = fillRuleMask;
m_pixelPipe = pixelPipe;
m_covMinx = vpx+vpwidth;
m_covMiny = vpy+vpheight;
m_covMaxx = vpx;
m_covMaxy = vpy;
}
/*-------------------------------------------------------------------*//*!
* \brief Sets scissor rectangles.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/
void Rasterizer::setScissor(const Array<Rectangle>& scissors)
{
try
{
m_scissorEdges.clear();
for(int i=0;i<scissors.size();i++)
{
if(scissors[i].width > 0 && scissors[i].height > 0)
{
ScissorEdge e;
e.miny = scissors[i].y;
e.maxy = RI_INT_ADDSATURATE(scissors[i].y, scissors[i].height);
e.x = scissors[i].x;
e.direction = 1;
m_scissorEdges.push_back(e); //throws bad_alloc
e.x = RI_INT_ADDSATURATE(scissors[i].x, scissors[i].width);
e.direction = -1;
m_scissorEdges.push_back(e); //throws bad_alloc
}
}
}
catch(std::bad_alloc)
{
m_scissorEdges.clear();
throw;
}
}
void Rasterizer::setScissoring(bool enabled)
{
m_scissor = enabled;
}
static RI_INLINE void small_memcpy32(void* dst, const void* src, size_t n)
{
RIuint32 *d = (RIuint32*)dst;
const RIuint32 *s = (const RIuint32*)src;
while(n)
{
*d++ = *s++;
n-=4;
}
}
// \todo Move this to some debug file or remove.
#if defined(USE_SSE2) && !defined(_WIN32)
RI_INLINE static void print128(__m128i ll)
{
#if defined(RI_DEBUG)
unsigned long long v[2];
_mm_storeu_pd((double*)v, (__m128d)ll);
RI_PRINTF("0x%016llx %016llx\n", v[0], v[1]);
#else
(void)ll;
#endif
}
#endif
#if defined(USE_SSE2)
RI_INLINE static __m128i mm_mul4x32(const __m128i a, const __m128i b) {
__m128i res;
#if (_MSC_VER > 1400 )
// \todo Simpler way to do this on intel?
__m128i m0 = _mm_mul_epu32(a, _mm_shuffle_epi32(b, _MM_SHUFFLE(1, 1, 0, 0)));
__m128i m1 = _mm_mul_epu32(a, _mm_shuffle_epi32(b, _MM_SHUFFLE(3, 3, 2, 2)));
res = _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(m0), _mm_castsi128_ps(m1), _MM_SHUFFLE(2, 0, 2, 0)));
#else
__asm {
movdqa xmm1, a;
movdqa xmm2, b;
pshufd xmm3, xmm2, 80;
movdqa xmm0, xmm1;
pshufd xmm2, xmm2, 250;
pmuludq xmm0, xmm3;
pmuludq xmm1, xmm2;
shufps xmm0, xmm1, 136;
movdqa res, xmm0;
}
#endif
return res;
}
#endif
#if defined(USE_SSE2)
RI_INLINE static void mm_get_xmasks(const __m128i& coords, const __m128i& sampleCoords, __m128i& slWindMask, __m128i& pxWindMask)
{
const __m128i z = _mm_setzero_si128();
const __m128i xMask = _mm_cmpeq_epi16(_mm_srai_epi16(coords, Rasterizer::RASTERIZER_BITS), z);
const __m128i sCmp = _mm_or_si128(_mm_cmpgt_epi16(sampleCoords, coords), _mm_cmpeq_epi16(sampleCoords, coords));
//const __m128i sCmp = _mm_cmplt_epi16(coords, sampleCoords);
slWindMask = xMask;
pxWindMask = _mm_and_si128(xMask, sCmp);
}
#endif
RI_INLINE static void getVerticalSubpixels(int iY, int yStart, int yEnd, int& py0, int& py1)
{
const int cy = iY << Rasterizer::Y_BITS;
py0 = cy > yStart ? 0 : yStart & Rasterizer::Y_MASK;
py1 = (RI_INT_MIN(yEnd, cy + (1<<Rasterizer::Y_BITS)) - 1) & Rasterizer::Y_MASK;
}
RI_INLINE static void applyLeftEdge(const Rasterizer::ActiveEdge& currAe, Rasterizer::Windings& scanline, int intY)
{
// Applies the whole edge at a time. Make sure xRight < x for all y.
// \todo Remove duplicate code for determining the active samples
#if defined(USE_SSE2)
int py0, py1;
getVerticalSubpixels(intY, currAe.yStart, currAe.yEnd, py0, py1);
const __m128i csteps = _mm_set_epi16(7,6,5,4,3,2,1,0);
const __m128i ssePy0 = _mm_set1_epi16(py0-1);
const __m128i ssePy1 = _mm_set1_epi16(py1+1);
const __m128i yMask = _mm_and_si128(_mm_cmpgt_epi16(csteps, ssePy0), _mm_cmplt_epi16(csteps, ssePy1));
const __m128i dir = _mm_set1_epi16(currAe.direction);
scanline.sseWinding = _mm_add_epi16(scanline.sseWinding, _mm_and_si128(yMask, dir));
#else
RI_ASSERT(false); // Not implemented yet.
#endif
}
RI_INLINE static void applyLeftEdgeNoAA(const Rasterizer::ActiveEdge& currAe, Rasterizer::Windings& scanline, int intY)
{
// Applies the whole edge at a time. Make sure xRight < x for all y.
// \todo Remove duplicate code for determining the active samples?
#if defined(USE_SSE2)
int py0, py1;
getVerticalSubpixels(intY, currAe.yStart, currAe.yEnd, py0, py1);
//const __m128i csteps = _mm_set_epi16(4,4,4,4,4,4,4,4);
__m128i yMask;
if (py0 <= 4 && py1 >= 4)
yMask = _mm_set1_epi8(-1);
else
yMask = _mm_set1_epi8(0);
const __m128i dir = _mm_set1_epi16(currAe.direction);
scanline.sseWinding = _mm_add_epi16(scanline.sseWinding, _mm_and_si128(yMask, dir));
//scanline.sseWinding = _mm_add_epi32(scanline.sseWinding, dir);
#else
RI_ASSERT(false); // Not implemented yet.
#endif
}
RI_INLINE void calculateAEWinding(const Rasterizer::ActiveEdge& currAe, Rasterizer::Windings& pixel, Rasterizer::Windings& scanline, int intY, int pixelX)
{
#define QUEEN_COORD(Y) ((Y<<(Rasterizer::RASTERIZER_BITS - Rasterizer::SAMPLE_BITS)) + (1<<(Rasterizer::RASTERIZER_BITS-Rasterizer::SAMPLE_BITS-1)))
#if !defined(USE_SSE2)
static const int queenCoords[(1<<Rasterizer::SAMPLE_BITS)] = {
QUEEN_COORD(3), QUEEN_COORD(7), QUEEN_COORD(0), QUEEN_COORD(2),
QUEEN_COORD(5), QUEEN_COORD(1), QUEEN_COORD(6), QUEEN_COORD(4)
};
const int ix = pixelX >> Rasterizer::RASTERIZER_BITS;
const int cy = intY << Rasterizer::Y_BITS;
const int py0 = cy > currAe.yStart ? 0 : currAe.yStart & Rasterizer::Y_MASK;
const int py1 = (RI_INT_MIN(currAe.yEnd, cy + (1<<Rasterizer::Y_BITS)) - 1) & Rasterizer::Y_MASK;
int edgeX = currAe.xRef + (cy + py0 - (currAe.yStart & ~Rasterizer::Y_MASK)) * currAe.slope;
RI_ASSERT(py1 >= py0);
for (int s = py0; s <= py1; s++)
{
const int sampleX = pixelX + queenCoords[s];
//compute winding number by evaluating the edge functions of edges to the left of the sampling point
if(((edgeX >> Rasterizer::RASTERIZER_BITS) == ix))
{
if (sampleX >= edgeX)
{
pixel.winding[s] += currAe.direction;
}
scanline.winding[s] += currAe.direction;
}
edgeX += currAe.slope;
}
#else
__m128i qCoords = _mm_set_epi16(
QUEEN_COORD(4), QUEEN_COORD(6), QUEEN_COORD(1), QUEEN_COORD(5),
QUEEN_COORD(2), QUEEN_COORD(0), QUEEN_COORD(7), QUEEN_COORD(3));
RI_ASSERT(Rasterizer::RASTERIZER_BITS <= 14);
// TEROP: Optimize conditions.
int py0, py1;
getVerticalSubpixels(intY, currAe.yStart, currAe.yEnd, py0, py1);
const int cy = intY << Rasterizer::Y_BITS;
const __m128i csteps0 = _mm_set_epi32(3,2,1,0);
const __m128i csteps1 = _mm_set_epi32(7,6,5,4);
const __m128i ssePy0 = _mm_set1_epi32(py0-1);
const __m128i ssePy1 = _mm_set1_epi32(py1+1);
const __m128i yMask0 = _mm_and_si128(_mm_cmpgt_epi32(csteps0, ssePy0), _mm_cmplt_epi32(csteps0, ssePy1));
const __m128i yMask1 = _mm_and_si128(_mm_cmpgt_epi32(csteps1, ssePy0), _mm_cmplt_epi32(csteps1, ssePy1));
const int edgeX = currAe.xRef + (cy - (currAe.yStart & ~Rasterizer::Y_MASK)) * currAe.slope;
const __m128i xStart = _mm_set1_epi32(edgeX - pixelX);
const __m128i xs0 = _mm_set1_epi32(currAe.slope);
__m128i xAdd0 = mm_mul4x32(xs0, csteps0);
__m128i xAdd1 = mm_mul4x32(xs0, csteps1);
__m128i coords0 = _mm_add_epi32(xStart, xAdd0);
__m128i coords1 = _mm_add_epi32(xStart, xAdd1);
__m128i coords = _mm_packs_epi32(coords0, coords1);
__m128i dir = _mm_set1_epi16(currAe.direction);
__m128i yMask = _mm_packs_epi32(yMask0, yMask1);
__m128i mDir = _mm_and_si128(dir, yMask);
__m128i sampleCoords = qCoords;
__m128i sw, pw;
mm_get_xmasks(coords, sampleCoords, sw, pw);
pixel.sseWinding = _mm_add_epi16(pixel.sseWinding, _mm_and_si128(pw, mDir));
scanline.sseWinding = _mm_add_epi16(scanline.sseWinding, _mm_and_si128(sw, mDir));
#endif
#undef QUEEN_COORD
}
/**
* \brief Calculate winding using one sample only.
* \note This uses most of the same code as the AA-case even though it is not
* necessary (one sample would be enough).
*/
RI_INLINE void calculateAEWindingNoAA(const Rasterizer::ActiveEdge& currAe, Rasterizer::Windings& pixel, Rasterizer::Windings& scanline, int intY, int pixelX)
{
#if defined(USE_SSE2)
#define QUEEN_COORD(Y) ((Y<<(Rasterizer::RASTERIZER_BITS - Rasterizer::SAMPLE_BITS)) + (1<<(Rasterizer::RASTERIZER_BITS-Rasterizer::SAMPLE_BITS-1)))
const int half = 1<<(Rasterizer::RASTERIZER_BITS-1);
__m128i sampleCoords = _mm_set1_epi16(half);
RI_ASSERT(Rasterizer::RASTERIZER_BITS <= 14);
const int cy = intY << Rasterizer::Y_BITS;
int py0, py1;
getVerticalSubpixels(intY, currAe.yStart, currAe.yEnd, py0, py1);
__m128i yMask;
if (py0 <= 4 && py1 >= 4)
yMask = _mm_set1_epi8(-1);
else
yMask = _mm_set1_epi8(0);
const __m128i csteps0 = _mm_set_epi32(4,4,4,4);
const __m128i csteps1 = _mm_set_epi32(4,4,4,4);
const int edgeX = currAe.xRef + (cy - (currAe.yStart & ~Rasterizer::Y_MASK)) * currAe.slope;
const __m128i xStart = _mm_set1_epi32(edgeX - pixelX);
const __m128i xs0 = _mm_set1_epi32(currAe.slope);
__m128i xAdd0 = mm_mul4x32(xs0, csteps0);
__m128i xAdd1 = mm_mul4x32(xs0, csteps1);
__m128i coords0 = _mm_add_epi32(xStart, xAdd0);
__m128i coords1 = _mm_add_epi32(xStart, xAdd1);
__m128i coords = _mm_packs_epi32(coords0, coords1);
__m128i dir = _mm_set1_epi16(currAe.direction);
__m128i mDir = _mm_and_si128(dir, yMask);
//__m128i mDir = dir;
__m128i sw, pw;
mm_get_xmasks(coords, sampleCoords, sw, pw);
pixel.sseWinding = _mm_add_epi16(pixel.sseWinding, _mm_and_si128(pw, mDir));
scanline.sseWinding = _mm_add_epi16(scanline.sseWinding, _mm_and_si128(sw, mDir));
#undef QUEEN_COORD
#else
RI_ASSERT(false); // Not implemented.
#endif
}
#if defined(USE_SSE2)
RI_INLINE static int mm_winding_to_coverage(const Rasterizer::Windings& pixel, int fillRuleMask)
{
// This version uses SSE2 counters.
__m128i mask = _mm_set1_epi16(fillRuleMask);
__m128i t = _mm_and_si128(mask, pixel.sseWinding);
__m128i z = _mm_setzero_si128();
__m128i isz = _mm_cmpeq_epi16(t, z);
__m128i ones = _mm_set1_epi16(1);
__m128i res = _mm_add_epi16(ones, isz);
__m128i add0 = _mm_add_epi16(res, _mm_shuffle_epi32(res, _MM_SHUFFLE(2, 3, 2, 3)));
__m128i add1 = _mm_add_epi16(add0, _mm_shuffle_epi32(add0, _MM_SHUFFLE(1, 1, 1, 1)));
__m128i add2 = _mm_add_epi16(add1, _mm_shufflelo_epi16(add1, _MM_SHUFFLE(1, 1, 1, 1)));
int nSamples = _mm_cvtsi128_si32(add2) & 0xff;
return nSamples;
}
#endif
#define RI_DEBUG
#if defined(RI_DEBUG)
void maybeDumpEdges(Array<Rasterizer::ActiveEdge> &edgePool)
{
return;
// \note This gives an idea about the edges at the rasterization stage.
// Input edges must be output at a different stage.
RI_PRINTF("lines = []\n");
for (int i = 0 ; i < edgePool.size(); i++)
{
const int slope = edgePool[i].slope;
int x0, x1, y0, y1;
y0 = edgePool[i].yStart;
y1 = edgePool[i].yEnd;
x0 = edgePool[i].xRef + (slope * (y0 & Rasterizer::Y_MASK));
x1 = (edgePool[i].xRef + (slope * (y1 - (y0 & ~Rasterizer::Y_MASK))))>>(Rasterizer::RASTERIZER_BITS-Rasterizer::X_BITS);
RI_PRINTF("lines += [[%d, %d], [%d, %d]]\n",x0>>(Rasterizer::RASTERIZER_BITS-Rasterizer::X_BITS),y0,x1,y1);
}
}
#endif
/*-------------------------------------------------------------------*//*!
* \brief Calls PixelPipe::pixelPipe for each pixel with coverage greater
* than zero.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/
void Rasterizer::fill()
{
if(m_scissor && !m_scissorEdges.size())
return; //scissoring is on, but there are no scissor rectangles => nothing is visible
int firstAe = 0;
//proceed scanline by scanline
//keep track of edges that can intersect the pixel filters of the current scanline (Active Edge Table)
//until all pixels of the scanline have been processed
// for all sampling points of the current pixel
// determine the winding number using edge functions
// add filter weight to coverage
// divide coverage by the number of samples
// determine a run of pixels with constant coverage
// call fill callback for each pixel of the run
const int fillRuleMask = m_fillRuleMask;
int bbminx = (m_edgeMin.x >> X_BITS);
int bbminy = (m_edgeMin.y >> Y_BITS);
int bbmaxx = (m_edgeMax.x >> X_BITS)+1;
int bbmaxy = (m_edgeMax.y >> Y_BITS)+1;
int sx = RI_INT_MAX(m_vpx, bbminx);
int ex = RI_INT_MIN(m_vpx+m_vpwidth, bbmaxx);
int sy = RI_INT_MAX(m_vpy, bbminy);
int ey = RI_INT_MIN(m_vpy+m_vpheight, bbmaxy);
if(sx < m_covMinx) m_covMinx = sx;
if(sy < m_covMiny) m_covMiny = sy;
if(ex > m_covMaxx) m_covMaxx = ex;
if(ey > m_covMaxy) m_covMaxy = ey;
#if 0
// Dump edges:
static bool dump = true;
if (dump)
{
RI_PRINTF("lines = []\n");
for (int ie = 0; dump && ie < m_edgePool.size(); ie++)
{
RI_PRINTF("lines += [[%d, %d], [%d, %d]]\n",m_edgePool[ie].v0.x, m_edgePool[ie].v0.y, m_edgePool[ie].v1.x, m_edgePool[ie].v1.y);
}
dump = false;
}
#endif
int debugMagic = 0;
m_aet.clear();
#if defined(RI_DEBUG)
maybeDumpEdges(m_edgePool);
#endif
//fill the screen
for(int j = sy; j < ey; j++)
{
Windings scanlineWinding;
const int cminy = j << Y_BITS;
if (m_scissor)
{
// Gather scissor edges intersecting this scanline
// \todo Don't clear, remove unused instead!
m_scissorAet.clear();
for(int e = 0; e < m_scissorEdges.size(); e++)
{
const ScissorEdge& se = m_scissorEdges[e];
if(j >= se.miny && j < se.maxy)
m_scissorAet.push_back(m_scissorEdges[e]); //throws bad_alloc
}
//sort scissor AET by edge x
if (m_scissor)
m_scissorAet.sort();
}
// Drop unused edges, update remaining.
// \todo Combine with full sweep. Use a sort-friendly edge-discard.
for (int iae = firstAe; iae < m_aet.size(); iae++)
{
ActiveEdge& ae = m_aet[iae];
if (cminy >= ae.yEnd)
{
m_aet[iae] = m_aet[firstAe];
firstAe++;
continue;
}
/* Update existing coordinates */
// \todo AND instead of shift. See other places also.
const int y0 = (ae.yStart & ~Y_MASK);
const int x = ae.xRef + ((j << Y_BITS) - y0) * ae.slope;
ae.minx = x >> RASTERIZER_BITS;
ae.maxx = (x + ae.slope * (1<<Y_BITS)) >> RASTERIZER_BITS;
if (ae.minx > ae.maxx)
RI_ANY_SWAP(ActiveEdge::XCoord, ae.minx, ae.maxx);
// If the edge is not visible, "mark" it as immediately applicable
// \todo Verify that this is the correct procedure.
if (ae.maxx < 0)
ae.minx = ae.maxx = LEFT_DISCARD_SHORT;
}
/* Add new edges */
RIuint32 aeIndex = m_edges[j];
while (aeIndex != EDGE_TERMINATOR)
{
const ActiveEdge& ae = m_edgePool[aeIndex];
m_aet.push_back(ae); // \todo Just copy pointers?
aeIndex = ae.next;
}
if (firstAe >= m_aet.size())
{
RI_ASSERT(firstAe == m_aet.size());
continue; //no edges on the whole scanline, skip it
}
//sort AET by edge minx
m_aet.sort(firstAe, m_aet.size() - 1);
// \todo Optimize adding and updating the edges?
if (m_scissor && !m_scissorAet.size())
continue; // Scissoring is on, but there are no scissor rectangles on this scanline.
//fill the scanline
int scissorWinding = m_scissor ? 0 : 1; //if scissoring is off, winding is always 1
int scissorIndex = 0;
int aes = firstAe;
int aen = firstAe;
RI_ASSERT(sx >= 0);
#if 1
if (m_aa)
{
while ((aen < m_aet.size()) && (m_aet[aen].maxx < 0))
{
applyLeftEdge(m_aet[aen], scanlineWinding, j);
aen++;
}
}
else
{
while ((aen < m_aet.size()) && (m_aet[aen].maxx < 0))
{
applyLeftEdgeNoAA(m_aet[aen], scanlineWinding, j);
aen++;
}
}
#if defined(RI_DEBUG)
for (int a = aen; a < m_aet.size(); a++)
{
RI_ASSERT(m_aet[a].maxx >= 0);
}
#endif
#endif
// \todo Combine this with the first check or reorganize the "clipping".
if (aen >= m_aet.size())
continue; // No edges within viewport. Can happen atm. when all edges are "left".
for(int i = sx; i < ex;)
{
//find edges that intersect or are to the left of the pixel antialiasing filter
while(aes < m_aet.size() && (i + 1) >= m_aet[aes].minx)
aes++;
//edges [0,aes[ may have an effect on winding, and need to be evaluated while sampling
// RIint8 winding[SF_SAMPLES];
Windings pixelWinding;
pixelWinding = scanlineWinding;
if (m_aa)
{
for(int e = aen; e < aes; e++)
{
const ActiveEdge& currAe = m_aet[e];
calculateAEWinding(currAe, pixelWinding, scanlineWinding, j, i << RASTERIZER_BITS);
}
}
else
{
for(int e = aen; e < aes; e++)
{
const ActiveEdge& currAe = m_aet[e];
calculateAEWindingNoAA(currAe, pixelWinding, scanlineWinding, j, i << RASTERIZER_BITS);
}
}
//compute coverage
int coverageSamples = 0;
#if !defined(USE_SSE2)
for (int s = 0; s < SF_SAMPLES; s++)
{
if(pixelWinding.winding[s])
{
coverageSamples++;
}
}
#else
coverageSamples = mm_winding_to_coverage(pixelWinding, fillRuleMask);
_mm_empty();
#endif
//constant coverage optimization:
//scan AET from left to right and skip all the edges that are completely to the left of the pixel filter.
//since AET is sorted by minx, the edge we stop at is the leftmost of the edges we haven't passed yet.
//if that edge is to the right of this pixel, coverage is constant between this pixel and the start of the edge.
while(aen < m_aet.size() && m_aet[aen].maxx < i)
aen++;
int endSpan = m_vpx + m_vpwidth; // endSpan is the first pixel NOT part of the span
if(aen < m_aet.size())
{
endSpan = RI_INT_MAX(i+1, RI_INT_MIN(endSpan, m_aet[aen].minx));
}
//fill a run of pixels with constant coverage
if(coverageSamples)
{
if (!m_scissor)
{
int fillStartX = i; /* Inclusive */
pushSpan(fillStartX, j, (endSpan - fillStartX), coverageSamples);
}
else // (scissor)
{
int fillStartX = i;
//update scissor winding number
/* \todo Sort the scissor edges and skip unnecessary checks when scissors are used */
while (scissorIndex < m_scissorAet.size() && m_scissorAet[scissorIndex].x <= fillStartX)
{
scissorWinding += m_scissorAet[scissorIndex++].direction;
}
while (!scissorWinding && scissorIndex < m_scissorAet.size() && m_scissorAet[scissorIndex].x < endSpan)
{
fillStartX = m_scissorAet[scissorIndex].x;
scissorWinding += m_scissorAet[scissorIndex++].direction;
RI_ASSERT(fillStartX >= i);
}
RI_ASSERT(scissorWinding >= 0);
int endScissorSpan = endSpan;
while (scissorWinding && fillStartX < endSpan && (scissorIndex < m_scissorAet.size()))
{
// Determine the end of renderable area:
while (scissorWinding && scissorIndex < m_scissorAet.size() && m_scissorAet[scissorIndex].x <= endSpan)
{
endScissorSpan = m_scissorAet[scissorIndex].x;
scissorWinding += m_scissorAet[scissorIndex++].direction;
}
RI_ASSERT(fillStartX >= i);
RI_ASSERT(endScissorSpan <= endSpan);
pushSpan(fillStartX, j, (endScissorSpan - fillStartX), coverageSamples);
fillStartX = endScissorSpan;
endScissorSpan = endSpan;
// Skip until within drawable area
while (!scissorWinding && scissorIndex < m_scissorAet.size() && m_scissorAet[scissorIndex].x < endSpan)
{
fillStartX = m_scissorAet[scissorIndex].x;
scissorWinding += m_scissorAet[scissorIndex++].direction;
}
}
}
}
i = endSpan;
}
}
commitSpans();
#if defined(USE_SSE2)
_mm_empty();
#endif
clear();
}
RI_INLINE void Rasterizer::commitSpans()
{
if (!m_nSpans)
return;
m_pixelPipe->fillSpans(m_ppVariants, m_spanCache, m_nSpans);
m_nSpans = 0;
}
RI_INLINE void Rasterizer::pushSpan(int x, int y, int len, int coverage)
{
//printf("x: %d, y: %d, len: %d, coverage: %d\n", x, y, len, coverage);
// \todo Check what causes this with scissors
if (len <= 0) return;
//RI_ASSERT(len > 0);
Span& span = m_spanCache[m_nSpans];
span.x0 = x;
span.y = y;
span.len = (RIuint16)len;
span.coverage = coverage;
m_nSpans++;
if (m_nSpans == N_CACHED_SPANS)
{
commitSpans();
}
}
//=======================================================================
} //namespace OpenVGRI