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

 *

 * 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 Paint and pixel pipe functionality.

 * \note

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

#ifndef __RIPIXELPIPE_H

#   include "riPixelPipe.h"

#endif

#ifndef __RIRASTERIZER_H

#   include "riRasterizer.h"

#endif

#ifndef __SFDYNAMICPIXELPIPE_H

#   include "sfDynamicPixelPipe.h"

#endif

#ifndef __SFCOMPILER_H

#   include "sfCompiler.h"

#endif

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

namespace OpenVGRI

{

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

* \brief    Paint constructor.

* \param

* \return

* \note

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

Paint::Paint() :

    m_paintType(VG_PAINT_TYPE_COLOR),

    m_paintColor(0,0,0,1,Color::sRGBA_PRE),

    m_inputPaintColor(0,0,0,1,Color::sRGBA),

    m_colorRampSpreadMode(VG_COLOR_RAMP_SPREAD_PAD),

    m_colorRampStops(),

    m_inputColorRampStops(),

    m_colorRampPremultiplied(VG_TRUE),

    m_inputLinearGradientPoint0(0,0),

    m_inputLinearGradientPoint1(1,0),

    m_inputRadialGradientCenter(0,0),

    m_inputRadialGradientFocalPoint(0,0),

    m_inputRadialGradientRadius(1.0f),

    m_linearGradientPoint0(0,0),

    m_linearGradientPoint1(1,0),

    m_radialGradientCenter(0,0),

    m_radialGradientFocalPoint(0,0),

    m_radialGradientRadius(1.0f),

    m_patternTilingMode(VG_TILE_FILL),

    m_pattern(NULL),

    m_referenceCount(0),

    m_lutFormat((VGImageFormat)-1),

