SkDraw_vertices.cpp File Reference

#include "include/core/SkAlphaType.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkBlender.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkPoint3.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTypes.h"
#include "include/core/SkVertices.h"
#include "include/private/SkColorData.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkBlenderBase.h"
#include "src/core/SkConvertPixels.h"
#include "src/core/SkCoreBlitters.h"
#include "src/core/SkDraw.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkScan.h"
#include "src/core/SkSurfacePriv.h"
#include "src/core/SkVertState.h"
#include "src/core/SkVerticesPriv.h"
#include "src/shaders/SkShaderBase.h"
#include "src/shaders/SkTransformShader.h"
#include "src/shaders/SkTriColorShader.h"
#include <cstddef>
#include <cstdint>
#include <optional>
#include <utility>

Go to the source code of this file.

Functions
static bool	texture_to_matrix (const VertState &state, const SkPoint verts[], const SkPoint texs[], SkMatrix *matrix)
static SkPMColor4f *	convert_colors (const SkColor src[], int count, SkColorSpace *deviceCS, SkArenaAlloc *alloc, bool skipColorXform)
static bool	compute_is_opaque (const SkColor colors[], int count)
static void	fill_triangle_2 (const VertState &state, SkBlitter *blitter, const SkRasterClip &rc, const SkPoint dev2[])
static void	fill_triangle_3 (const VertState &state, SkBlitter *blitter, const SkRasterClip &rc, const SkPoint3 dev3[])
static void	fill_triangle (const VertState &state, SkBlitter *blitter, const SkRasterClip &rc, const SkPoint dev2[], const SkPoint3 dev3[])

Variables
static constexpr int	kMaxClippedTrianglePointCount = 4

Function Documentation

compute_is_opaque()

static bool compute_is_opaque ( const SkColor  colors[], int  count  )

static

Definition at line 90 of file SkDraw_vertices.cpp.

                                                                 {
    uint32_t c = ~0;
    for (int i = 0; i < count; ++i) {
        c &= colors[i];
    }
    return SkColorGetA(c) == 0xFF;
}

convert_colors()

static SkPMColor4f * convert_colors ( const SkColor  src[], int  count, SkColorSpace *  deviceCS, SkArenaAlloc *  alloc, bool  skipColorXform  )

static

Definition at line 73 of file SkDraw_vertices.cpp.

                                                        {
    SkPMColor4f* dst = alloc->makeArray<SkPMColor4f>(count);
 
    // Passing `nullptr` for the destination CS effectively disables color conversion.
    auto dstCS = skipColorXform ? nullptr : sk_ref_sp(deviceCS);
    SkImageInfo srcInfo = SkImageInfo::Make(
            count, 1, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType, SkColorSpace::MakeSRGB());
    SkImageInfo dstInfo =
            SkImageInfo::Make(count, 1, kRGBA_F32_SkColorType, kPremul_SkAlphaType, dstCS);
    SkAssertResult(SkConvertPixels(dstInfo, dst, 0, srcInfo, src, 0));
    return dst;
}

fill_triangle()

static void fill_triangle ( const VertState &  state, SkBlitter *  blitter, const SkRasterClip &  rc, const SkPoint  dev2[], const SkPoint3  dev3[]  )

static

Definition at line 178 of file SkDraw_vertices.cpp.

                                                                       {
    if (dev3) {
        fill_triangle_3(state, blitter, rc, dev3);
    } else {
        fill_triangle_2(state, blitter, rc, dev2);
    }
}

fill_triangle_2()

static void fill_triangle_2 ( const VertState &  state, SkBlitter *  blitter, const SkRasterClip &  rc, const SkPoint  dev2[]  )

static

Definition at line 98 of file SkDraw_vertices.cpp.

                                                  {
    SkPoint tmp[] = {
        dev2[state.f0], dev2[state.f1], dev2[state.f2]
    };
    SkScan::FillTriangle(tmp, rc, blitter);
}

fill_triangle_3()

