#ifndef __RIRASTERIZER_H
#define __RIRASTERIZER_H

/*------------------------------------------------------------------------
 *
 * 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   Rasterizer class.
 * \note
 *//*-------------------------------------------------------------------*/

#ifndef __RIMATH_H
#include "riMath.h"
#endif

#ifndef __RIARRAY_H
#include "riArray.h"
#endif

#ifndef __RIPIXELPIPE_H
#include "riPixelPipe.h"
#endif

// TESTING ONLY!!
#include "sfDynamicPixelPipe.h"

#if defined(RI_DEBUG)
#    include <stdio.h>
#endif
// \todo SSE2 probably has everything necessary and matches the minimum platform requirements.
// SSE4 is probably too new. SSE3?
// \note This will cause the code to not compile on MSVC...
#define USE_SSE2

#if defined(USE_SSE2)
// \todo only the last include is needed: QT creator does not find types if others not included.
#   include <mmintrin.h>
#   include <xmmintrin.h>
#   include <emmintrin.h>
#endif

//=======================================================================

namespace OpenVGRI
{

/*-------------------------------------------------------------------*//*!
* \brief    Scalar and vector data types used by the rasterizer.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/

typedef RIfloat RScalar;    //change this if you want to have different precision for rasterizer scalars and RIfloat

struct RVector2
{
    RI_INLINE RVector2()                            { }
    RI_INLINE RVector2(const Vector2& v)            { x = v.x; y = v.y; }
    RI_INLINE RVector2(RIfloat vx, RIfloat vy)      { x = vx; y = vy; }
    RI_INLINE void set(RIfloat vx, RIfloat vy)      { x = vx; y = vy; }
    RScalar     x;
    RScalar     y;
};

struct IVector2
{
    RI_INLINE IVector2() {}
    RI_INLINE IVector2(const IVector2& v) { x = v.x; y = v.y; }
    RI_INLINE IVector2(const Vector2& v) { x = (int)v.x; y = (int) v.y; }
    RI_INLINE IVector2(int vx, int vy) { x = vx; y = vy; }
    RI_INLINE void set(int vx, int vy) { x = vx; y = vy; }
    int x;
    int y;
};

struct Span
{
    RIuint16 x0;
    RIuint16 y;
    RIuint16 len;
    RIuint8  coverage;
    RIuint8  pad; // align to 8 bytes. \temp Use qualifiers instead?
};

/*-------------------------------------------------------------------*//*!
* \brief    Converts a set of edges to coverage values for each pixel and
*           calls PixelPipe::pixelPipe for painting a pixel.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/

class Rasterizer
{
public:
    Rasterizer();   //throws bad_alloc
    ~Rasterizer();

    void        setup(int vpx, int vpy, int vpwidth, int vpheight, VGFillRule fillRule, const PixelPipe* pixelPipe);
    void        setScissor(const Array<Rectangle>& scissors);   //throws bad_alloc
    void        setScissoring(bool enabled);

    void        clear();
    void        addEdge(const Vector2& v0, const Vector2& v1);  //throws bad_alloc

    RI_INLINE void setAntiAliasing(bool enable) { m_aa = enable; }
    void        fill(); //throws bad_alloc

    void        getBBox(int& sx, int& sy, int& ex, int& ey) const       { sx = m_covMinx; sy = m_covMiny; ex = m_covMaxx; ey = m_covMaxy; }

public:
    enum { SAMPLE_BITS = 3 };
    enum { Y_BITS = SAMPLE_BITS };
    enum { MAX_COVERAGE = 1<<SAMPLE_BITS };

    // temp!:
    RIuint32    *m_covBuffer;
    size_t      m_covBufferSz;

private:
    Rasterizer(const Rasterizer&);                      //!< Not allowed.
    const Rasterizer& operator=(const Rasterizer&);     //!< Not allowed.

public:
    struct ScissorEdge
    {
        ScissorEdge() {}
        bool operator<(const ScissorEdge& e) const  { return x < e.x; }
        int         x;
        int         miny;
        int         maxy;
        int         direction;      //1 start, -1 end
    };

    struct Edge
    {
        Edge() {}
        bool operator<(const Edge& e) const { return v0.y < e.v0.y; }
#if defined(RI_DEBUG)
        bool operator<=(const Edge& e) const {return v0.y <= e.v0.y; }
#endif
        IVector2    v0;
        IVector2    v1;
        int         direction;
    };

    struct ActiveEdge
    {
        typedef RIint16 XCoord;
        typedef RIint16 YCoord;

        ActiveEdge() {}
        //bool operator<(const ActiveEdge& e) const   { return minx < e.minx; }
        bool operator<(const ActiveEdge& e) const
        {
            if (minx < e.minx)
                return true;
            if (minx == e.minx)
                return maxx < e.maxx;
            return false;
        }
#if defined(RI_DEBUG)
        bool operator<=(const ActiveEdge& e) const { return minx <= e.minx; }
#endif
        // Fixed-point edge coordinates.
        RIuint32 next; // \todo Pointer?
        int     direction;      //-1 down, 1 up
        int     xRef;
        int     slope;
        XCoord  minx;           // for the current scanline
        XCoord  maxx;           // for the current scanline
        YCoord  yStart;         // for the edge
        YCoord  yEnd;           // for the edge
    };

    enum { SF_SAMPLES = 8 };
    enum { RASTERIZER_BITS = 14 };
    enum { RASTERIZER_MASK = ((1<<RASTERIZER_BITS)-1) };
    enum { Y_MASK = ((1<<Y_BITS)-1) };
    enum { X_BITS = 7 };
    enum { XMASK  = ((1<<X_BITS)-1) };
    enum { LEFT_DISCARD = -0x100000 };
    enum { LEFT_DISCARD_SHORT = -32768 };

    struct Windings
    {
#if !defined(USE_SSE2)
        Windings() {wq = 0;}
        // \todo Use SSE counters or packed counters!
        // \todo 8 samples -> 64 bits == 2 32-bit uints
        union
        {
            RIint8              winding[SF_SAMPLES];
            RIuint32            wd[SF_SAMPLES/4];
            unsigned long long  wq;
        };
#else
        Windings() { sseWinding = _mm_setzero_si128(); }
        __m128i sseWinding;
#endif
     };

private:
    void                pushEdge(const Edge& edge);
    void                clipAndAddEdge(Edge& edge);
    void                addBBox(const IVector2& v);
    RI_INLINE void      pushSpan(int x, int y, int len, int coverage);
    RI_INLINE void      commitSpans();

    //RI_INLINE void      calculateAEWinding(const ActiveEdge& currAe, Windings& pixel, Windings& scanline, int intY, int pixelX);

    Array<ActiveEdge>   m_edgePool;
    Array<RIuint32>     m_edges;
    Array<ScissorEdge>  m_scissorEdges;
    Array<ActiveEdge>   m_aet;
    Array<ScissorEdge>  m_scissorAet;
    bool                m_scissor;

    bool                    m_aa;

    IVector2            m_edgeMin;
    IVector2            m_edgeMax;
    int                 m_covMinx;
    int                 m_covMiny;
    int                 m_covMaxx;
    int                 m_covMaxy;
    int                 m_vpx;
    int                 m_vpy;
    int                 m_vpwidth;
    int                 m_vpheight;
    int                 m_vpMinx;
    int                 m_vpMiny;
    int                 m_vpMaxx;
    int                 m_vpMaxy;
    VGFillRule          m_fillRule;
    RIuint32            m_fillRuleMask;

    const PixelPipe*        m_pixelPipe;
    PixelPipe::PPVariants   m_ppVariants;

    enum { N_CACHED_SPANS = 64 };
    Span                m_spanCache[N_CACHED_SPANS];
    int                 m_nSpans;

};

//=======================================================================

}   //namespace OpenVGRI

//=======================================================================

#endif /* __RIRASTERIZER_H */