    m_gradientStopsChanged(true)

{

    Paint::GradientStop gs;

    gs.offset = 0.0f;

    gs.color.set(0,0,0,1,Color::sRGBA);

    m_colorRampStops.push_back(gs); //throws bad_alloc

    gs.offset = 1.0f;

    gs.color.set(1,1,1,1,Color::sRGBA);

    m_colorRampStops.push_back(gs); //throws bad_alloc

}

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

* \brief    Paint destructor.

* \param

* \return

* \note

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

Paint::~Paint()

{

    RI_ASSERT(m_referenceCount == 0);

    if(m_pattern)

    {

        m_pattern->removeInUse();

        if(!m_pattern->removeReference())

            RI_DELETE(m_pattern);

    }

}

static Color readStopColor(const Array<Paint::GradientStop>& colorRampStops, int i, VGboolean colorRampPremultiplied)

{

    RI_ASSERT(i >= 0 && i < colorRampStops.size());

    Color c = colorRampStops[i].color;

    RI_ASSERT(c.getInternalFormat() == Color::sRGBA);

    if(colorRampPremultiplied)

        c.premultiply();

    return c;

}

void Paint::setGradientStops(Array<GradientStop>& inputStops, Array<GradientStop>& stops)

{

    m_colorRampStops.swap(stops);

    m_inputColorRampStops.swap(inputStops);

    m_gradientStopsChanged = true;

}

void Paint::setLinearGradient(const Vector2& p0, const Vector2& p1)

{

    m_linearGradientPoint0 = p0;

    m_linearGradientPoint1 = p1;

}

void Paint::setRadialGradient(const Vector2& c, const Vector2& f, VGfloat r)

{

    m_radialGradientCenter = c;

    m_radialGradientFocalPoint = f;

    m_radialGradientRadius = r;

}

bool Paint::linearDegenerate() const

{

    return m_linearGradientPoint0 == m_linearGradientPoint1 ? true : false;

}

bool Paint::radialDegenerate() const

{

    return m_radialGradientRadius == 0.0f ? true : false;

}

/**

 * \brief   Returns either the VG_PAINT_COLOR, or evaluated gradient value when the

 *          gradient is degenerate.

 */

Color Paint::getSolidColor() const

{

    if (m_paintType == VG_PAINT_TYPE_PATTERN)

    {

        RI_ASSERT(m_pattern == NULL);

        return m_paintColor;

    }

    if (m_paintType == VG_PAINT_TYPE_COLOR)

        return m_paintColor;

    RI_ASSERT(linearDegenerate() || radialDegenerate());

    // Determine the color at the end of the gradient

    RIfloat gs, ge;

    if (m_colorRampSpreadMode == VG_COLOR_RAMP_SPREAD_PAD)

    {

        gs = 1.0f - 1/256.0f;

        ge = 1.0f;

    } else if (m_colorRampSpreadMode == VG_COLOR_RAMP_SPREAD_REPEAT)

    {

        gs = 0.0f;

        ge = 1/256.0f;

    } else

    {

        gs = 1.0f - 1/256.0f;

        ge = 1.0f;

    }

    Color c = integrateColorRamp(gs, ge);

    return c * 256.0f;

}

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

* \brief    Returns the average color within an offset range in the color ramp.

* \param

* \return

* \note

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

Color Paint::integrateColorRamp(RIfloat gmin, RIfloat gmax) const

{

    RI_ASSERT(gmin <= gmax);

    RI_ASSERT(gmin >= 0.0f && gmin <= 1.0f);

    RI_ASSERT(gmax >= 0.0f && gmax <= 1.0f);

    RI_ASSERT(m_colorRampStops.size() >= 2);   //there are at least two stops

    Color currC(0,0,0,0,m_colorRampPremultiplied ? Color::sRGBA_PRE : Color::sRGBA);

    if(gmin == 1.0f || gmax == 0.0f)

        return currC;

    int i = 0;

    for(; i < m_colorRampStops.size()-1; i++)

    {

        if(gmin >= m_colorRampStops[i].offset && gmin < m_colorRampStops[i+1].offset)

        {

            RIfloat s = m_colorRampStops[i].offset;

            RIfloat e = m_colorRampStops[i+1].offset;

            RI_ASSERT(s < e);

            RIfloat g = (gmin - s) / (e - s);

            Color sc = readStopColor(m_colorRampStops, i, m_colorRampPremultiplied);

            Color ec = readStopColor(m_colorRampStops, i+1, m_colorRampPremultiplied);

            Color rc = (1.0f-g) * sc + g * ec;

            //subtract the average color from the start of the stop to gmin

            Color dc = 0.5f*(gmin - s)*(sc + rc);

            currC -= dc; 

            break;

        }

    }

    for(;i < m_colorRampStops.size()-1; i++)

    {

        RIfloat s = m_colorRampStops[i].offset;

        RIfloat e = m_colorRampStops[i+1].offset;

        RI_ASSERT(s <= e);

        Color sc = readStopColor(m_colorRampStops, i, m_colorRampPremultiplied);

        Color ec = readStopColor(m_colorRampStops, i+1, m_colorRampPremultiplied);

        //average of the stop

        Color dc = 0.5f*(e-s)*(sc + ec);

        currC += dc; 

        if(gmax >= m_colorRampStops[i].offset && gmax < m_colorRampStops[i+1].offset)

        {

            RIfloat g = (gmax - s) / (e - s);

            Color rc = (1.0f-g) * sc + g * ec;

            //subtract the average color from gmax to the end of the stop

            dc = 0.5f*(e - gmax)*(rc + ec);

            currC -= dc;

            break;

        }

    }

    return currC;

}

/**

 * \brief   Generates gradient color-ramp lookup values.

 *

 * \param   targetFormat    Destination or image format to associate LUT with.

 * \patam   drawImage       true if paint is evaluated along drawImage.

 *

 * \note    Must be called prior to rendering, and after the destination

 *          format is known. The destination format is either destination 

 *          surface format, or the image format in case of image rendering

 *          operation.

 */

void Paint::generateLUT(PixelPipe& pipe, VGImageFormat preferredFormat)

{

    const RIfloat gstep = 1.0f / (GRADIENT_LUT_COUNT);

    const RIfloat rcp = (RIfloat)(GRADIENT_LUT_COUNT);

    RIfloat gsx;

    gsx = 0.0f;

    if (!pipe.colorTransformChanged() && !m_gradientStopsChanged && (preferredFormat == m_lutFormat))

        return; // Already in correct format

    const bool inputPremultiplied = m_colorRampPremultiplied == VG_TRUE ? true : false;

    // Colortransform premultiplies color.

    const Color::Descriptor srcDesc = Color::formatToDescriptorConst(

        inputPremultiplied || pipe.hasColorTransform() ? VG_sRGBA_8888_PRE : VG_sRGBA_8888);

    const Color::Descriptor dstDesc = Color::formatToDescriptorConst(preferredFormat);

    // Create a pre-calculated LUT.

    for (int i = 0; i < GRADIENT_LUT_COUNT; i++)

    {

        // \todo Open up the integrator and/or use also integers.

        Color c = integrateColorRamp(gsx, gsx + gstep);

        c *= rcp;

        // \todo Changing the mode must be tracked somehow!

        if (pipe.getImageMode() != VG_DRAW_IMAGE_MULTIPLY)

            pipe.colorTransform(c);

        IntegerColor ic = IntegerColor(c);

        ic.convertToFrom(dstDesc, srcDesc, false);

        m_gradientLUT[i] = ic;

        gsx += gstep;

    }

    m_gradientStopsChanged = false;

    m_lutFormat = Color::descriptorToVGImageFormat(dstDesc);

    pipe.setColorTransformChanged(false);

    RI_ASSERT(m_lutFormat == preferredFormat);

}

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

* \brief    PixelPipe constructor.

* \param

* \return

* \note

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

PixelPipe::PixelPipe() :

