compositor_quads.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkData.h"
#include "include/core/SkFont.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkColorMatrix.h"
#include "include/effects/SkGradientShader.h"
#include "include/effects/SkImageFilters.h"
#include "include/effects/SkShaderMaskFilter.h"
#include "include/private/base/SkTArray.h"
#include "src/core/SkLineClipper.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/gpu/YUVUtils.h"
#include <array>
#include <memory>
#include <utility>

Go to the source code of this file.

Classes
class	ClipTileRenderer
class	CompositorGM
class	DebugTileRenderer
class	SolidColorRenderer
class	TextureSetRenderer
class	YUVTextureSetRenderer

Typedefs
using	ClipTileRendererArray = TArray< sk_sp< ClipTileRenderer > >

Functions
static void	clipping_line_segment (const SkPoint &p0, const SkPoint &p1, SkPoint line[2])
static bool	intersect_line_segments (const SkPoint &p0, const SkPoint &p1, const SkPoint &l0, const SkPoint &l1, SkPoint *intersect)
static void	draw_outset_line (SkCanvas *canvas, const SkMatrix &local, const SkPoint pts[2], const SkPaint &paint)
static void	draw_tile_boundaries (SkCanvas *canvas, const SkMatrix &local)
static void	draw_clipping_boundaries (SkCanvas *canvas, const SkMatrix &local)
static void	draw_text (SkCanvas *canvas, const char *text)
static ClipTileRendererArray	make_debug_renderers ()
static ClipTileRendererArray	make_solid_color_renderers ()
static ClipTileRendererArray	make_shader_renderers ()
static ClipTileRendererArray	make_image_renderers ()
static ClipTileRendererArray	make_filtered_renderers ()

Variables
static constexpr SkScalar	kTileWidth = 40
static constexpr SkScalar	kTileHeight = 30
static constexpr int	kRowCount = 4
static constexpr int	kColCount = 3
static constexpr SkPoint	kClipP1 = {1.75f * kTileWidth, 0.8f * kTileHeight}
static constexpr SkPoint	kClipP2 = {0.6f * kTileWidth, 2.f * kTileHeight}
static constexpr SkPoint	kClipP3 = {2.9f * kTileWidth, 3.5f * kTileHeight}
static constexpr int	kMatrixCount = 5

Typedef Documentation

ClipTileRendererArray

using ClipTileRendererArray = TArray<sk_sp<ClipTileRenderer> >

Definition at line 53 of file compositor_quads.cpp.

Function Documentation

clipping_line_segment()

static void clipping_line_segment ( const SkPoint &  p0, const SkPoint &  p1, SkPoint  line[2]  )

static

Definition at line 78 of file compositor_quads.cpp.

                                                                                         {
    SkVector v = p1 - p0;
    // 10f was chosen as a balance between large enough to scale the currently set clip
    // points outside of the tile grid, but small enough to preserve precision.
    line[0] = p0 - v * 10.f;
    line[1] = p1 + v * 10.f;
}

draw_clipping_boundaries()

static void draw_clipping_boundaries ( SkCanvas *  canvas, const SkMatrix &  local  )

static

Definition at line 167 of file compositor_quads.cpp.

                                                                              {
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setColor(SK_ColorGREEN);
    paint.setStyle(SkPaint::kStroke_Style);
    paint.setStrokeWidth(0.f);
 
    // Clip the "infinite" line segments to a rectangular region outside the tile grid
    SkRect border = SkRect::MakeWH(kTileWidth * kColCount, kTileHeight * kRowCount);
 
    // Draw p1 to p2
    SkPoint line[2];
    SkPoint clippedLine[2];
    clipping_line_segment(kClipP1, kClipP2, line);
    SkAssertResult(SkLineClipper::IntersectLine(line, border, clippedLine));
    draw_outset_line(canvas, local, clippedLine, paint);
 
    // Draw p2 to p3
    clipping_line_segment(kClipP2, kClipP3, line);
    SkAssertResult(SkLineClipper::IntersectLine(line, border, clippedLine));
    draw_outset_line(canvas, local, clippedLine, paint);
 
    // Draw p3 to p1
    clipping_line_segment(kClipP3, kClipP1, line);
    SkAssertResult(SkLineClipper::IntersectLine(line, border, clippedLine));
    draw_outset_line(canvas, local, clippedLine, paint);
}

draw_outset_line()

static void draw_outset_line ( SkCanvas *  canvas, const SkMatrix &  local, const SkPoint  pts[2], const SkPaint &  paint  )

static

