darling-cocotron/Onyx2D/O2Paint_radialGradient.m

/*------------------------------------------------------------------------
 *
 * Derivative of the OpenVG 1.0.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.
 *
 *-------------------------------------------------------------------*/
#import <Onyx2D/O2Paint_radialGradient.h>
#import <Onyx2D/O2Shading.h>

@implementation O2Paint_radialGradient

ONYX2D_STATIC_INLINE void quadratic(O2Float a, O2Float hb, O2Float c,
                                    O2Float *x1, O2Float *x2)
{
    // Solve a*x*x + 2*hb*x + c = 0 numerically, trying not to lose precision
    // for cases when a is close to 0.
    O2Float qD = hb * hb - a * c;
    O2Float d = (O2Float) sqrt(qD);
    *x1 = c / (-hb + d);
    *x2 = c / (-hb - d);
}

void O2PaintRadialGradient(O2Paint_radialGradient *self, O2Float *g,
                           O2Float *rho, O2Float x, O2Float y)
{
    RI_ASSERT(self);
    if (self->_endRadius <= 0.0f) {
        *g = 1.0f;
        *rho = 0.0f;
        return;
    }

    O2Point gx = O2PointMake(self->m_surfaceToPaintMatrix.a,
                             self->m_surfaceToPaintMatrix.b);
    O2Point gy = O2PointMake(self->m_surfaceToPaintMatrix.c,
                             self->m_surfaceToPaintMatrix.d);

    O2Float r = self->_endRadius;
    O2Float R = self->_startRadius;

    O2Point O = self->_endPoint;

    O2Point p = O2PointMake(x, y);
    p = Vector2Subtract(
            O2PointApplyAffineTransform(p, self->m_surfaceToPaintMatrix), O);

    O2Point f = self->_startPoint;
    f = Vector2Subtract(f, O);

    O2Point d = Vector2Subtract(p, f);
    O2Float dd = Vector2Dot(d, d);
    O2Float df = Vector2Dot(d, f);
    O2Float ff = Vector2Dot(f, f);

    O2Float a = ff - r * r - R * R + 2 * r * R;
    O2Float hb = df + R * R - R * r;
    O2Float c = dd - R * R;

    *rho = 0.01; // TODO: something smarter

    O2Float g_inside, g_outside;
    quadratic(a, hb, c, &g_inside, &g_outside);

    BOOL outsideVisible = (self->_extendStart || 0.0 <= g_outside - *rho) &&
                          (self->_extendEnd || g_outside + *rho <= 1.0) &&
                          (a >= 0.0 || R > r);
    *g = outsideVisible ? g_outside : g_inside;

    O2Float resultingRadius = (R * (1 - *g)) + (*g * r);
    if (resultingRadius < 0.0) {
        *g = NAN;
    }
}

ONYX2D_STATIC_INLINE O2argb32f
radialGradientColorAt(O2Paint_radialGradient *self, int x, int y, int *skip)
{
    O2argb32f result;

    O2Float g, rho;
    O2PaintRadialGradient(self, &g, &rho, x + 0.5f, y + 0.5f);

    result = O2PaintColorRamp(self, g, rho, skip);

    return result;
}

ONYX2D_STATIC int radial_span_largb8u_PRE(O2Paint *selfX, int x, int y,
                                          O2argb8u *span, int length)
{
    O2Paint_radialGradient *self = (O2Paint_radialGradient *) selfX;
    int i;
    int previous = -1;

    for (i = 0; i < length; i++, x++) {
        int skip = 0;
        O2argb32f value = radialGradientColorAt(self, x, y, &skip);

        if (skip != previous) {
            if (previous == -1)
                previous = skip;
            else
                return (previous == 1) ? -i : i;
        }

        span[i] = O2argb8uFromO2argb32f(value);
    }
    return (previous == 1) ? -length : length;
}

ONYX2D_STATIC int radial_span_largb32f_PRE(O2Paint *selfX, int x, int y,
                                           O2argb32f *span, int length)
{
    O2Paint_radialGradient *self = (O2Paint_radialGradient *) selfX;
    int i;
    int previous = -1;

    for (i = 0; i < length; i++, x++) {
        int skip = 0;
        O2argb32f value = radialGradientColorAt(self, x, y, &skip);

        if (skip != previous) {
            if (previous == -1)
                previous = skip;
            else
                return (previous == 1) ? -i : i;
        }

        span[i] = value;
    }
    return (previous == 1) ? -length : length;
}

- initWithShading: (O2Shading *) shading
        deviceTransform: (O2AffineTransform) deviceTransform
{
    [super initWithShading: shading
            deviceTransform: deviceTransform
            numberOfSamples: 1024];
    _paint_largb8u_PRE = radial_span_largb8u_PRE;
    _paint_largb32f_PRE = radial_span_largb32f_PRE;
    _startRadius = [shading startRadius];
    _endRadius = [shading endRadius];

    return self;
}

@end