GrOvalOpFactory.cpp File Reference

#include "src/gpu/ganesh/ops/GrOvalOpFactory.h"
#include "include/core/SkStrokeRec.h"
#include "include/private/base/SkFloatingPoint.h"
#include "src/core/SkMatrixPriv.h"
#include "src/core/SkRRectPriv.h"
#include "src/gpu/BufferWriter.h"
#include "src/gpu/KeyBuilder.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrDrawOpTest.h"
#include "src/gpu/ganesh/GrGeometryProcessor.h"
#include "src/gpu/ganesh/GrOpFlushState.h"
#include "src/gpu/ganesh/GrProcessor.h"
#include "src/gpu/ganesh/GrProcessorUnitTest.h"
#include "src/gpu/ganesh/GrProgramInfo.h"
#include "src/gpu/ganesh/GrResourceProvider.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "src/gpu/ganesh/GrStyle.h"
#include "src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h"
#include "src/gpu/ganesh/glsl/GrGLSLProgramDataManager.h"
#include "src/gpu/ganesh/glsl/GrGLSLUniformHandler.h"
#include "src/gpu/ganesh/glsl/GrGLSLVarying.h"
#include "src/gpu/ganesh/glsl/GrGLSLVertexGeoBuilder.h"
#include "src/gpu/ganesh/ops/GrMeshDrawOp.h"
#include "src/gpu/ganesh/ops/GrSimpleMeshDrawOpHelper.h"
#include <utility>

Go to the source code of this file.

Classes
class	CircleGeometryProcessor
class	ButtCapDashedCircleGeometryProcessor
class	EllipseGeometryProcessor
class	DIEllipseGeometryProcessor
class	CircleOp
struct	CircleOp::ArcParams
class	ButtCapDashedCircleOp
class	EllipseOp
class	DIEllipseOp
class	CircularRRectOp
class	EllipticalRRectOp

Enumerations
enum class	DIEllipseStyle { kStroke = 0 , kHairline , kFill }
enum	RRectType { kFill_RRectType , kStroke_RRectType , kOverstroke_RRectType }

Functions
static int	circle_type_to_vert_count (bool stroked)
static int	circle_type_to_index_count (bool stroked)
static const uint16_t *	circle_type_to_indices (bool stroked)
static int	rrect_type_to_vert_count (RRectType type)
static int	rrect_type_to_index_count (RRectType type)
static const uint16_t *	rrect_type_to_indices (RRectType type)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gStrokeRRectOnlyIndexBufferKey)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gRRectOnlyIndexBufferKey)
static sk_sp< const GrBuffer >	get_rrect_index_buffer (RRectType type, GrResourceProvider *resourceProvider)
GrOp::Owner	make_rrect_op (GrRecordingContext *context, GrPaint &&paint, const SkMatrix &viewMatrix, const SkRRect &rrect, const SkStrokeRec &stroke)

Variables
static const uint16_t	gFillCircleIndices []
static const uint16_t	gStrokeCircleIndices []
static constexpr SkScalar	kOctOffset = 0.41421356237f
static constexpr SkPoint	kOctagonOuter []
static constexpr SkScalar	kCosPi8 = 0.923579533f
static constexpr SkScalar	kSinPi8 = 0.382683432f
static constexpr SkPoint	kOctagonInner []
static const int	kIndicesPerFillCircle = std::size(gFillCircleIndices)
static const int	kIndicesPerStrokeCircle = std::size(gStrokeCircleIndices)
static const int	kVertsPerStrokeCircle = 16
static const int	kVertsPerFillCircle = 9
static const uint16_t	gOverstrokeRRectIndices []
static const uint16_t *	gStandardRRectIndices = gOverstrokeRRectIndices + 6 * 4
static const int	kIndicesPerOverstrokeRRect = std::size(gOverstrokeRRectIndices) - 6
static const int	kIndicesPerFillRRect = kIndicesPerOverstrokeRRect - 6 * 4 + 6
static const int	kIndicesPerStrokeRRect = kIndicesPerFillRRect - 6
static const int	kVertsPerStandardRRect = 16
static const int	kVertsPerOverstrokeRRect = 24
static const int	kNumRRectsInIndexBuffer = 256

