788b91678f
Use std::min and std::max everywhere. SkTPin still exists. We can't use std::clamp yet, and even when we can, it has undefined behavior with NaN. SkTPin is written to ensure that we return a value in the [lo, hi] range. Change-Id: I506852a36e024ae405358d5078a872e2c77fa71e Docs-Preview: https://skia.org/?cl=269357 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/269357 Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Mike Reed <reed@google.com> Reviewed-by: Brian Salomon <bsalomon@google.com>
158 lines
5.2 KiB
C++
158 lines
5.2 KiB
C++
/*
|
|
* Copyright 2019 Google Inc. and Adobe Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "include/core/SkCanvas.h"
|
|
#include "include/core/SkPaint.h"
|
|
#include "include/core/SkSurface.h"
|
|
#include "include/core/SkTypes.h"
|
|
#include "include/gpu/GrContext.h"
|
|
#include "samplecode/Sample.h"
|
|
#include "tools/timer/TimeUtils.h"
|
|
|
|
/**
|
|
* This sample exercises heavy texture updates and uploads.
|
|
*/
|
|
class TextureUploadSample : public Sample {
|
|
static constexpr int kMinTileSize = 128;
|
|
static constexpr int kMaxTileSize = 2048;
|
|
static constexpr float kGridScale = 0.25f;
|
|
|
|
bool fDrawTexturesToScreen = true;
|
|
int fTileSize = 256;
|
|
int fTileRows = 8;
|
|
int fTileCols = 8;
|
|
|
|
sk_sp<SkSurface> fBlueSurface;
|
|
sk_sp<SkSurface> fGraySurface;
|
|
|
|
class RenderTargetTexture : public SkRefCnt {
|
|
public:
|
|
RenderTargetTexture(GrContext* context, int size) {
|
|
SkSurfaceProps surfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
|
|
SkImageInfo imageInfo = SkImageInfo::Make(size, size, kRGBA_8888_SkColorType,
|
|
kPremul_SkAlphaType);
|
|
fSurface = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, imageInfo, 0,
|
|
&surfaceProps);
|
|
}
|
|
|
|
sk_sp<SkImage> getImage() {
|
|
return fSurface->makeImageSnapshot();
|
|
}
|
|
|
|
void uploadRasterSurface(sk_sp<SkSurface> rasterSurface) {
|
|
SkPixmap pixmap;
|
|
rasterSurface->peekPixels(&pixmap);
|
|
fSurface->writePixels(pixmap, 0, 0);
|
|
}
|
|
|
|
private:
|
|
sk_sp<SkSurface> fSurface;
|
|
sk_sp<SkImage> fCachedImage;
|
|
};
|
|
|
|
SkTArray<sk_sp<RenderTargetTexture>> fTextures;
|
|
GrContext* fCachedContext = nullptr;
|
|
SkScalar fActiveTileIndex = 0;
|
|
|
|
SkString name() override {
|
|
return SkString("TextureUpload");
|
|
}
|
|
|
|
bool onChar(SkUnichar uni) override {
|
|
if ('m' == uni) {
|
|
fDrawTexturesToScreen = !fDrawTexturesToScreen;
|
|
return true;
|
|
} else if ('>' == uni) {
|
|
fTileSize = std::min(kMaxTileSize, 2*fTileSize);
|
|
fTileRows = kMaxTileSize/fTileSize;
|
|
fTileCols = kMaxTileSize/fTileSize;
|
|
fCachedContext = nullptr;
|
|
} else if ('<' == uni) {
|
|
fTileSize = std::max(kMinTileSize, fTileSize/2);
|
|
fTileRows = kMaxTileSize/fTileSize;
|
|
fTileCols = kMaxTileSize/fTileSize;
|
|
fCachedContext = nullptr;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
sk_sp<SkSurface> getFilledRasterSurface(SkColor color, int size) {
|
|
sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(size, size));
|
|
SkCanvas* canvas = surface->getCanvas();
|
|
canvas->clear(color);
|
|
return surface;
|
|
}
|
|
|
|
void onOnceBeforeDraw() override {
|
|
this->setBGColor(0xFFFFFFFF);
|
|
this->setSize(1024, 1024);
|
|
}
|
|
|
|
void initializeTextures(GrContext* context) {
|
|
fTextures.reset();
|
|
int textureCount = fTileRows * fTileCols;
|
|
for (int i = 0; i < textureCount; i++) {
|
|
fTextures.emplace_back(new RenderTargetTexture(context, fTileSize));
|
|
}
|
|
|
|
// Construct two simple rasters of differing colors to serve
|
|
// as cpu rasterized data to refresh textures with.
|
|
fBlueSurface = this->getFilledRasterSurface(SK_ColorBLUE, fTileSize);
|
|
fGraySurface = this->getFilledRasterSurface(SK_ColorGRAY, fTileSize);
|
|
}
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
#if SK_SUPPORT_GPU
|
|
SkPaint paint;
|
|
|
|
GrContext* context = canvas->getGrContext();
|
|
if (context) {
|
|
// One-time context-specific setup.
|
|
if (context != fCachedContext) {
|
|
fCachedContext = context;
|
|
this->initializeTextures(context);
|
|
}
|
|
|
|
// Upload new texture data for all textures, simulating a full page of tiles
|
|
// needing refresh.
|
|
int textureCount = fTileRows * fTileCols;
|
|
for (int i = 0; i < textureCount; i++) {
|
|
fTextures[i]->uploadRasterSurface(i == fActiveTileIndex ? fBlueSurface
|
|
: fGraySurface);
|
|
}
|
|
|
|
// Scale grid.
|
|
canvas->scale(kGridScale, kGridScale);
|
|
|
|
if (fDrawTexturesToScreen) {
|
|
for (int y = 0; y < fTileRows; y++) {
|
|
for (int x = 0; x < fTileCols; x++) {
|
|
int currentIndex = y * fTileCols + x;
|
|
canvas->drawImage(fTextures[currentIndex]->getImage(),
|
|
x * fTileSize, y * fTileSize, &paint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool onAnimate(double nanos) override {
|
|
constexpr SkScalar kDesiredDurationSecs = 16.0f;
|
|
float numTiles = fTileRows*fTileCols;
|
|
fActiveTileIndex = floorf(TimeUtils::Scaled(1e-9 * nanos,
|
|
numTiles/kDesiredDurationSecs, numTiles));
|
|
return true;
|
|
}
|
|
};
|
|
|
|
const int TextureUploadSample::kMinTileSize;
|
|
const int TextureUploadSample::kMaxTileSize;
|
|
|
|
DEF_SAMPLE( return new TextureUploadSample(); )
|
|
|