    m_drawable(NULL),

    m_image(NULL),

    m_paint(NULL),

    m_defaultPaint(),

    m_blendMode(VG_BLEND_SRC_OVER),

    m_imageMode(VG_DRAW_IMAGE_NORMAL),

    m_imageQuality(VG_IMAGE_QUALITY_FASTER),

    m_tileFillColor(0,0,0,0,Color::sRGBA),

    m_colorTransform(false),

    m_colorTransformValues(),

    m_iColorTransformValues(),

    m_surfaceToPaintMatrix(),

    m_surfaceToImageMatrix(),

    m_paintToSurfaceMatrix(),

    m_maskOperation(VG_SET_MASK),

    m_renderToMask(false),

    m_colorTransformChanged(true)

{

    for(int i=0;i<8;i++)

    {

        m_colorTransformValues[i] = (i < 4) ? 1.0f : 0.0f;

        m_iColorTransformValues[i] = (i < 4) ? (COLOR_TRANSFORM_ONE) : 0;

    }

}

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

* \brief    PixelPipe destructor.

* \param

* \return

* \note

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

PixelPipe::~PixelPipe()

{

}

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

* \brief    Sets the rendering surface.

* \param

* \return

* \note

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

void PixelPipe::setDrawable(Drawable* drawable)

{

    RI_ASSERT(drawable);

    m_drawable = drawable;

}

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

* \brief    Sets the blend mode.

* \param

* \return

* \note

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

void PixelPipe::setBlendMode(VGBlendMode blendMode)

{

    RI_ASSERT(blendMode >= VG_BLEND_SRC && blendMode <= VG_BLEND_ADDITIVE);

    m_blendMode = blendMode;

}

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

* \brief    Sets the mask image. NULL disables masking.

* \param

* \return

* \note

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

void PixelPipe::setMask(bool masking)

{

    m_masking = masking;

}

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

* \brief    Sets the image to be drawn. NULL disables image drawing.

* \param

* \return

* \note

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

void PixelPipe::setImage(Image* image, VGImageMode imageMode)

{

    RI_ASSERT(imageMode == VG_DRAW_IMAGE_NORMAL || imageMode == VG_DRAW_IMAGE_MULTIPLY || imageMode == VG_DRAW_IMAGE_STENCIL);

    m_image = image;

    m_imageMode = imageMode;

}

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

* \brief    Sets the surface-to-paint matrix.

* \param

* \return

* \note

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

void PixelPipe::setSurfaceToPaintMatrix(const Matrix3x3& surfaceToPaintMatrix)

{

    m_surfaceToPaintMatrix = surfaceToPaintMatrix;

}

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

* \brief    Sets the surface-to-image matrix.

* \param

* \return

* \note

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

void PixelPipe::setSurfaceToImageMatrix(const Matrix3x3& surfaceToImageMatrix)

{

    m_surfaceToImageMatrix = surfaceToImageMatrix;

}

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

* \brief    Sets image quality.

* \param

* \return

* \note

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

void PixelPipe::setImageQuality(VGImageQuality imageQuality)

{

    RI_ASSERT(imageQuality == VG_IMAGE_QUALITY_NONANTIALIASED || imageQuality == VG_IMAGE_QUALITY_FASTER || imageQuality == VG_IMAGE_QUALITY_BETTER);

    m_imageQuality = imageQuality;

}

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

* \brief    Sets fill color for VG_TILE_FILL tiling mode (pattern only).

* \param

* \return

* \note

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

void PixelPipe::setTileFillColor(const Color& c)

{

    m_tileFillColor = c;

    m_tileFillColor.clamp();

}

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

* \brief    Sets paint.

* \param

* \return

* \note

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

void PixelPipe::setPaint(Paint* paint)

{

    // \temp Only call this right before filling a polygon.

    m_paint = paint;

    if(!m_paint)

        m_paint = &m_defaultPaint;

    if(m_paint->m_pattern)

        m_tileFillColor.convert(m_paint->m_pattern->getDescriptor().internalFormat);

}

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

* \brief    Color transform.

* \param

* \return

* \note

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

void PixelPipe::setColorTransform(bool enable, RIfloat values[8])

{

    m_colorTransform = enable;

    for(int i=0;i<4;i++)

    {

        m_colorTransformValues[i] = RI_CLAMP(values[i], -127.0f, 127.0f);

        m_colorTransformValues[i+4] = RI_CLAMP(values[i+4], -1.0f, 1.0f);

        m_iColorTransformValues[i] = RI_ROUND_TO_INT(m_colorTransformValues[i]*(RIfloat)COLOR_TRANSFORM_ONE);

        m_iColorTransformValues[i+4] = RI_ROUND_TO_INT(m_colorTransformValues[i+4]*255.0f);

    }

    m_colorTransformChanged = true;