Enumeration Type Documentation

DIEllipseStyle

enum class DIEllipseStyle

strong

The output of this effect is a modulation of the input color and coverage for an ellipse, specified as a 2D offset from center for both the outer and inner paths (if stroked). The implict equation used is for a unit circle (x^2 + y^2 - 1 = 0) and the edge corrected by using differentials.

The result is device-independent and can be used with any affine matrix.

Enumerator
kStroke
kHairline
kFill

Definition at line 729 of file GrOvalOpFactory.cpp.

{ kStroke = 0, kHairline, kFill };

RRectType

enum RRectType

Enumerator
kFill_RRectType
kStroke_RRectType
kOverstroke_RRectType

Definition at line 2461 of file GrOvalOpFactory.cpp.

               {
    kFill_RRectType,
    kStroke_RRectType,
    kOverstroke_RRectType,
};

Function Documentation

circle_type_to_index_count()

static int circle_type_to_index_count ( bool  stroked )

static

Definition at line 975 of file GrOvalOpFactory.cpp.

                                                    {
    return stroked ? kIndicesPerStrokeCircle : kIndicesPerFillCircle;
}

circle_type_to_indices()

static const uint16_t * circle_type_to_indices ( bool  stroked )

static

Definition at line 979 of file GrOvalOpFactory.cpp.

                                                            {
    return stroked ? gStrokeCircleIndices : gFillCircleIndices;
}

circle_type_to_vert_count()

static int circle_type_to_vert_count ( bool  stroked )

static

Definition at line 971 of file GrOvalOpFactory.cpp.

                                                   {
    return stroked ? kVertsPerStrokeCircle : kVertsPerFillCircle;
}

get_rrect_index_buffer()

static sk_sp< const GrBuffer > get_rrect_index_buffer ( RRectType  type, GrResourceProvider *  resourceProvider  )

static

Definition at line 2858 of file GrOvalOpFactory.cpp.

                                                                                          {
    SKGPU_DEFINE_STATIC_UNIQUE_KEY(gStrokeRRectOnlyIndexBufferKey);
    SKGPU_DEFINE_STATIC_UNIQUE_KEY(gRRectOnlyIndexBufferKey);
    switch (type) {
        case kFill_RRectType:
            return resourceProvider->findOrCreatePatternedIndexBuffer(
                    gStandardRRectIndices, kIndicesPerFillRRect, kNumRRectsInIndexBuffer,
                    kVertsPerStandardRRect, gRRectOnlyIndexBufferKey);
        case kStroke_RRectType:
            return resourceProvider->findOrCreatePatternedIndexBuffer(
                    gStandardRRectIndices, kIndicesPerStrokeRRect, kNumRRectsInIndexBuffer,
                    kVertsPerStandardRRect, gStrokeRRectOnlyIndexBufferKey);
        default:
            SkASSERT(false);
            return nullptr;
    }
}

make_rrect_op()

GrOp::Owner make_rrect_op	(	GrRecordingContext *	context,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		const SkRRect &	rrect,
		const SkStrokeRec &	stroke
	)

