SkLineClipper.cpp File Reference

#include "src/core/SkLineClipper.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTo.h"
#include <cstring>
#include <utility>

Go to the source code of this file.

Functions
template<typename T >
T	pin_unsorted (T value, T limit0, T limit1)
static SkScalar	sect_with_horizontal (const SkPoint src[2], SkScalar Y)
static SkScalar	sect_with_vertical (const SkPoint src[2], SkScalar X)
static SkScalar	sect_clamp_with_vertical (const SkPoint src[2], SkScalar x)
static bool	nestedLT (SkScalar a, SkScalar b, SkScalar dim)
static bool	containsNoEmptyCheck (const SkRect &outer, const SkRect &inner)

Function Documentation

containsNoEmptyCheck()

static bool containsNoEmptyCheck ( const SkRect &  outer, const SkRect &  inner  )

inlinestatic

Definition at line 90 of file SkLineClipper.cpp.

                                                             {
    return  outer.fLeft <= inner.fLeft && outer.fTop <= inner.fTop &&
            outer.fRight >= inner.fRight && outer.fBottom >= inner.fBottom;
}

nestedLT()

static bool nestedLT ( SkScalar  a, SkScalar  b, SkScalar  dim  )

inlinestatic

Definition at line 84 of file SkLineClipper.cpp.

                                                                  {
    return a <= b && (a < b || dim > 0);
}

pin_unsorted()

template<typename T >

T pin_unsorted	(	T	value,
		T	limit0,
		T	limit1
	)

Definition at line 19 of file SkLineClipper.cpp.

                                                                  {
    if (limit1 < limit0) {
        using std::swap;
        swap(limit0, limit1);
    }
    // now the limits are sorted
    SkASSERT(limit0 <= limit1);
 
    if (value < limit0) {
        value = limit0;
    } else if (value > limit1) {
        value = limit1;
    }
    return value;
}

sect_clamp_with_vertical()

static SkScalar sect_clamp_with_vertical ( const SkPoint  src[2], SkScalar  x  )

static

Definition at line 73 of file SkLineClipper.cpp.

                                                                           {
    SkScalar y = sect_with_vertical(src, x);
    // Our caller expects y to be between src[0].fY and src[1].fY (unsorted), but due to the
    // numerics of floats/doubles, we might have computed a value slightly outside of that,
    // so we have to manually clamp afterwards.
    // See skbug.com/7491
    return pin_unsorted(y, src[0].fY, src[1].fY);
}

sect_with_horizontal()

static SkScalar sect_with_horizontal ( const SkPoint  src[2], SkScalar  Y  )

static

Definition at line 36 of file SkLineClipper.cpp.

                                                                       {
    SkScalar dy = src[1].fY - src[0].fY;
    if (SkScalarNearlyZero(dy)) {
        return SkScalarAve(src[0].fX, src[1].fX);
    } else {
        // need the extra precision so we don't compute a value that exceeds
        // our original limits
        double X0 = src[0].fX;
        double Y0 = src[0].fY;
        double X1 = src[1].fX;
        double Y1 = src[1].fY;
        double result = X0 + ((double)Y - Y0) * (X1 - X0) / (Y1 - Y0);
 
        // The computed X value might still exceed [X0..X1] due to quantum flux
        // when the doubles were added and subtracted, so we have to pin the
        // answer :(
        return (float)pin_unsorted(result, X0, X1);
    }
}

sect_with_vertical()

static SkScalar sect_with_vertical ( const SkPoint  src[2], SkScalar  X  )

static

Definition at line 57 of file SkLineClipper.cpp.

                                                                     {
    SkScalar dx = src[1].fX - src[0].fX;
    if (SkScalarNearlyZero(dx)) {
        return SkScalarAve(src[0].fY, src[1].fY);
    } else {
        // need the extra precision so we don't compute a value that exceeds
        // our original limits
        double X0 = src[0].fX;
        double Y0 = src[0].fY;
        double X1 = src[1].fX;
        double Y1 = src[1].fY;
        double result = Y0 + ((double)X - X0) * (Y1 - Y0) / (X1 - X0);
        return (float)result;
    }
}