Definition at line 139 of file compositor_quads.cpp.

                                                   {
    static constexpr SkScalar kLineOutset = 10.f;
    SkPoint mapped[2];
    local.mapPoints(mapped, pts, 2);
    SkVector v = mapped[1] - mapped[0];
    v.setLength(v.length() + kLineOutset);
    canvas->drawLine(mapped[1] - v, mapped[0] + v, paint);
}

draw_text()

static void draw_text ( SkCanvas *  canvas, const char *  text  )

static

Definition at line 195 of file compositor_quads.cpp.

                                                          {
    SkFont font(ToolUtils::DefaultPortableTypeface(), 12);
    canvas->drawString(text, 0, 0, font, SkPaint());
}

draw_tile_boundaries()

static void draw_tile_boundaries ( SkCanvas *  canvas, const SkMatrix &  local  )

static

Definition at line 150 of file compositor_quads.cpp.

                                                                          {
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setColor(SK_ColorRED);
    paint.setStyle(SkPaint::kStroke_Style);
    paint.setStrokeWidth(0.f);
    for (int x = 1; x < kColCount; ++x) {
        SkPoint pts[] = {{x * kTileWidth, 0}, {x * kTileWidth, kRowCount * kTileHeight}};
        draw_outset_line(canvas, local, pts, paint);
    }
    for (int y = 1; y < kRowCount; ++y) {
        SkPoint pts[] = {{0, y * kTileHeight}, {kTileWidth * kColCount, y * kTileHeight}};
        draw_outset_line(canvas, local, pts, paint);
    }
}

intersect_line_segments()

static bool intersect_line_segments ( const SkPoint &  p0, const SkPoint &  p1, const SkPoint &  l0, const SkPoint &  l1, SkPoint *  intersect  )

static

Definition at line 88 of file compositor_quads.cpp.

                                                                                              {
    static constexpr SkScalar kHorizontalTolerance = 0.01f; // Pretty conservative
 
    // Use doubles for accuracy, since the clipping strategy used below can create T
    // junctions, and lower precision could artificially create gaps
    double pY = (double) p1.fY - (double) p0.fY;
    double pX = (double) p1.fX - (double) p0.fX;
    double lY = (double) l1.fY - (double) l0.fY;
    double lX = (double) l1.fX - (double) l0.fX;
    double plY = (double) p0.fY - (double) l0.fY;
    double plX = (double) p0.fX - (double) l0.fX;
    if (SkScalarNearlyZero(pY, kHorizontalTolerance)) {
        if (SkScalarNearlyZero(lY, kHorizontalTolerance)) {
            // Two horizontal lines
            return false;
        } else {
            // Recalculate but swap p and l
            return intersect_line_segments(l0, l1, p0, p1, intersect);
        }
    }
 
    // Up to now, the line segments do not form an invalid intersection
    double lNumerator = plX * pY - plY * pX;
    double lDenom = lX * pY - lY * pX;
    if (SkScalarNearlyZero(lDenom)) {
        // Parallel or identical
        return false;
    }
 
    // Calculate alphaL that provides the intersection point along (l0-l1), e.g. l0+alphaL*(l1-l0)
    double alphaL = lNumerator / lDenom;
    if (alphaL < 0.0 || alphaL > 1.0) {
        // Outside of the l segment
        return false;
    }
 
    // Calculate alphaP from the valid alphaL (since it could be outside p segment)
    // double alphaP = (alphaL * l.fY - pl.fY) / p.fY;
    double alphaP = (alphaL * lY - plY) / pY;
    if (alphaP < 0.0 || alphaP > 1.0) {
        // Outside of p segment
        return false;
    }
 
    // Is valid, so calculate the actual intersection point
    *intersect = l1 * SkScalar(alphaL) + l0 * SkScalar(1.0 - alphaL);
    return true;
}

make_debug_renderers()

static ClipTileRendererArray make_debug_renderers ( )

static

Definition at line 995 of file compositor_quads.cpp.

                                                    {
    return ClipTileRendererArray{DebugTileRenderer::Make(),
                                 DebugTileRenderer::MakeAA(),
                                 DebugTileRenderer::MakeNonAA()};
}

make_filtered_renderers()

static ClipTileRendererArray make_filtered_renderers ( )

static