Definition at line 3226 of file GrOvalOpFactory.cpp.

                                                     {
    SkASSERT(viewMatrix.rectStaysRect());
    SkASSERT(rrect.isSimple());
    SkASSERT(!rrect.isOval());
 
    // RRect ops only handle simple, but not too simple, rrects.
    // Do any matrix crunching before we reset the draw state for device coords.
    const SkRect& rrectBounds = rrect.getBounds();
    SkRect bounds;
    viewMatrix.mapRect(&bounds, rrectBounds);
 
    SkVector radii = SkRRectPriv::GetSimpleRadii(rrect);
    SkScalar xRadius = SkScalarAbs(viewMatrix[SkMatrix::kMScaleX] * radii.fX +
                                   viewMatrix[SkMatrix::kMSkewY] * radii.fY);
    SkScalar yRadius = SkScalarAbs(viewMatrix[SkMatrix::kMSkewX] * radii.fX +
                                   viewMatrix[SkMatrix::kMScaleY] * radii.fY);
 
    SkStrokeRec::Style style = stroke.getStyle();
 
    // Do (potentially) anisotropic mapping of stroke. Use -1s to indicate fill-only draws.
    SkVector scaledStroke = {-1, -1};
    SkScalar strokeWidth = stroke.getWidth();
 
    bool isStrokeOnly =
            SkStrokeRec::kStroke_Style == style || SkStrokeRec::kHairline_Style == style;
    bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
 
    if (hasStroke) {
        if (SkStrokeRec::kHairline_Style == style) {
            scaledStroke.set(1, 1);
        } else {
            scaledStroke.fX = SkScalarAbs(
                    strokeWidth * (viewMatrix[SkMatrix::kMScaleX] + viewMatrix[SkMatrix::kMSkewY]));
            scaledStroke.fY = SkScalarAbs(
                    strokeWidth * (viewMatrix[SkMatrix::kMSkewX] + viewMatrix[SkMatrix::kMScaleY]));
        }
 
        // if half of strokewidth is greater than radius, we don't handle that right now
        if ((SK_ScalarHalf * scaledStroke.fX > xRadius ||
             SK_ScalarHalf * scaledStroke.fY > yRadius)) {
            return nullptr;
        }
    }
 
    // The matrix may have a rotation by an odd multiple of 90 degrees.
    if (viewMatrix.getScaleX() == 0) {
        std::swap(xRadius, yRadius);
        std::swap(scaledStroke.fX, scaledStroke.fY);
    }
 
    // The way the effect interpolates the offset-to-ellipse/circle-center attribute only works on
    // the interior of the rrect if the radii are >= 0.5. Otherwise, the inner rect of the nine-
    // patch will have fractional coverage. This only matters when the interior is actually filled.
    // We could consider falling back to rect rendering here, since a tiny radius is
    // indistinguishable from a square corner.
    if (!isStrokeOnly && (SK_ScalarHalf > xRadius || SK_ScalarHalf > yRadius)) {
        return nullptr;
    }
 
    // if the corners are circles, use the circle renderer
    return EllipticalRRectOp::Make(context, std::move(paint), viewMatrix, bounds,
                                   xRadius, yRadius, scaledStroke, isStrokeOnly);
}

rrect_type_to_index_count()

static int rrect_type_to_index_count ( RRectType  type )

static

Definition at line 2478 of file GrOvalOpFactory.cpp.

                                                     {
    switch (type) {
        case kFill_RRectType:
            return kIndicesPerFillRRect;
        case kStroke_RRectType:
            return kIndicesPerStrokeRRect;
        case kOverstroke_RRectType:
            return kIndicesPerOverstrokeRRect;
    }
    SK_ABORT("Invalid type");
}

rrect_type_to_indices()

static const uint16_t * rrect_type_to_indices ( RRectType  type )

static

Definition at line 2490 of file GrOvalOpFactory.cpp.

                                                             {
    switch (type) {
        case kFill_RRectType:
        case kStroke_RRectType:
            return gStandardRRectIndices;
        case kOverstroke_RRectType:
            return gOverstrokeRRectIndices;
    }
    SK_ABORT("Invalid type");
}

rrect_type_to_vert_count()

static int rrect_type_to_vert_count ( RRectType  type )

static

Definition at line 2467 of file GrOvalOpFactory.cpp.

                                                    {
    switch (type) {
        case kFill_RRectType:
        case kStroke_RRectType:
            return kVertsPerStandardRRect;
        case kOverstroke_RRectType:
            return kVertsPerOverstrokeRRect;
    }
    SK_ABORT("Invalid type");
}

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [1/2]

SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gRRectOnlyIndexBufferKey

)

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [2/2]

SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gStrokeRRectOnlyIndexBufferKey

)

Variable Documentation

gFillCircleIndices

const uint16_t gFillCircleIndices[]

static

Initial value:

