1 /*------------------------------------------------------------------------

     2  *

     3  * OpenVG 1.1 Reference Implementation

     4  * -----------------------------------

     5  *

     6  * Copyright (c) 2007 The Khronos Group Inc.

     7  * Portions copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     8  *

     9  * Permission is hereby granted, free of charge, to any person obtaining a

    10  * copy of this software and /or associated documentation files

    11  * (the "Materials "), to deal in the Materials without restriction,

    12  * including without limitation the rights to use, copy, modify, merge,

    13  * publish, distribute, sublicense, and/or sell copies of the Materials,

    14  * and to permit persons to whom the Materials are furnished to do so,

    15  * subject to the following conditions:

    16  *

    17  * The above copyright notice and this permission notice shall be included

    18  * in all copies or substantial portions of the Materials.

    19  *

    20  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    23  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    24  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    25  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    26  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    27  *

    28  *//**

    29  * \file

    30  * \brief   Implementation of Paint and pixel pipe functionality.

    31  * \note

    32  *//*-------------------------------------------------------------------*/

    33 

    34 #ifndef __RIPIXELPIPE_H

    35 #   include "riPixelPipe.h"

    36 #endif

    37 #ifndef __RIRASTERIZER_H

    38 #   include "riRasterizer.h"

    39 #endif

    40 #ifndef __SFDYNAMICPIXELPIPE_H

    41 #   include "sfDynamicPixelPipe.h"

    42 #endif

    43 #ifndef __SFCOMPILER_H

    44 #   include "sfCompiler.h"

    45 #endif

    46 

    47 //==============================================================================================

    48 

    49 namespace OpenVGRI

    50 {

    51 

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

    53 * \brief    Paint constructor.

    54 * \param

    55 * \return

    56 * \note

    57 *//*-------------------------------------------------------------------*/

    58 

    59 Paint::Paint() :

    60     m_paintType(VG_PAINT_TYPE_COLOR),

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

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

    63     m_colorRampSpreadMode(VG_COLOR_RAMP_SPREAD_PAD),

    64     m_colorRampStops(),

    65     m_inputColorRampStops(),

    66     m_colorRampPremultiplied(VG_TRUE),

    67     m_inputLinearGradientPoint0(0,0),

    68     m_inputLinearGradientPoint1(1,0),

    69     m_inputRadialGradientCenter(0,0),

    70     m_inputRadialGradientFocalPoint(0,0),

    71     m_inputRadialGradientRadius(1.0f),

    72     m_linearGradientPoint0(0,0),

    73     m_linearGradientPoint1(1,0),

    74     m_radialGradientCenter(0,0),

    75     m_radialGradientFocalPoint(0,0),

    76     m_radialGradientRadius(1.0f),

    77     m_patternTilingMode(VG_TILE_FILL),

    78     m_pattern(NULL),

    79     m_referenceCount(0),

    80     m_lutFormat((VGImageFormat)-1),

    81     m_gradientStopsChanged(true)

    82 {

    83     Paint::GradientStop gs;

    84     gs.offset = 0.0f;

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

    86     m_colorRampStops.push_back(gs); //throws bad_alloc

    87     gs.offset = 1.0f;

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

    89     m_colorRampStops.push_back(gs); //throws bad_alloc

    90 }

    91 

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

    93 * \brief    Paint destructor.

    94 * \param

    95 * \return

    96 * \note

    97 *//*-------------------------------------------------------------------*/

    98 

    99 Paint::~Paint()

   100 {

   101     RI_ASSERT(m_referenceCount == 0);

   102     if(m_pattern)

   103     {

   104         m_pattern->removeInUse();

   105         if(!m_pattern->removeReference())

   106             RI_DELETE(m_pattern);

   107     }

   108 }

   109 

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

   111 {

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

   113     Color c = colorRampStops[i].color;

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

   115     if(colorRampPremultiplied)

   116         c.premultiply();

   117     return c;

   118 }

   119 

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

   121 {

   122     m_colorRampStops.swap(stops);

   123     m_inputColorRampStops.swap(inputStops);

   124     m_gradientStopsChanged = true;

   125 }

   126 

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

   128 {

   129     m_linearGradientPoint0 = p0;

   130     m_linearGradientPoint1 = p1;

   131 }

   132 

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

   134 {

   135     m_radialGradientCenter = c;

   136     m_radialGradientFocalPoint = f;

   137     m_radialGradientRadius = r;

   138 }

   139 

   140 bool Paint::linearDegenerate() const

   141 {

   142     return m_linearGradientPoint0 == m_linearGradientPoint1 ? true : false;

   143 }

   144 

   145 bool Paint::radialDegenerate() const

   146 {

   147     return m_radialGradientRadius == 0.0f ? true : false;

   148 }

   149 

   150 /**

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

   152  *          gradient is degenerate.

   153  */

   154 Color Paint::getSolidColor() const

   155 {

   156     if (m_paintType == VG_PAINT_TYPE_PATTERN)

   157     {

   158         RI_ASSERT(m_pattern == NULL);

   159         return m_paintColor;

   160     }

   161 

   162     if (m_paintType == VG_PAINT_TYPE_COLOR)

   163         return m_paintColor;

   164 

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

   166 

   167     // Determine the color at the end of the gradient

   168     RIfloat gs, ge;

   169     if (m_colorRampSpreadMode == VG_COLOR_RAMP_SPREAD_PAD)

   170     {

   171         gs = 1.0f - 1/256.0f;

   172         ge = 1.0f;

   173     } else if (m_colorRampSpreadMode == VG_COLOR_RAMP_SPREAD_REPEAT)

   174     {

   175         gs = 0.0f;

   176         ge = 1/256.0f;

   177     } else

   178     {

   179         gs = 1.0f - 1/256.0f;

   180         ge = 1.0f;

   181     }

   182     Color c = integrateColorRamp(gs, ge);

   183     return c * 256.0f;

   184 }

   185 

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

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

   188 * \param

   189 * \return

   190 * \note

   191 *//*-------------------------------------------------------------------*/

   192 

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

   194 {

   195     RI_ASSERT(gmin <= gmax);

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

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

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

   199 

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

   201 

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

   203         return currC;

   204 

   205     int i = 0;

   206 

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

   208     {

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

   210         {

   211             RIfloat s = m_colorRampStops[i].offset;

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

   213             RI_ASSERT(s < e);

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

   215 

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

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

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

   219 

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

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

   222             currC -= dc; 

   223             break;

   224         }

   225     }

   226 

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

   228     {

   229         RIfloat s = m_colorRampStops[i].offset;

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

   231         RI_ASSERT(s <= e);

   232 

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

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

   235 

   236         //average of the stop

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

   238         currC += dc; 

   239 

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

   241         {

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

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

   244 

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

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

   247             currC -= dc;

   248             break;

   249         }

   250     }

   251 

   252     return currC;

   253 }

   254 

   255 /**

   256  * \brief   Generates gradient color-ramp lookup values.

   257  *

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

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

   260  *

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

   262  *          format is known. The destination format is either destination 

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

   264  *          operation.

   265  */

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

   267 {

   268     const RIfloat gstep = 1.0f / (GRADIENT_LUT_COUNT);

   269     const RIfloat rcp = (RIfloat)(GRADIENT_LUT_COUNT);

   270     RIfloat gsx;

   271     gsx = 0.0f;

   272     

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

   274         return; // Already in correct format

   275 

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

   277 

   278     // Colortransform premultiplies color.

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

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

   281 

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

   283 

   284     // Create a pre-calculated LUT.

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

   286     {

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

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

   289         c *= rcp;

   290 

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

   292         if (pipe.getImageMode() != VG_DRAW_IMAGE_MULTIPLY)

   293             pipe.colorTransform(c);

   294 

   295         IntegerColor ic = IntegerColor(c);

   296         ic.convertToFrom(dstDesc, srcDesc, false);

   297         m_gradientLUT[i] = ic;

   298 

   299         gsx += gstep;

   300     }

   301 

   302     m_gradientStopsChanged = false;

   303     m_lutFormat = Color::descriptorToVGImageFormat(dstDesc);

   304     pipe.setColorTransformChanged(false);

   305 

   306     RI_ASSERT(m_lutFormat == preferredFormat);

   307 }

   308 

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

   310 * \brief    PixelPipe constructor.

   311 * \param

   312 * \return

   313 * \note

   314 *//*-------------------------------------------------------------------*/

   315 

   316 PixelPipe::PixelPipe() :

   317     m_drawable(NULL),

   318     m_image(NULL),

   319     m_paint(NULL),

   320     m_defaultPaint(),

   321     m_blendMode(VG_BLEND_SRC_OVER),

   322     m_imageMode(VG_DRAW_IMAGE_NORMAL),

   323     m_imageQuality(VG_IMAGE_QUALITY_FASTER),

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

   325     m_colorTransform(false),

   326     m_colorTransformValues(),

   327     m_iColorTransformValues(),

   328     m_surfaceToPaintMatrix(),

   329     m_surfaceToImageMatrix(),

   330     m_paintToSurfaceMatrix(),

   331     m_maskOperation(VG_SET_MASK),

   332     m_renderToMask(false),

   333     m_colorTransformChanged(true)

   334 {

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

   336     {

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

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

   339     }

   340 }

   341 

   342 

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

   344 * \brief    PixelPipe destructor.

   345 * \param

   346 * \return

   347 * \note

   348 *//*-------------------------------------------------------------------*/

   349 

   350 PixelPipe::~PixelPipe()

   351 {

   352 }

   353 

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

   355 * \brief    Sets the rendering surface.

   356 * \param

   357 * \return

   358 * \note

   359 *//*-------------------------------------------------------------------*/

   360 

   361 void PixelPipe::setDrawable(Drawable* drawable)

   362 {

   363     RI_ASSERT(drawable);

   364     m_drawable = drawable;

   365 }

   366 

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

   368 * \brief    Sets the blend mode.

   369 * \param

   370 * \return

   371 * \note

   372 *//*-------------------------------------------------------------------*/

   373 

   374 void PixelPipe::setBlendMode(VGBlendMode blendMode)

   375 {

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

   377     m_blendMode = blendMode;

   378 }

   379 

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

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

   382 * \param

   383 * \return

   384 * \note

   385 *//*-------------------------------------------------------------------*/

   386 

   387 void PixelPipe::setMask(bool masking)

   388 {

   389     m_masking = masking;

   390 }

   391 

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

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

   394 * \param

   395 * \return

   396 * \note

   397 *//*-------------------------------------------------------------------*/

   398 

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

   400 {

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

   402     m_image = image;

   403     m_imageMode = imageMode;

   404 }

   405 

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

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

   408 * \param

   409 * \return

   410 * \note

   411 *//*-------------------------------------------------------------------*/

   412 

   413 void PixelPipe::setSurfaceToPaintMatrix(const Matrix3x3& surfaceToPaintMatrix)

   414 {

   415     m_surfaceToPaintMatrix = surfaceToPaintMatrix;

   416 }

   417 

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

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

   420 * \param

   421 * \return

   422 * \note

   423 *//*-------------------------------------------------------------------*/

   424 

   425 void PixelPipe::setSurfaceToImageMatrix(const Matrix3x3& surfaceToImageMatrix)

   426 {

   427     m_surfaceToImageMatrix = surfaceToImageMatrix;

   428 }

   429 

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

   431 * \brief    Sets image quality.

   432 * \param

   433 * \return

   434 * \note

   435 *//*-------------------------------------------------------------------*/

   436 

   437 void PixelPipe::setImageQuality(VGImageQuality imageQuality)

   438 {

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

   440     m_imageQuality = imageQuality;

   441 }

   442 

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

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

   445 * \param

   446 * \return

   447 * \note

   448 *//*-------------------------------------------------------------------*/

   449 

   450 void PixelPipe::setTileFillColor(const Color& c)

   451 {

   452     m_tileFillColor = c;

   453     m_tileFillColor.clamp();

   454 }

   455 

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

   457 * \brief    Sets paint.

   458 * \param

   459 * \return

   460 * \note

   461 *//*-------------------------------------------------------------------*/

   462 

   463 void PixelPipe::setPaint(Paint* paint)

   464 {

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

   466     m_paint = paint;

   467 

   468     if(!m_paint)

   469         m_paint = &m_defaultPaint;

   470 

   471     if(m_paint->m_pattern)

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

   473 

   474 }

   475 

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

   477 * \brief    Color transform.

   478 * \param

   479 * \return

   480 * \note

   481 *//*-------------------------------------------------------------------*/

   482 

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

   484 {

   485     m_colorTransform = enable;

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

   487     {

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

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

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

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

   492     }

   493     m_colorTransformChanged = true;

   494 }

   495 

   496 const Image* PixelPipe::getRenderTargetImage() const

   497 {

   498     if (m_renderToMask)

   499         return m_drawable->getMaskBuffer()->getImage();

   500 

   501     return m_drawable->getColorBuffer()->getImage();

   502 }

   503 

   504 /**

   505  * \brief   Determine an appropriate VGImageFormat to use for lookup tables.

   506  * \todo    Should return descriptor instead?

   507  */

   508 VGImageFormat PixelPipe::getPreferredLUTFormat() const

   509 {

   510     const Image* target = getRenderTargetImage();

   511     const Color::Descriptor& targetDesc = target->getDescriptor();

   512 

   513     if (m_renderToMask)

   514     {

   515         RI_ASSERT(!m_image);

   516         if (targetDesc.isNonlinear())

   517             return VG_sRGBA_8888_PRE;

   518         else

   519             return VG_lRGBA_8888_PRE;

   520     }

   521 

   522     if (m_image && m_imageMode == VG_DRAW_IMAGE_MULTIPLY)

   523         return VG_sRGBA_8888_PRE; // ?

   524 

   525     // Prefer premultiplied formats

   526     // \note Can also generate non-premultiplied if no sampling/other operation and destination

   527     // is in linear format.

   528     // \note Do not use VGImageFormat, because using (s/l)LA88 is possible with

   529     // luminance destination formats.

   530     if (targetDesc.isNonlinear())

   531         return VG_sRGBA_8888_PRE;

   532     else

   533         return VG_lRGBA_8888_PRE;

   534 }

   535 

   536 void PixelPipe::prepareSolidFill()

   537 {

   538     if (!(m_drawable && m_paint))

   539         return;

   540         

   541     Color c = m_paint->getSolidColor();

   542     //Color c = m_paint->m_paintColor;

   543     

   544     if (!m_image || m_imageMode != VG_DRAW_IMAGE_MULTIPLY)

   545         colorTransform(c); // Output will be premultiplied

   546     // Generate internal color

   547     Color::Descriptor blendDesc = getRenderTargetImage()->getDescriptor();

   548 

   549     // MULTIPLY uses the color as-is.

   550     if (m_imageMode != VG_DRAW_IMAGE_MULTIPLY) c.convert(blendDesc.internalFormat);

   551 

   552     IntegerColor ic = IntegerColor(c);

   553     blendDesc.internalFormat = (Color::InternalFormat)(blendDesc.internalFormat | (Color::PREMULTIPLIED));

   554 

   555     if (m_imageMode != VG_DRAW_IMAGE_MULTIPLY) c.convert(blendDesc.internalFormat);

   556     

   557     IntegerColor blendColor = IntegerColor(c);

   558 

   559     if (m_imageMode == VG_DRAW_IMAGE_STENCIL)

   560         blendColor.asFixedPoint(c); // Enhance the precision a bit

   561     

   562     // \todo No need to pack the color if solid fill is not possible

   563     if (!m_renderToMask)

   564         ic.truncateColor(getRenderTargetImage()->getDescriptor());

   565     else

   566         ic.truncateMask(getRenderTargetImage()->getDescriptor());

   567 

   568     RIuint32 p = ic.getPackedColor(getRenderTargetImage()->getDescriptor());

   569 

   570     m_spanUniforms.solidColor = blendColor; // This must be premultiplied

   571     m_spanUniforms.packedSolidColor = p; // This must be exactly the dst color

   572 }

   573 

   574 void PixelPipe::prepareCoverageFill()

   575 {

   576     IntegerColor ic = IntegerColor(255, 255, 255, 255);

   577     RIuint32 p = ic.getPackedColor(m_drawable->getMaskBuffer()->getDescriptor());

   578 

   579     m_spanUniforms.solidColor = ic;

   580     m_spanUniforms.packedSolidColor = p;

   581 }

   582 

   583 void PixelPipe::prepareLinearGradient()

   584 {

   585     const Matrix3x3& s2p = m_surfaceToPaintMatrix;

   586 

   587     Vector2 zero(0,0);

   588     Vector2 p0 = m_paint->m_linearGradientPoint0;

   589     Vector2 p1 = m_paint->m_linearGradientPoint1;

   590     Vector2 delta = p1 - p0;

   591 

   592     zero = affineTransform(s2p, zero);

   593 

   594     RIfloat d = (delta.x * delta.x) + (delta.y * delta.y);

   595     RIfloat gdx = (s2p[0][0] * delta.x + s2p[1][0] * delta.y) / d;

   596     RIfloat gdy = (s2p[0][1] * delta.x + s2p[1][1] * delta.y) / d;

   597     RIfloat cx = (zero.x-p0.x) * (delta.x);

   598     RIfloat cy = (zero.y-p0.y) * (delta.y);

   599     RIfloat c = (cx + cy) / d;

   600 

   601     m_spanUniforms.dgdx = RI_FLOAT_TO_FX(gdx, PixelPipe::GRADIENT_BITS);

   602     m_spanUniforms.dgdy = RI_FLOAT_TO_FX(gdy, PixelPipe::GRADIENT_BITS);

   603     m_spanUniforms.lgc = RI_FLOAT_TO_FX(c + 0.5*(gdx + gdy), PixelPipe::GRADIENT_BITS);

   604 

   605     m_spanUniforms.gradientLookup = m_paint->getGradientLUT();

   606 }

   607 

   608 void PixelPipe::prepareRadialGradient()

   609 {

   610     const Matrix3x3& s2p = m_surfaceToPaintMatrix;

   611 

   612     Vector2 c = m_paint->m_radialGradientCenter;

   613     Vector2 f = m_paint->m_radialGradientFocalPoint;

   614     RGScalar r = m_paint->m_radialGradientRadius;

   615 

   616     Vector2 zero(0,0);

   617     Vector2 pzero = affineTransform(s2p, zero);

   618 

   619     Vector2 fp = f - c;

   620 

   621     RGScalar q = fp.length();

   622 

   623     if (q > r)

   624     {

   625         const RIfloat scale = 0.99f;

   626         fp.normalize();

   627         fp *= r * scale;

   628         f = fp + c;

   629     } 

   630 

   631     RGScalar r1sqr = RI_SQR(r);

   632     RGScalar d = r1sqr - dot(fp, fp);

   633 

   634     m_spanUniforms.rdxdx = s2p[0][0];

   635     m_spanUniforms.rdxdy = s2p[0][1];

   636     m_spanUniforms.rdydx = s2p[1][0];

   637     m_spanUniforms.rdydy = s2p[1][1];

   638 

   639     m_spanUniforms.rsqrp = r1sqr / RI_SQR(d);

   640     m_spanUniforms.rfxp = fp.x / d;

   641     m_spanUniforms.rfyp = fp.y / d;

   642     m_spanUniforms.rx0 = pzero.x - f.x + 0.5f*(m_spanUniforms.rdxdx + m_spanUniforms.rdxdy);

   643     m_spanUniforms.ry0 = pzero.y - f.y + 0.5f*(m_spanUniforms.rdydy + m_spanUniforms.rdydx);

   644 

   645     m_spanUniforms.gradientLookup = m_paint->getGradientLUT();

   646 }

   647 

   648 void PixelPipe::preparePattern()

   649 {

   650     // Patterns only support affine transforms

   651     const Matrix3x3& s2p = m_surfaceToPaintMatrix;

   652     const RIfloat patternWidth = (RIfloat)m_paint->m_pattern->getWidth();

   653     const RIfloat patternHeight = (RIfloat)m_paint->m_pattern->getHeight();

   654     const Vector2 zero(0, 0);

   655     Vector2 pzero = affineTransform(s2p, zero); 

   656 

   657     m_spanUniforms.paint_x0 = RI_ROUND_TO_INT((pzero.x/patternWidth)*(1<<GRADIENT_BITS));

   658     m_spanUniforms.paint_y0 = RI_ROUND_TO_INT((pzero.y/patternHeight)*(1<<GRADIENT_BITS));

   659     m_spanUniforms.paint_dxdx = RI_ROUND_TO_INT((s2p[0][0]/patternWidth)*(1<<GRADIENT_BITS));

   660     m_spanUniforms.paint_dxdy = RI_ROUND_TO_INT((s2p[0][1]/patternHeight)*(1<<GRADIENT_BITS));

   661     m_spanUniforms.paint_dydx = RI_ROUND_TO_INT((s2p[1][0]/patternWidth)*(1<<GRADIENT_BITS));

   662     m_spanUniforms.paint_dydy = RI_ROUND_TO_INT((s2p[1][1]/patternHeight)*(1<<GRADIENT_BITS));

   663 

   664     m_spanUniforms.paint_x0 += (m_spanUniforms.paint_dxdx + m_spanUniforms.paint_dxdy) / 2;

   665     m_spanUniforms.paint_y0 += (m_spanUniforms.paint_dydy + m_spanUniforms.paint_dydx) / 2;

   666 

   667     m_spanUniforms.patternPtr = m_paint->m_pattern->getData(); 

   668     m_spanUniforms.patternStride = m_paint->m_pattern->getStride();

   669     m_spanUniforms.paint_width = m_paint->m_pattern->getWidth();

   670     m_spanUniforms.paint_height = m_paint->m_pattern->getHeight();

   671 

   672     m_signatureState.patternDesc = m_paint->m_pattern->getDescriptor();

   673 

   674     m_spanUniforms.tileFillColor = IntegerColor(m_tileFillColor);

   675     // The tile fill-color must be shifted down to same bit-depth (see integer samplers)

   676     m_spanUniforms.tileFillColor.truncateColor(m_signatureState.patternDesc);

   677 

   678 }

   679 

   680 RI_INLINE static RIfloat floatEqu(RIfloat a, RIfloat b, RIfloat e)

   681 {

   682     // \note This should be sufficient for our use-cases;

   683     return (RI_ABS(a - b) < e);

   684 }

   685 

   686 RI_INLINE static RIfloat distToInt(RIfloat f)

   687 {

   688     const RIfloat intF = RI_ROUND_TO_INT(f);

   689     return RI_ABS(intF - f);

   690 }

   691 

   692 /**

   693  * \brief   Check if transform is 90 degree rotation, or flip and nothing else.

   694  */

   695 RI_INLINE static bool orthoNormalCoAxialTransform(const Matrix3x3& t, bool aa)

   696 {

   697     const RIfloat epsilonCoord = 1/255.0f; // 1/127.0f;

   698     const RIfloat epsilonGradient = epsilonCoord * epsilonCoord; // \todo Too strict?

   699     const RIfloat absPatterns[2][4] = {

   700         {1.0f, 0.0f, 0.0f, 1.0f},

   701         {0.0f, 1.0f, 1.0f, 0.0f} };

   702 

   703     if (!t.isAffine())

   704         return false;

   705 

   706     // \todo This rule only applies if filtering is in use?

   707     if (aa)

   708         if (!floatEqu(distToInt(t[0][2]), 0.0f, epsilonCoord) || !floatEqu(distToInt(t[1][2]), 0.0f, epsilonCoord))

   709             return false;

   710 

   711     Matrix3x3 u = t;

   712     

   713     for (int j = 0; j < 2; j++)

   714         for (int i = 0; i < 2; i++)

   715             u[j][i] = RI_ABS(u[j][i]);

   716 

   717     bool found;

   718 

   719     for (int m = 0; m < 2; m++)

   720     {

   721         found = true;

   722         for (int j = 0; j < 2; j++)

   723         {

   724             for (int i = 0; i < 2; i++)

   725             {

   726                 //if (u[j][i] != absPatterns[m][i+j*2])

   727                 if (!floatEqu(u[j][i], absPatterns[m][i+j*2], epsilonGradient))

   728                 {

   729                     found = false;

   730                     break;

   731                 }

   732             }

   733             if (!found) break;

   734         }

   735         if (found) break;

   736     }

   737 

   738     return found;

   739 }

   740 

   741 void PixelPipe::prepareImage(bool aa)

   742 {

   743     if (!m_image)

   744     {

   745         m_signatureState.imageGradientType = GRADIENT_TYPE_INTEGER;

   746         return;

   747     }

   748 

   749     RI_ASSERT(m_image);

   750     m_spanUniforms.imagePtr = m_image->getData();

   751     m_spanUniforms.imageStride = m_image->getStride();

   752     

   753     if (m_image->getParent() != NULL)

   754     {

   755         // Adjust the pointer.

   756         int x, y;

   757         m_image->getStorageOffset(x, y);

   758         m_spanUniforms.imagePtr = Image::calculateAddress(

   759             m_spanUniforms.imagePtr, m_image->getDescriptor().bitsPerPixel, x, y, m_spanUniforms.imageStride);

   760     }

   761 

   762     // \todo This function writes to derived state also.

   763     // \todo Plenty of fast-paths possible!

   764     const Matrix3x3& s2i = m_surfaceToImageMatrix;

   765     

   766     Vector3 zero(0,0,1);

   767     Vector3 pzero;

   768 

   769     bool fastImage = orthoNormalCoAxialTransform(s2i, aa);

   770     

   771     pzero = s2i * zero;

   772 

   773     if (fastImage)

   774     {

   775         RI_ASSERT(pzero.z == 1.0f);

   776         m_spanUniforms.image_idxdx = RI_ROUND_TO_INT(s2i[0][0]);

   777         m_spanUniforms.image_idxdy = RI_ROUND_TO_INT(s2i[0][1]);

   778         m_spanUniforms.image_idydx = RI_ROUND_TO_INT(s2i[1][0]);

   779         m_spanUniforms.image_idydy = RI_ROUND_TO_INT(s2i[1][1]);

   780         m_spanUniforms.image_ix0 = RI_FLOOR(pzero.x + 0.5f*(s2i[0][0]+s2i[0][1]));

   781         m_spanUniforms.image_iy0 = RI_FLOOR(pzero.y + 0.5f*(s2i[1][1]+s2i[1][0]));

   782 

   783         // Adjust sample-center when using (exactly) integer coordinates.

   784         

   785 #if 0

   786         if (m_spanUniforms.image_idxdx < 0 || m_spanUniforms.image_idxdy < 0)

   787             m_spanUniforms.image_ix0--;

   788     

   789         if (m_spanUniforms.image_idydy < 0 || m_spanUniforms.image_idydx < 0)

   790             m_spanUniforms.image_iy0--;

   791 #endif

   792 

   793         m_signatureState.imageGradientType = GRADIENT_TYPE_INTEGER;

   794     } 

   795     else if (s2i.isAffine())

   796     {

   797         RI_ASSERT(pzero.z == 1.0f); 

   798         const RIfloat imageWidth = m_image->getWidth();

   799         const RIfloat imageHeight = m_image->getHeight();

   800         

   801         m_spanUniforms.image_idxdx = RI_ROUND_TO_INT((s2i[0][0]/imageWidth)*(1<<GRADIENT_BITS));

   802         m_spanUniforms.image_idxdy = RI_ROUND_TO_INT((s2i[0][1]/imageHeight)*(1<<GRADIENT_BITS));

   803         m_spanUniforms.image_idydx = RI_ROUND_TO_INT((s2i[1][0]/imageWidth)*(1<<GRADIENT_BITS));

   804         m_spanUniforms.image_idydy = RI_ROUND_TO_INT((s2i[1][1]/imageHeight)*(1<<GRADIENT_BITS));

   805         m_spanUniforms.image_ix0 = RI_ROUND_TO_INT((pzero.x/imageWidth)*(1<<GRADIENT_BITS));

   806         m_spanUniforms.image_iy0 = RI_ROUND_TO_INT((pzero.y/imageHeight)*(1<<GRADIENT_BITS));

   807 

   808         m_spanUniforms.image_ix0 += (m_spanUniforms.image_idxdx + m_spanUniforms.image_idxdy)/2;

   809         m_spanUniforms.image_iy0 += (m_spanUniforms.image_idydy + m_spanUniforms.image_idydx)/2;

   810 

   811         m_spanUniforms.image_iWidth = (RIint32)imageWidth;

   812         m_spanUniforms.image_iHeight = (RIint32)imageHeight;

   813 

   814         m_signatureState.imageGradientType = GRADIENT_TYPE_FIXED;

   815     } 

   816     else

   817     {

   818         // Use floats.

   819         m_spanUniforms.image_fx0 = pzero.x;

   820         m_spanUniforms.image_fy0 = pzero.y;

   821         m_spanUniforms.image_fw0 = pzero.z;

   822         m_spanUniforms.image_fdxdx = s2i[0][0];

   823         m_spanUniforms.image_fdxdy = s2i[0][1];

   824         m_spanUniforms.image_fdydx = s2i[1][0];

   825         m_spanUniforms.image_fdydy = s2i[1][1];

   826         m_spanUniforms.image_fdwdx = s2i[2][0];

   827         m_spanUniforms.image_fdwdy = s2i[2][1];

   828 

   829         m_spanUniforms.image_fx0 += 0.5f * (m_spanUniforms.image_fdxdx + m_spanUniforms.image_fdxdy);

   830         m_spanUniforms.image_fy0 += 0.5f * (m_spanUniforms.image_fdydy + m_spanUniforms.image_fdydx);

   831         m_spanUniforms.image_fw0 += 0.5f * (m_spanUniforms.image_fdwdx + m_spanUniforms.image_fdwdy);

   832 

   833         m_spanUniforms.image_fWidth = (RIfloat)m_image->getWidth();

   834         m_spanUniforms.image_fHeight = (RIfloat)m_image->getHeight();

   835 

   836         m_signatureState.imageGradientType = GRADIENT_TYPE_FLOAT;

   837     }

   838 

   839     m_signatureState.imageDesc = m_image->getDescriptor();

   840 }

   841 

   842 static PixelPipe::TilingMode tilingModeOfImageTilingMode(VGTilingMode it)

   843 {

   844     switch(it)

   845     {

   846     case VG_TILE_PAD:

   847         return PixelPipe::TILING_MODE_PAD;

   848     case VG_TILE_REPEAT:

   849         return PixelPipe::TILING_MODE_REPEAT;

   850     case VG_TILE_REFLECT:

   851         return PixelPipe::TILING_MODE_REFLECT;

   852     default:

   853         RI_ASSERT(it == VG_TILE_FILL);

   854         return PixelPipe::TILING_MODE_FILL;

   855     }

   856 }

   857 

   858 static PixelPipe::TilingMode tilingModeOfSpreadMode(VGColorRampSpreadMode sm)

   859 {

   860     switch(sm)

   861     {

   862     case VG_COLOR_RAMP_SPREAD_PAD:

   863         return PixelPipe::TILING_MODE_PAD;

   864     case VG_COLOR_RAMP_SPREAD_REPEAT:

   865         return PixelPipe::TILING_MODE_REPEAT;

   866     default:

   867         RI_ASSERT(sm == VG_COLOR_RAMP_SPREAD_REFLECT);

   868         return PixelPipe::TILING_MODE_REFLECT;

   869     }

   870 }

   871 

   872 static PixelPipe::TilingMode tilingModeOfPaint(const Paint* paint)

   873 {

   874     switch(paint->m_paintType)

   875     {

   876     case VG_PAINT_TYPE_COLOR:

   877         return PixelPipe::TILING_MODE_PAD;

   878     case VG_PAINT_TYPE_LINEAR_GRADIENT:

   879     case VG_PAINT_TYPE_RADIAL_GRADIENT:

   880         return tilingModeOfSpreadMode(paint->m_colorRampSpreadMode);

   881     default:

   882         RI_ASSERT(paint->m_paintType == VG_PAINT_TYPE_PATTERN);

   883         return tilingModeOfImageTilingMode(paint->m_patternTilingMode);

   884     }

   885 }

   886 

   887 void PixelPipe::prepareRenderToMask()

   888 {

   889     RI_ASSERT(m_drawable->getMaskBuffer());

   890 

   891     m_signatureState.dstDesc = m_drawable->getMaskBuffer()->getDescriptor();

   892     //RI_ASSERT(m_signatureState.dstFormat >= 0 && m_signatureState.dstFormat <= VG_lABGR_8888_PRE);

   893 

   894     m_signatureState.maskOperation = m_maskOperation;

   895 }

   896 

   897 void PixelPipe::prepareSignatureState()

   898 {

   899     m_signatureState.isRenderToMask = m_renderToMask;

   900 

   901     if (m_signatureState.isRenderToMask)

   902     {

   903         prepareRenderToMask();

   904         return;

   905     }

   906 

   907     m_signatureState.blendMode = getBlendMode();

   908 

   909     m_signatureState.hasColorTransform = this->m_colorTransform;

   910 

   911     m_signatureState.paintType = getPaintType();

   912     

   913     m_signatureState.paintTilingMode = tilingModeOfPaint(m_paint);

   914     // \todo Derive these from the quality settings somehow.

   915     // Linear and nearest should work atm.

   916     m_signatureState.paintSampler = SAMPLER_TYPE_NEAREST;

   917     m_signatureState.imageSampler = SAMPLER_TYPE_NEAREST;

   918 

   919     m_signatureState.hasMasking = isMasking() && (m_drawable->getMaskBuffer() != NULL);

   920     

   921     m_signatureState.hasImage = m_image ? true : false;

   922     m_signatureState.unsafeImageInput = !m_image ? false : m_image->isUnsafe();

   923     m_signatureState.imageMode = m_imageMode;

   924 

   925     // Formats. Note that fields that are not filled in / used get set to a derived state in a 

   926     // separate function!

   927 

   928     if (m_signatureState.paintType == (RIuint32)VG_PAINT_TYPE_COLOR)

   929     {

   930         RI_ASSERT(m_paint);

   931         if (m_paint->getSolidColor().a == 1.0)

   932             m_signatureState.fillColorTransparent = false;

   933         else

   934             m_signatureState.fillColorTransparent = true;

   935     }

   936 

   937     m_signatureState.dstDesc = m_drawable->getColorBuffer()->getDescriptor();

   938 

   939     // \todo Why isn't the imagedescriptor set here?

   940     if (m_signatureState.hasMasking)

   941     {

   942         m_signatureState.maskDesc = m_drawable->getMaskBuffer()->getDescriptor();

   943     }

   944 

   945 }

   946 

   947 /**

   948  * \brief   Remove redundancy from the pixel-pipeline state so that less

   949  *          pipelines are generated.

   950  */

   951 static void determineDerivedState(PixelPipe::SignatureState& derivedState, const PixelPipe::SignatureState& originalState)

   952 {

   953     derivedState = originalState;

   954 

   955     if (derivedState.isRenderToMask)

   956     {

   957         // Set a lot of defaults:

   958         derivedState.blendMode = VG_BLEND_SRC;

   959         derivedState.imageMode = VG_DRAW_IMAGE_NORMAL;

   960         derivedState.paintType = VG_PAINT_TYPE_COLOR;

   961 

   962         derivedState.hasImage = false;

   963         derivedState.hasMasking = false;

   964         derivedState.hasColorTransform = false;

   965     }

   966 

   967     if (derivedState.paintType == VG_PAINT_TYPE_COLOR)

   968     {

   969         derivedState.paintTilingMode = PixelPipe::TILING_MODE_PAD;

   970         derivedState.paintSampler = PixelPipe::SAMPLER_TYPE_NEAREST;

   971         // \todo Opaque solid colors can benefit from simpler coverage-blending

   972         // becase SRC_OVER == SRC. This information has to be present in

   973         // the derivedState (and not just uniform).

   974     }

   975 

   976     if (!derivedState.hasImage)

   977     {

   978         derivedState.imageMode = VG_DRAW_IMAGE_NORMAL;

   979         derivedState.imageSampler = PixelPipe::SAMPLER_TYPE_NEAREST;

   980         derivedState.imageGradientType = PixelPipe::GRADIENT_TYPE_INTEGER;

   981         derivedState.imageDesc = Color::Descriptor::getDummyDescriptor();

   982     } else if (derivedState.imageMode == VG_DRAW_IMAGE_NORMAL)

   983     {

   984         // If paint is not generated, use a common enum

   985         derivedState.paintType = VG_PAINT_TYPE_COLOR;

   986     }

   987 

   988     if (derivedState.paintType != VG_PAINT_TYPE_PATTERN)

   989     {

   990         derivedState.patternDesc = Color::Descriptor::getDummyDescriptor();

   991     }

   992 

   993     if (!derivedState.isRenderToMask)

   994         derivedState.maskOperation = VG_CLEAR_MASK;

   995 

   996     if (!derivedState.hasMasking)

   997     {

   998         derivedState.maskDesc = Color::Descriptor::getDummyDescriptor();

   999     }

  1000 }

  1001 

  1002 

  1003 /**

  1004  * \brief   Determine per-scanconversion constant state.

  1005  * \todo    NOTE! This also prepares the derived state at the moment.

  1006  */

  1007 void PixelPipe::prepareSpanUniforms(bool aa)

  1008 {

  1009     prepareSignatureState();

  1010 

  1011     if (m_signatureState.hasColorTransform)

  1012         m_spanUniforms.colorTransformValues = m_iColorTransformValues;

  1013 

  1014     RI_ASSERT(m_drawable->getColorBuffer());

  1015 

  1016     const Image* dst;

  1017 

  1018     if (!m_signatureState.isRenderToMask)

  1019         dst = m_drawable->getColorBuffer()->getImage();

  1020     else

  1021         dst = m_drawable->getMaskBuffer()->getImage();

  1022     

  1023     m_spanUniforms.dstPtr = dst->getData();

  1024     m_spanUniforms.dstStride = dst->getStride();

  1025 

  1026     if (m_drawable->getMaskBuffer())

  1027     {

  1028         m_spanUniforms.maskPtr = m_drawable->getMaskBuffer()->m_image->getData();

  1029         m_spanUniforms.maskStride = m_drawable->getMaskBuffer()->m_image->getStride();

  1030     }

  1031     else

  1032     {

  1033         m_spanUniforms.maskPtr = NULL;

  1034         m_spanUniforms.maskStride = 0;

  1035     }

  1036 

  1037     if (!m_renderToMask)

  1038     {

  1039         VGImageFormat prefPaintFormat = getPreferredLUTFormat();

  1040 

  1041         switch (getPaintType())

  1042         {

  1043             case VG_PAINT_TYPE_COLOR:

  1044                 prepareSolidFill();

  1045                 break;

  1046             case VG_PAINT_TYPE_LINEAR_GRADIENT:

  1047                 m_paint->generateLUT(*this, prefPaintFormat);

  1048                 prepareLinearGradient(); 

  1049                 break;

  1050             case VG_PAINT_TYPE_RADIAL_GRADIENT:

  1051                 m_paint->generateLUT(*this, prefPaintFormat);

  1052                 prepareRadialGradient();

  1053                 break;

  1054             default:

  1055                 RI_ASSERT(getPaintType() == VG_PAINT_TYPE_PATTERN);

  1056                 preparePattern();

  1057                 break;

  1058         }

  1059     }

  1060     else

  1061     {

  1062         prepareCoverageFill();

  1063     }

  1064 

  1065     prepareImage(aa);

  1066 

  1067     // Must be done last:

  1068     determineDerivedState(m_derivedState, m_signatureState);

  1069 }

  1070 

  1071 

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

  1073 * \brief    Computes the linear gradient function at (x,y).

  1074 * \param

  1075 * \return

  1076 * \note

  1077 *//*-------------------------------------------------------------------*/

  1078 void PixelPipe::linearGradient(RIfloat& g, RIfloat& rho, RIfloat x, RIfloat y) const

  1079 {

  1080     RI_ASSERT(m_paint);

  1081     Vector2 u = m_paint->m_linearGradientPoint1 - m_paint->m_linearGradientPoint0;

  1082     RIfloat usq = dot(u,u);

  1083     if( usq <= 0.0f )

  1084     {   //points are equal, gradient is always 1.0f

  1085         g = 1.0f;

  1086         rho = 0.0f;

  1087         return;

  1088     }

  1089     RIfloat oou = 1.0f / usq;

  1090 

  1091     Vector2 p(x, y);

  1092     p = affineTransform(m_surfaceToPaintMatrix, p);

  1093     p -= m_paint->m_linearGradientPoint0;

  1094     RI_ASSERT(usq >= 0.0f);

  1095     g = dot(p, u) * oou;

  1096     RIfloat dgdx = oou * u.x * m_surfaceToPaintMatrix[0][0] + oou * u.y * m_surfaceToPaintMatrix[1][0];

  1097     RIfloat dgdy = oou * u.x * m_surfaceToPaintMatrix[0][1] + oou * u.y * m_surfaceToPaintMatrix[1][1];

  1098     rho = (RIfloat)sqrt(dgdx*dgdx + dgdy*dgdy);

  1099     RI_ASSERT(rho >= 0.0f);

  1100 }

  1101 

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

  1103 * \brief    Computes the radial gradient function at (x,y).

  1104 * \param

  1105 * \return

  1106 * \note

  1107 *//*-------------------------------------------------------------------*/

  1108 

  1109 void PixelPipe::radialGradient(RIfloat &g, RIfloat &rho, RIfloat x, RIfloat y) const

  1110 {

  1111     RI_ASSERT(m_paint);

  1112     if( m_paint->m_radialGradientRadius <= 0.0f )

  1113     {

  1114         g = 1.0f;

  1115         rho = 0.0f;

  1116         return;

  1117     }

  1118 

  1119     RIfloat r = m_paint->m_radialGradientRadius;

  1120     Vector2 c = m_paint->m_radialGradientCenter;

  1121     Vector2 f = m_paint->m_radialGradientFocalPoint;

  1122     Vector2 gx(m_surfaceToPaintMatrix[0][0], m_surfaceToPaintMatrix[1][0]);

  1123     Vector2 gy(m_surfaceToPaintMatrix[0][1], m_surfaceToPaintMatrix[1][1]);

  1124 

  1125     Vector2 fp = f - c;

  1126 

  1127     //clamp the focal point inside the gradient circle

  1128     RIfloat fpLen = fp.length();

  1129     if( fpLen > 0.999f * r )

  1130         fp *= 0.999f * r / fpLen;

  1131 

  1132     RIfloat D = -1.0f / (dot(fp,fp) - r*r);

  1133     Vector2 p(x, y);

  1134     p = affineTransform(m_surfaceToPaintMatrix, p) - c;