static void fill_triangle_3 ( const VertState &  state, SkBlitter *  blitter, const SkRasterClip &  rc, const SkPoint3  dev3[]  )

static

Definition at line 107 of file SkDraw_vertices.cpp.

                                                   {
    // Compute the crossing point (across zero) for the two values, expressed as a
    // normalized 0...1 value. If curr is 0, returns 0. If next is 0, returns 1.
    auto computeT = [](float curr, float next) {
        // Check that 0 is between next and curr.
        SkASSERT((next <= 0 && 0 < curr) || (curr <= 0 && 0 < next));
        float t = curr / (curr - next);
        SkASSERT(0 <= t && t <= 1);
        return t;
    };
 
    auto lerp = [](SkPoint3 curr, SkPoint3 next, float t) {
        return curr + t * (next - curr);
    };
 
    constexpr float tol = 0.05f;
    // tol is the nudge away from zero, to keep the numerics nice.
    // Think of it as our near-clipping-plane (or w-plane).
    auto clip = [&](SkPoint3 curr, SkPoint3 next) {
        // Return the point between curr and next where the fZ value crosses tol.
        // To be (really) perspective correct, we should be computing based on 1/Z, not Z.
        // For now, this is close enough (and faster).
        return lerp(curr, next, computeT(curr.fZ - tol, next.fZ - tol));
    };
 
    // Clip a triangle (based on its homogeneous W values), and return the projected polygon.
    // Since we only clip against one "edge"/plane, the max number of points in the clipped
    // polygon is 4.
    auto clipTriangle = [&](SkPoint dst[], const int idx[3], const SkPoint3 pts[]) -> int {
        SkPoint3 outPoints[kMaxClippedTrianglePointCount];
        SkPoint3* outP = outPoints;
 
        for (int i = 0; i < 3; ++i) {
            int curr = idx[i];
            int next = idx[(i + 1) % 3];
            if (pts[curr].fZ > tol) {
                *outP++ = pts[curr];
                if (pts[next].fZ <= tol) { // curr is IN, next is OUT
                    *outP++ = clip(pts[curr], pts[next]);
                }
            } else {
                if (pts[next].fZ > tol) { // curr is OUT, next is IN
                    *outP++ = clip(pts[curr], pts[next]);
                }
            }
        }
 
        const int count = SkTo<int>(outP - outPoints);
        SkASSERT(count == 0 || count == 3 || count == 4);
        for (int i = 0; i < count; ++i) {
            float scale = sk_ieee_float_divide(1.0f, outPoints[i].fZ);
            dst[i].set(outPoints[i].fX * scale, outPoints[i].fY * scale);
        }
        return count;
    };
 
    SkPoint tmp[kMaxClippedTrianglePointCount];
    int idx[] = { state.f0, state.f1, state.f2 };
    if (int n = clipTriangle(tmp, idx, dev3)) {
        // TODO: SkScan::FillConvexPoly(tmp, n, ...);
        SkASSERT(n == 3 || n == 4);
        SkScan::FillTriangle(tmp, rc, blitter);
        if (n == 4) {
            tmp[1] = tmp[2];
            tmp[2] = tmp[3];
            SkScan::FillTriangle(tmp, rc, blitter);
        }
    }
}

texture_to_matrix()

static bool texture_to_matrix ( const VertState &  state, const SkPoint  verts[], const SkPoint  texs[], SkMatrix *  matrix  )

static

Definition at line 51 of file SkDraw_vertices.cpp.

                                                                                    {
    SkPoint src[3], dst[3];
 
    src[0] = verts[state.f0];
    src[1] = verts[state.f1];
    src[2] = verts[state.f2];
    dst[0] = texs[state.f0];
    dst[1] = texs[state.f1];
    dst[2] = texs[state.f2];
    return matrix->setPolyToPoly(src, dst, 3);
}

Variable Documentation

kMaxClippedTrianglePointCount

constexpr int kMaxClippedTrianglePointCount = 4

staticconstexpr

Definition at line 106 of file SkDraw_vertices.cpp.