Definition at line 1031 of file compositor_quads.cpp.

                                                       {
    sk_sp<SkImage> mandrill = ToolUtils::GetResourceAsImage("images/mandrill_512.png");
 
    SkColorMatrix cm;
    cm.setSaturation(10);
    sk_sp<SkColorFilter> colorFilter = SkColorFilters::Matrix(cm);
    sk_sp<SkImageFilter> imageFilter = SkImageFilters::Dilate(8, 8, nullptr);
 
    static constexpr SkColor kAlphas[] = { SK_ColorTRANSPARENT, SK_ColorBLACK };
    auto alphaGradient = SkGradientShader::MakeRadial(
            {0.5f * kTileWidth * kColCount, 0.5f * kTileHeight * kRowCount},
            0.25f * kTileWidth * kColCount, kAlphas, nullptr, 2, SkTileMode::kClamp);
    sk_sp<SkMaskFilter> maskFilter = SkShaderMaskFilter::Make(std::move(alphaGradient));
 
    return ClipTileRendererArray{
               TextureSetRenderer::MakeAlpha(mandrill, 0.5f),
               TextureSetRenderer::MakeColorFilter("Saturation", mandrill, std::move(colorFilter)),
 
    // NOTE: won't draw correctly until SkCanvas' AutoLoopers are used to handle image filters
               TextureSetRenderer::MakeImageFilter("Dilate", mandrill, std::move(imageFilter)),
 
    // NOTE: blur mask filters do work (tested locally), but visually they don't make much
    // sense, since each quad is blurred independently
               TextureSetRenderer::MakeMaskFilter("Shader", mandrill, std::move(maskFilter))};
}

make_image_renderers()

static ClipTileRendererArray make_image_renderers ( )

static

Definition at line 1022 of file compositor_quads.cpp.

                                                    {
    sk_sp<SkImage> mandrill = ToolUtils::GetResourceAsImage("images/mandrill_512.png");
    sk_sp<SkData> mandrillJpeg = GetResourceAsData("images/mandrill_h1v1.jpg");
    return ClipTileRendererArray{TextureSetRenderer::MakeUnbatched(mandrill),
                                 TextureSetRenderer::MakeBatched(mandrill, 0),
                                 TextureSetRenderer::MakeBatched(mandrill, kMatrixCount),
                                 YUVTextureSetRenderer::MakeFromJPEG(mandrillJpeg)};
}

make_shader_renderers()

static ClipTileRendererArray make_shader_renderers ( )

static

Definition at line 1005 of file compositor_quads.cpp.

                                                     {
    static constexpr SkPoint kPts[] = { {0.f, 0.f}, {0.25f * kTileWidth, 0.25f * kTileHeight} };
    static constexpr SkColor kColors[] = { SK_ColorBLUE, SK_ColorWHITE };
    auto gradient = SkGradientShader::MakeLinear(kPts, kColors, nullptr, 2,
                                                 SkTileMode::kMirror);
 
    auto info = SkImageInfo::Make(1, 1, kAlpha_8_SkColorType, kOpaque_SkAlphaType);
    SkBitmap bm;
    bm.allocPixels(info);
    bm.eraseColor(SK_ColorWHITE);
    sk_sp<SkImage> image = bm.asImage();
 
    return ClipTileRendererArray{
               TextureSetRenderer::MakeShader("Gradient", image, gradient, false),
               TextureSetRenderer::MakeShader("Local Gradient", image, gradient, true)};
}

make_solid_color_renderers()

static ClipTileRendererArray make_solid_color_renderers ( )

static

Definition at line 1001 of file compositor_quads.cpp.

                                                          {
    return ClipTileRendererArray{SolidColorRenderer::Make({.2f, .8f, .3f, 1.f})};
}

Variable Documentation

kClipP1

constexpr SkPoint kClipP1 = {1.75f * kTileWidth, 0.8f * kTileHeight}

staticconstexpr

Definition at line 68 of file compositor_quads.cpp.

{1.75f * kTileWidth, 0.8f * kTileHeight};

kClipP2

constexpr SkPoint kClipP2 = {0.6f * kTileWidth, 2.f * kTileHeight}

staticconstexpr

Definition at line 69 of file compositor_quads.cpp.

{0.6f * kTileWidth, 2.f * kTileHeight};

kClipP3

constexpr SkPoint kClipP3 = {2.9f * kTileWidth, 3.5f * kTileHeight}

staticconstexpr

Definition at line 70 of file compositor_quads.cpp.

{2.9f * kTileWidth, 3.5f * kTileHeight};

kColCount

constexpr int kColCount = 3

staticconstexpr

Definition at line 63 of file compositor_quads.cpp.

kMatrixCount

constexpr int kMatrixCount = 5

staticconstexpr

Definition at line 420 of file compositor_quads.cpp.

kRowCount

constexpr int kRowCount = 4

staticconstexpr

Definition at line 62 of file compositor_quads.cpp.

kTileHeight

constexpr SkScalar kTileHeight = 30

staticconstexpr

Definition at line 60 of file compositor_quads.cpp.

kTileWidth

constexpr SkScalar kTileWidth = 40

staticconstexpr

Definition at line 59 of file compositor_quads.cpp.