= {
        
        
        0, 1, 8, 1, 2, 8,
        2, 3, 8, 3, 4, 8,
        4, 5, 8, 5, 6, 8,
        6, 7, 8, 7, 0, 8
        
}

Definition at line 913 of file GrOvalOpFactory.cpp.

                                             {
        // enter the octagon
        // clang-format off
        0, 1, 8, 1, 2, 8,
        2, 3, 8, 3, 4, 8,
        4, 5, 8, 5, 6, 8,
        6, 7, 8, 7, 0, 8
        // clang-format on
};

gOverstrokeRRectIndices

const uint16_t gOverstrokeRRectIndices[]

static

Initial value:

= {
        
        
        
        16, 17, 19, 16, 19, 18,
        19, 17, 23, 19, 23, 21,
        21, 23, 22, 21, 22, 20,
        22, 16, 18, 22, 18, 20,
 
        
        0, 1, 5, 0, 5, 4,
        2, 3, 7, 2, 7, 6,
        8, 9, 13, 8, 13, 12,
        10, 11, 15, 10, 15, 14,
 
        
        1, 2, 6, 1, 6, 5,
        4, 5, 9, 4, 9, 8,
        6, 7, 11, 6, 11, 10,
        9, 10, 14, 9, 14, 13,
 
        
        
        5, 6, 10, 5, 10, 9,
        
}

Definition at line 2422 of file GrOvalOpFactory.cpp.

                                                  {
        // clang-format off
        // overstroke quads
        // we place this at the beginning so that we can skip these indices when rendering normally
        16, 17, 19, 16, 19, 18,
        19, 17, 23, 19, 23, 21,
        21, 23, 22, 21, 22, 20,
        22, 16, 18, 22, 18, 20,
 
        // corners
        0, 1, 5, 0, 5, 4,
        2, 3, 7, 2, 7, 6,
        8, 9, 13, 8, 13, 12,
        10, 11, 15, 10, 15, 14,
 
        // edges
        1, 2, 6, 1, 6, 5,
        4, 5, 9, 4, 9, 8,
        6, 7, 11, 6, 11, 10,
        9, 10, 14, 9, 14, 13,
 
        // center
        // we place this at the end so that we can ignore these indices when not rendering as filled
        5, 6, 10, 5, 10, 9,
        // clang-format on
};

gStandardRRectIndices

const uint16_t* gStandardRRectIndices = gOverstrokeRRectIndices + 6 * 4

static

Definition at line 2450 of file GrOvalOpFactory.cpp.

gStrokeCircleIndices

const uint16_t gStrokeCircleIndices[]

static

Initial value:

= {
        
        
        0, 1,  9, 0, 9,   8,
        1, 2, 10, 1, 10,  9,
        2, 3, 11, 2, 11, 10,
        3, 4, 12, 3, 12, 11,
        4, 5, 13, 4, 13, 12,
        5, 6, 14, 5, 14, 13,
        6, 7, 15, 6, 15, 14,
        7, 0,  8, 7,  8, 15,
        
}

Definition at line 924 of file GrOvalOpFactory.cpp.

                                               {
        // enter the octagon
        // clang-format off
        0, 1,  9, 0, 9,   8,
        1, 2, 10, 1, 10,  9,
        2, 3, 11, 2, 11, 10,
        3, 4, 12, 3, 12, 11,
        4, 5, 13, 4, 13, 12,
        5, 6, 14, 5, 14, 13,
        6, 7, 15, 6, 15, 14,
        7, 0,  8, 7,  8, 15,
        // clang-format on
};

kCosPi8

constexpr SkScalar kCosPi8 = 0.923579533f

staticconstexpr

Definition at line 953 of file GrOvalOpFactory.cpp.

kIndicesPerFillCircle

const int kIndicesPerFillCircle = std::size(gFillCircleIndices)

static

Definition at line 966 of file GrOvalOpFactory.cpp.

kIndicesPerFillRRect

const int kIndicesPerFillRRect = kIndicesPerOverstrokeRRect - 6 * 4 + 6

static

Definition at line 2455 of file GrOvalOpFactory.cpp.

