lazytiling.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/gpu/GrDirectContext.h"
#include "src/base/SkRectMemcpy.h"
#include "src/core/SkCanvasPriv.h"
#include "src/core/SkConvertPixels.h"
#include "src/gpu/ganesh/GrCanvas.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrPaint.h"
#include "src/gpu/ganesh/GrProxyProvider.h"
#include "src/gpu/ganesh/GrResourceProvider.h"
#include "src/gpu/ganesh/GrTexture.h"
#include "src/gpu/ganesh/SkGr.h"
#include "src/gpu/ganesh/SurfaceDrawContext.h"
#include "src/gpu/ganesh/effects/GrTextureEffect.h"
#include "tools/gpu/ProxyUtils.h"

Go to the source code of this file.

Classes
class	skiagm::LazyTilingGM

Namespaces
namespace	skiagm

Macros
#define	USE_LAZY_PROXIES   1

Functions
static GrSurfaceProxyView	create_view (GrDirectContext *dContext, const SkBitmap &src, GrSurfaceOrigin origin)
static SkBitmap	create_bitmap (SkIRect contentRect, SkISize fullSize, GrSurfaceOrigin origin)
static void	draw_texture (const GrCaps *caps, skgpu::ganesh::SurfaceDrawContext *sdc, const GrSurfaceProxyView &src, const SkIRect &srcRect, const SkIRect &drawRect, const SkMatrix &mat, GrSamplerState::WrapMode xTileMode, GrSamplerState::WrapMode yTileMode)

Macro Definition Documentation

USE_LAZY_PROXIES

#define USE_LAZY_PROXIES   1

Function Documentation

create_bitmap()

static SkBitmap create_bitmap ( SkIRect  contentRect, SkISize  fullSize, GrSurfaceOrigin  origin  )

static

