#ifndef __RIPIXELPIPE_H
#define __RIPIXELPIPE_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	Paint and PixelPipe classes.
 * \note
 *//*-------------------------------------------------------------------*/

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

#ifndef __RIIMAGE_H
#include "riImage.h"
#endif

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

namespace OpenVGRI
{

struct Span;
class PPCompiler;
class PixelPipe;

/*-------------------------------------------------------------------*//*!
* \brief	Storage and operations for VGPaint.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/

class Paint
{
public:
    enum { GRADIENT_LUT_BITS = 8 };
    enum { GRADIENT_LUT_COUNT = 1 << GRADIENT_LUT_BITS };
    enum { GRADIENT_LUT_MASK = (1<<GRADIENT_LUT_BITS)-1 };

    struct GradientStop
    {
        GradientStop() : offset(0.0f), color(0.0f, 0.0f, 0.0f, 0.0f, Color::sRGBA) {}
        RIfloat		offset;
        Color		color;
    };

public:
    Paint();
    ~Paint();
    void					addReference()							{ m_referenceCount++; }
    int						removeReference()						{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }
    void                    setColor(const Color& color) {m_paintColor = color; m_paintColor.clamp(); m_paintColor.premultiply(); }
    void                    setGradientStops(Array<GradientStop>& inputStops, Array<GradientStop>& stops);
    void                    generateLUT(PixelPipe& pipe, VGImageFormat targetFormat);
    const IntegerColor*     getGradientLUT() const { return m_gradientLUT; }
    void                    setLinearGradient(const Vector2& p0, const Vector2& p1);
    void                    setRadialGradient(const Vector2& c, const Vector2& f, VGfloat r);
    bool                    linearDegenerate() const;
    bool                    radialDegenerate() const;
    Color                   getSolidColor() const;
    
    Color integrateColorRamp(RIfloat gmin, RIfloat gmax) const; // \todo Private after modifications.
    
public:
    VGPaintType				m_paintType;
    Color					m_paintColor;
    Color					m_inputPaintColor;
    VGColorRampSpreadMode	m_colorRampSpreadMode;
    Array<GradientStop>		m_colorRampStops;
    Array<GradientStop>		m_inputColorRampStops;
    VGboolean				m_colorRampPremultiplied;
    Vector2					m_inputLinearGradientPoint0;
    Vector2					m_inputLinearGradientPoint1;
    Vector2					m_inputRadialGradientCenter;
    Vector2					m_inputRadialGradientFocalPoint;
    RIfloat					m_inputRadialGradientRadius;
    Vector2					m_linearGradientPoint0;
    Vector2					m_linearGradientPoint1;
    Vector2					m_radialGradientCenter;
    Vector2					m_radialGradientFocalPoint;
    RIfloat					m_radialGradientRadius;
    VGTilingMode			m_patternTilingMode;
    Image*					m_pattern;
private:
    Paint(const Paint&);						//!< Not allowed.
    const Paint& operator=(const Paint&);		//!< Not allowed.

    int						m_referenceCount;
    IntegerColor            m_gradientLUT[GRADIENT_LUT_COUNT];
    VGImageFormat           m_lutFormat;
    bool                    m_gradientStopsChanged;
    bool                    m_gradientDegenerate;
};

/*-------------------------------------------------------------------*//*!
* \brief	Encapsulates all information needed for painting a pixel.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/

#define RGRAD_FLOATS
#if defined(RGRAD_FLOATS)
typedef RIfloat RGScalar;
#else
typedef double RGScalar;
#endif

class PixelPipe
{
public:
    enum SamplerType 
    {
        SAMPLER_TYPE_NEAREST    = 0,
        SAMPLER_TYPE_LINEAR     = 1,
        SAMPLER_TYPE_SIZE
    };
    
    enum TilingMode 
    {
        TILING_MODE_PAD         = 0,
        TILING_MODE_REPEAT      = 1,
        TILING_MODE_REFLECT     = 2,
        TILING_MODE_FILL        = 3,
        TILING_MODE_SIZE
    };
    
    // Span per-pixel variants:
    struct PPVariants
    {
        void*       dst;
        void*       src;
        void*       maskPtr;
        int         coverage;

        RIuint32    dstX;

        RIint32     sx;
        RIint32     sy;

        RGScalar    rx;
        RGScalar    ry;

        // \todo Image sampling coordinates will be in fixed point if transform is affine,
        // in floating point if not.
        RGScalar    ix;
        RGScalar    iy;

        RIint32     iImageX;  
        RIint32     iImageY;
        RIfloat     fImageX;
        RIfloat     fImageY;
        RIfloat     fImageW;
    };
    
    // Uniform state per-pixel
    // \todo Organize into sub-structures?
    struct PPUniforms
    {
        // \todo Do not store pointers to classes, only atoms! It should make the
        // dynamic compilation a lot easier.
        void*           srcPtr;
        RIint32         srcStride;
        void*           dstPtr;
        RIint32         dstStride;
        void*           maskPtr;
        int             maskStride;
        void*           imagePtr;
        int             imageStride;
        void*           patternPtr;
        int             patternStride;
        const IntegerColor*   gradientLookup;
        const RIint32*        colorTransformValues;

        // Linear gradient
        RIint32         dgdx;
        RIint32         dgdy;
        RIint32         lgc;

        // Radial gradient
        RGScalar        rsqrp;
        RGScalar        rfxp;
        RGScalar        rfyp;
        RGScalar        rx0;
        RGScalar        ry0;
        RGScalar        rdxdx;
        RGScalar        rdxdy;
        RGScalar        rdydx;
        RGScalar        rdydy;

        // Pattern. Note that pattern and image may be used at the same time.
        RIint32         paint_width;
        RIint32         paint_height;
        RIint32         paint_x0;
        RIint32         paint_y0;
        RIint32         paint_dxdx;
        RIint32         paint_dxdy;
        RIint32         paint_dydx;
        RIint32         paint_dydy;

        // Image
        RIint32         image_iWidth;
        RIint32         image_iHeight;
        RIint32         image_ix0;
        RIint32         image_iy0;
        RIint32         image_idxdx;
        RIint32         image_idxdy;
        RIint32         image_idydx;
        RIint32         image_idydy;


        RIfloat         image_fWidth;
        RIfloat         image_fHeight;
        RIfloat         image_fx0;
        RIfloat         image_fy0;
        RIfloat         image_fw0;
        RIfloat         image_fdxdx;
        RIfloat         image_fdxdy;
        RIfloat         image_fdydx;
        RIfloat         image_fdydy;
        RIfloat         image_fdwdx;
        RIfloat         image_fdwdy;

        IntegerColor    tileFillColor;
        IntegerColor    solidColor;
        RIuint32        packedSolidColor;
    };

    enum ImageGradientType {
        GRADIENT_TYPE_INTEGER   = 0,
        GRADIENT_TYPE_FIXED     = 1,
        GRADIENT_TYPE_FLOAT     = 2,
        GRADIENT_TYPE_SIZE
    };

    // Signature state contains all the information necessary to compile
    // a pixel-pipeline. Note that some of these are actually derived.
    // \note REMEMBER TO UPDATE THE COMPILER. For now, there is now
    // automatic mechanism to propagate changes to that component!
    struct SignatureState
    {
        VGBlendMode         blendMode;
        VGImageMode         imageMode;
        VGPaintType         paintType;
        VGMaskOperation     maskOperation;
        TilingMode          paintTilingMode;
        SamplerType         paintSampler;
        SamplerType         imageSampler;

        ImageGradientType   imageGradientType;

        Color::Descriptor   dstDesc;
        Color::Descriptor   maskDesc;
        Color::Descriptor   imageDesc;
        Color::Descriptor   patternDesc;

        bool                hasMasking;
        bool                hasImage;
        bool                hasColorTransform;
        bool                isRenderToMask;
        bool                fillColorTransparent;
        // When using external data for rendering an image: This is the only case
        // where the data can be invalid in the pixel-pipe.
        bool                unsafeImageInput; 

    };

public:
    PixelPipe();	//throws bad_alloc
    ~PixelPipe();

    void	pixelPipe(int x, int y, RIuint32 coverage) const;	//rasterizer calls this function for each pixel
    void 	fillSolidSpan(int startX, int y, int nPixels) const;
    void	setDrawable(Drawable* drawable);
    void	setBlendMode(VGBlendMode blendMode);
    RI_INLINE VGBlendMode getBlendMode() const { return m_blendMode; }
    void    setRenderToMask(bool renderToMask) { m_renderToMask = renderToMask; }
    void    setMaskOperation(VGMaskOperation maskOperation) { m_maskOperation = maskOperation; }
    void	setMask(bool masking);
    void	setImage(Image* image, VGImageMode imageMode);	//image = NULL disables drawImage functionality
    void	setSurfaceToPaintMatrix(const Matrix3x3& surfaceToPaintMatrix);
    void	setSurfaceToImageMatrix(const Matrix3x3& surfaceToImageMatrix);
    void	setImageQuality(VGImageQuality imageQuality);
    void	setTileFillColor(const Color& c);
    void	setPaint(Paint* paint);
    void    setColorTransform(bool enable, RIfloat values[8]);
    bool    hasColorTransform() const { return m_colorTransform; }
    RI_INLINE const SignatureState& getSignatureState() const { return m_signatureState; }

    // Functions that determine parts of derived state.
    void    prepareSpanUniforms(bool aa);

    RI_INLINE VGPaintType getPaintType() const;
    RI_INLINE bool isMasking() const;
    void fillSpans(PPVariants& variants, const Span* spans, int nSpans) const;

    void    colorTransform(Color& c) const;
    void    setColorTransformChanged(bool changed) { m_colorTransformChanged = changed; } // make paint friend and this private!
    bool    colorTransformChanged() const { return m_colorTransformChanged; }
    RI_INLINE VGImageMode getImageMode() const { return m_imageMode; }

    RI_INLINE static bool isImageOnly(const SignatureState& state);

private:

    const Image*    getRenderTargetImage() const;
    VGImageFormat   getPreferredLUTFormat() const;

    void	prepareSolidFill();
    void    prepareCoverageFill();
    void    prepareLinearGradient();
    void    prepareRadialGradient();
    void    preparePattern();
    void    prepareImage(bool aa);
    void    prepareSignatureState();
    void    prepareRenderToMask();
    void	linearGradient(RIfloat& g, RIfloat& rho, RIfloat x, RIfloat y) const;
    void	radialGradient(RIfloat& g, RIfloat& rho, RIfloat x, RIfloat y) const;
    Color	colorRamp(RIfloat gradient, RIfloat rho) const;
    Color	blend(const Color& s, RIfloat ar, RIfloat ag, RIfloat ab, const Color& d, VGBlendMode blendMode) const;

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

    Drawable*               m_drawable;
    bool					m_masking;
    Image*					m_image;
    // \todo LUT within the paint class broke constness of paint.
    Paint*			        m_paint;
    Paint					m_defaultPaint;
    VGBlendMode				m_blendMode;
    VGImageMode				m_imageMode;
    VGImageQuality			m_imageQuality;
    Color					m_tileFillColor;
    bool                    m_colorTransform;
    RIfloat                 m_colorTransformValues[8];
    RIint32                 m_iColorTransformValues[8];
    Matrix3x3				m_surfaceToPaintMatrix;
    Matrix3x3				m_surfaceToImageMatrix;
    Matrix3x3               m_paintToSurfaceMatrix;
    VGMaskOperation         m_maskOperation;
    bool                    m_renderToMask;
    bool                    m_colorTransformChanged;

public:

    enum { COLOR_TRANSFORM_BITS = 8 };
    enum { COLOR_TRANSFORM_ONE = (1<<COLOR_TRANSFORM_BITS) };
    enum { COLOR_TRANSFORM_MASK = (COLOR_TRANSFORM_ONE - 1) };
    enum { GRADIENT_BITS = 16 };
    enum { GRADIENT_MASK = (1<<GRADIENT_BITS)-1 };
    enum { SAMPLE_BITS = 8 };
    enum { SAMPLE_MASK = (1<<SAMPLE_BITS)-1 };

private:


    SignatureState          m_signatureState;
    SignatureState          m_derivedState;

    PPUniforms  m_spanUniforms;
};

RI_INLINE VGPaintType PixelPipe::getPaintType() const
{
    if (m_paint->m_paintType == VG_PAINT_TYPE_COLOR)
        return VG_PAINT_TYPE_COLOR;

    if (m_paint->m_paintType == VG_PAINT_TYPE_PATTERN && !m_paint->m_pattern)
        return VG_PAINT_TYPE_COLOR;

    if (m_paint->m_paintType == VG_PAINT_TYPE_LINEAR_GRADIENT && m_paint->linearDegenerate())
        return VG_PAINT_TYPE_COLOR;

    if (m_paint->m_paintType == VG_PAINT_TYPE_RADIAL_GRADIENT && m_paint->radialDegenerate())
        return VG_PAINT_TYPE_COLOR;

    return m_paint->m_paintType;
}

RI_INLINE bool PixelPipe::isMasking() const
{
    return m_masking;
}

RI_INLINE /*static*/ bool PixelPipe::isImageOnly(const SignatureState& state)
{
    if (state.hasImage)
        return (state.imageMode == VG_DRAW_IMAGE_NORMAL) ? true : false;
    else
        return false;
}

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

}	//namespace OpenVGRI

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

#endif /* __RIPIXELPIPE_H */