#ifndef __RIRASTERIZER_H

#define __RIRASTERIZER_H

/*------------------------------------------------------------------------

 *

 * OpenVG 1.1 Reference Implementation

 * -----------------------------------

 *

 * Copyright (c) 2007 The Khronos Group Inc.

 *

 * 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

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

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;

};

/*-------------------------------------------------------------------*//*!

* \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, RIuint32* covBuffer);

	void		setScissor(const Array<Rectangle>& scissors);	//throws bad_alloc

	void		clear();

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

	int         setupSamplingPattern(VGRenderingQuality renderingQuality, int numFSAASamples);

	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; }

private:

	Rasterizer(const Rasterizer&);						//!< Not allowed.

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

	struct ScissorEdge

	{

		ScissorEdge() : x(0), miny(0), maxy(0), direction(0) {}

		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() : v0(), v1(), direction(1) {}

		bool operator<(const Edge& e) const	{ return v0.y < e.v0.y; }

		RVector2	v0;

		RVector2	v1;

		int			direction;

	};

	struct ActiveEdge

	{

		ActiveEdge() : v0(), v1(), direction(0), minx(0.0f), maxx(0.0f), n(), cnst(0.0f) {}

		bool operator<(const ActiveEdge& e) const	{ return minx < e.minx; }

		RVector2	v0;

		RVector2	v1;

		int			direction;		//-1 down, 1 up

		RScalar		minx;			//for the current scanline

		RScalar		maxx;			//for the current scanline

		RVector2	n;

		RScalar		cnst;

	};

	struct Sample

	{

		Sample() : x(0.0f), y(0.0f), weight(0.0f) {}

		RScalar		x;

		RScalar		y;

		RScalar		weight;

	};

    void                addBBox(const Vector2& v);

	Array<Edge>				m_edges;

	Array<ScissorEdge>		m_scissorEdges;

	bool					m_scissor;

	Sample				m_samples[RI_MAX_SAMPLES];

	int					m_numSamples;

	int					m_numFSAASamples;

	RScalar				m_sumWeights;

	RScalar				m_sampleRadius;

    Vector2             m_edgeMin;

    Vector2             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;

    VGFillRule          m_fillRule;

    const PixelPipe*    m_pixelPipe;

    RIuint32*           m_covBuffer;

};

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

}	//namespace OpenVGRI

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

#endif /* __RIRASTERIZER_H */