Definition at line 90 of file lazytiling.cpp.

                                                                                             {
 
    const int kContentSize = contentRect.width();
    SkBitmap contentBM;
 
    {
        SkImageInfo contentInfo = SkImageInfo::Make(kContentSize, kContentSize,
                                                    kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
        contentBM.allocPixels(contentInfo);
 
        contentBM.eraseColor(SK_ColorWHITE);
 
        const int halfM1 = kContentSize/2 - 1;
 
        // The coordinate frame
        contentBM.eraseArea(SkIRect::MakeXYWH(halfM1, 2,2, halfM1), SK_ColorGRAY);
        contentBM.eraseArea(SkIRect::MakeXYWH(2, halfM1, kContentSize-4, 2), SK_ColorGRAY);
 
        contentBM.eraseArea(SkIRect::MakeXYWH(2, halfM1, 2, 2), SK_ColorRED);
        contentBM.eraseArea(SkIRect::MakeXYWH(kContentSize-4, halfM1, 2, 2), SK_ColorGREEN);
 
        // The 1-pixel wide rim around the content rect
        contentBM.eraseArea(SkIRect::MakeXYWH(0, 0, kContentSize, 1), SK_ColorBLUE);
        contentBM.eraseArea(SkIRect::MakeXYWH(0, 0, 1, kContentSize), SK_ColorBLUE);
        contentBM.eraseArea(SkIRect::MakeXYWH(kContentSize-1, 0, 1, kContentSize), SK_ColorBLUE);
        contentBM.eraseArea(SkIRect::MakeXYWH(0, kContentSize-1, kContentSize, 1), SK_ColorBLUE);
    }
 
    SkBitmap bigBM;
 
    {
        const int kLeft = contentRect.fLeft;
        const int kTop  = contentRect.fTop;
 
        SkImageInfo bigInfo = SkImageInfo::Make(fullSize.fWidth, fullSize.fHeight,
                                                kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
 
        bigBM.allocPixels(bigInfo);
 
        bigBM.eraseColor(SK_ColorBLACK);
 
        const char* src = static_cast<const char*>(contentBM.getPixels());
        size_t srcRB = contentBM.rowBytes();
        size_t dstRB = bigBM.rowBytes();
 
        if (USE_LAZY_PROXIES && origin == kBottomLeft_GrSurfaceOrigin) {
            char* dst = static_cast<char*>(bigBM.getAddr(kLeft, fullSize.height() - kTop - 1));
            for (int y = 0; y < contentBM.height(); ++y) {
                memcpy(dst, src, srcRB);
                src = src + srcRB;
                dst = dst - dstRB;
            }
        } else {
            char* dst = static_cast<char*>(bigBM.getAddr(kLeft, kTop));
            SkRectMemcpy(dst, dstRB, src, srcRB,
                         contentBM.rowBytes(), contentBM.height());
        }
 
        bigBM.setAlphaType(kOpaque_SkAlphaType);
        bigBM.setImmutable();
    }
 
    return bigBM;
}

create_view()

static GrSurfaceProxyView create_view ( GrDirectContext *  dContext, const SkBitmap &  src, GrSurfaceOrigin  origin  )

static

Definition at line 31 of file lazytiling.cpp.

                                                              {
    SkASSERT(src.colorType() == kRGBA_8888_SkColorType);
 
#define USE_LAZY_PROXIES 1 // Toggle this to generate the reference images
 
    if (USE_LAZY_PROXIES) {
        auto format = dContext->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888,
                                                                       GrRenderable::kNo);
        if (!format.isValid()) {
            return {};
        }
 
        sk_sp<GrTextureProxy> proxy = GrProxyProvider::MakeFullyLazyProxy(
                [src](GrResourceProvider* rp, const GrSurfaceProxy::LazySurfaceDesc& desc)
                        -> GrSurfaceProxy::LazyCallbackResult {
                    SkASSERT(desc.fMipmapped == skgpu::Mipmapped::kNo);
                    GrMipLevel mipLevel = {src.getPixels(), src.rowBytes(), nullptr};
                    auto colorType = SkColorTypeToGrColorType(src.colorType());
 
                    return rp->createTexture(src.dimensions(),
                                             desc.fFormat,
                                             desc.fTextureType,
                                             colorType,
                                             desc.fRenderable,
                                             desc.fSampleCnt,
                                             desc.fBudgeted,
                                             desc.fFit,
                                             desc.fProtected,
                                             mipLevel,
                                             desc.fLabel);
                },
                format,
                GrRenderable::kNo,
                1,
                GrProtected::kNo,
                *dContext->priv().caps(),
                GrSurfaceProxy::UseAllocator::kYes);
 
        if (!proxy) {
            return {};
        }
 
        auto swizzle = dContext->priv().caps()->getReadSwizzle(proxy->backendFormat(),
                                                               GrColorType::kRGBA_8888);
        return GrSurfaceProxyView(std::move(proxy), origin, swizzle);
    }
 
    return sk_gpu_test::MakeTextureProxyViewFromData(dContext,
                                                     GrRenderable::kNo,
                                                     origin,
                                                     src.pixmap());
}

draw_texture()

static void draw_texture ( const GrCaps *  caps, skgpu::ganesh::SurfaceDrawContext *  sdc, const GrSurfaceProxyView &  src, const SkIRect &  srcRect, const SkIRect &  drawRect, const SkMatrix &  mat, GrSamplerState::WrapMode  xTileMode, GrSamplerState::WrapMode  yTileMode  )

static

Definition at line 155 of file lazytiling.cpp.

                                                           {
    GrSamplerState sampler(xTileMode, yTileMode, SkFilterMode::kNearest);
 
    auto fp = GrTextureEffect::MakeSubset(src, kOpaque_SkAlphaType, mat,
                                          sampler, SkRect::Make(srcRect), *caps);
    GrPaint paint;
    paint.setColorFragmentProcessor(std::move(fp));
 
    sdc->drawRect(nullptr, std::move(paint), GrAA::kNo, SkMatrix::I(), SkRect::Make(drawRect));
}