kIndicesPerOverstrokeRRect

const int kIndicesPerOverstrokeRRect = std::size(gOverstrokeRRectIndices) - 6

static

Definition at line 2453 of file GrOvalOpFactory.cpp.

kIndicesPerStrokeCircle

const int kIndicesPerStrokeCircle = std::size(gStrokeCircleIndices)

static

Definition at line 967 of file GrOvalOpFactory.cpp.

kIndicesPerStrokeRRect

const int kIndicesPerStrokeRRect = kIndicesPerFillRRect - 6

static

Definition at line 2457 of file GrOvalOpFactory.cpp.

kNumRRectsInIndexBuffer

const int kNumRRectsInIndexBuffer = 256

static

Definition at line 2854 of file GrOvalOpFactory.cpp.

kOctagonInner

constexpr SkPoint kOctagonInner[]

staticconstexpr

Initial value:

= {
    SkPoint::Make(-kSinPi8, -kCosPi8),
    SkPoint::Make( kSinPi8, -kCosPi8),
    SkPoint::Make( kCosPi8, -kSinPi8),
    SkPoint::Make( kCosPi8,  kSinPi8),
    SkPoint::Make( kSinPi8,  kCosPi8),
    SkPoint::Make(-kSinPi8,  kCosPi8),
    SkPoint::Make(-kCosPi8,  kSinPi8),
    SkPoint::Make(-kCosPi8, -kSinPi8),
}

Definition at line 955 of file GrOvalOpFactory.cpp.

                                           {
    SkPoint::Make(-kSinPi8, -kCosPi8),
    SkPoint::Make( kSinPi8, -kCosPi8),
    SkPoint::Make( kCosPi8, -kSinPi8),
    SkPoint::Make( kCosPi8,  kSinPi8),
    SkPoint::Make( kSinPi8,  kCosPi8),
    SkPoint::Make(-kSinPi8,  kCosPi8),
    SkPoint::Make(-kCosPi8,  kSinPi8),
    SkPoint::Make(-kCosPi8, -kSinPi8),
};

kOctagonOuter

constexpr SkPoint kOctagonOuter[]

staticconstexpr

Initial value:

= {
    SkPoint::Make(-kOctOffset, -1),
    SkPoint::Make( kOctOffset, -1),
    SkPoint::Make( 1, -kOctOffset),
    SkPoint::Make( 1,  kOctOffset),
    SkPoint::Make( kOctOffset, 1),
    SkPoint::Make(-kOctOffset, 1),
    SkPoint::Make(-1,  kOctOffset),
    SkPoint::Make(-1, -kOctOffset),
}

Definition at line 941 of file GrOvalOpFactory.cpp.

                                           {
    SkPoint::Make(-kOctOffset, -1),
    SkPoint::Make( kOctOffset, -1),
    SkPoint::Make( 1, -kOctOffset),
    SkPoint::Make( 1,  kOctOffset),
    SkPoint::Make( kOctOffset, 1),
    SkPoint::Make(-kOctOffset, 1),
    SkPoint::Make(-1,  kOctOffset),
    SkPoint::Make(-1, -kOctOffset),
};

kOctOffset

constexpr SkScalar kOctOffset = 0.41421356237f

staticconstexpr

Definition at line 940 of file GrOvalOpFactory.cpp.

kSinPi8

constexpr SkScalar kSinPi8 = 0.382683432f

staticconstexpr

Definition at line 954 of file GrOvalOpFactory.cpp.

kVertsPerFillCircle

const int kVertsPerFillCircle = 9

static

Definition at line 969 of file GrOvalOpFactory.cpp.

kVertsPerOverstrokeRRect

const int kVertsPerOverstrokeRRect = 24

static

Definition at line 2459 of file GrOvalOpFactory.cpp.

kVertsPerStandardRRect

const int kVertsPerStandardRRect = 16

static

Definition at line 2458 of file GrOvalOpFactory.cpp.

kVertsPerStrokeCircle

const int kVertsPerStrokeCircle = 16

static

Definition at line 968 of file GrOvalOpFactory.cpp.