blob: ed179494fb050fd0c8983f6a148207f18a34e19f [file] [log] [blame]
/*
* Copyright 2020 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm/gm.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkImage.h"
#include "include/core/SkTextureCompressionType.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
#include "src/core/SkCompressedDataUtils.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrImageContextPriv.h"
#include "src/gpu/ganesh/image/SkImage_GaneshBase.h"
#include "src/image/SkImage_Base.h"
#include "tools/gpu/ProxyUtils.h"
constexpr int kImgWidth = 16;
constexpr int kImgHeight = 8;
constexpr int kPad = 4;
struct BC1Block {
uint16_t fColor0;
uint16_t fColor1;
uint32_t fIndices;
};
static int num_4x4_blocks(int size) {
return ((size + 3) & ~3) >> 2;
}
static uint16_t to565(SkColor col) {
int r5 = SkMulDiv255Round(31, SkColorGetR(col));
int g6 = SkMulDiv255Round(63, SkColorGetG(col));
int b5 = SkMulDiv255Round(31, SkColorGetB(col));
return (r5 << 11) | (g6 << 5) | b5;
}
// BC1 has per-block transparency. If, taken as ints,
// fColor0 < fColor1 -> the block has transparency (& it is in color3)
// fColor1 > fColor0 -> the block is opaque
//
// This method can create two blocks to test out BC1's behavior. If BC1
// behaves as expected (i.e., w/ per-block transparency) then, for RGBA textures,
// the transparent block(s) should appear as:
// opaque black, medium grey, transparent black, white.
// and the opaque block(s) should appear as:
// opaque black, dark grey, light grey, white
//
// For RGB textures, however, the transparent block(s) should appear as:
// opaque black, medium grey, _opaque_ black, white
// and the opaque block(s) should appear as:
// opaque black, dark grey, light grey, white.
static void create_BC1_block(BC1Block* block, bool transparent) {
unsigned int byte;
if (transparent) {
block->fColor0 = to565(SK_ColorBLACK);
block->fColor1 = to565(SK_ColorWHITE);
SkASSERT(block->fColor0 <= block->fColor1); // this signals a transparent block
// opaque black (col0), medium grey (col2), transparent black (col3), white (col1).
byte = (0x0 << 0) | (0x2 << 2) | (0x3 << 4) | (0x1 << 6);
} else {
block->fColor0 = to565(SK_ColorWHITE);
block->fColor1 = to565(SK_ColorBLACK);
SkASSERT(block->fColor0 > block->fColor1); // this signals an opaque block
// opaque black (col1), dark grey (col3), light grey (col2), white (col0)
byte = (0x1 << 0) | (0x3 << 2) | (0x2 << 4) | (0x0 << 6);
}
block->fIndices = (byte << 24) | (byte << 16) | (byte << 8) | byte;
}
// This makes a 16x8 BC1 texture which has the top 4 rows be officially transparent
// and the bottom 4 rows be officially opaque.
static sk_sp<SkData> make_compressed_data() {
SkISize dim{ kImgWidth, kImgHeight };
size_t totalSize = SkCompressedDataSize(SkTextureCompressionType::kBC1_RGB8_UNORM, dim,
nullptr, false);
sk_sp<SkData> tmp = SkData::MakeUninitialized(totalSize);
BC1Block* dstBlocks = reinterpret_cast<BC1Block*>(tmp->writable_data());
BC1Block transBlock, opaqueBlock;
create_BC1_block(&transBlock, true);
create_BC1_block(&opaqueBlock, false);
int numXBlocks = num_4x4_blocks(kImgWidth);
int numYBlocks = num_4x4_blocks(kImgHeight);
for (int y = 0; y < numYBlocks; ++y) {
for (int x = 0; x < numXBlocks; ++x) {
dstBlocks[y*numXBlocks + x] = (y < numYBlocks/2) ? transBlock : opaqueBlock;
}
}
return tmp;
}
static sk_sp<SkImage> data_to_img(GrDirectContext *direct, sk_sp<SkData> data,
SkTextureCompressionType compression) {
if (direct) {
return SkImages::TextureFromCompressedTextureData(
direct, std::move(data), kImgWidth, kImgHeight, compression, skgpu::Mipmapped::kNo);
} else {
return SkImages::RasterFromCompressedTextureData(
std::move(data), kImgWidth, kImgHeight, compression);
}
}
static void draw_image(SkCanvas* canvas, sk_sp<SkImage> image, int x, int y) {
bool isCompressed = false;
if (image && image->isTextureBacked()) {
const GrCaps* caps = as_IB(image)->context()->priv().caps();
GrTextureProxy* proxy = sk_gpu_test::GetTextureImageProxy(image.get(),
canvas->recordingContext());
isCompressed = caps->isFormatCompressed(proxy->backendFormat());
}
canvas->drawImage(image, x, y);
if (!isCompressed) {
SkRect r = SkRect::MakeXYWH(x, y, kImgWidth, kImgHeight);
r.outset(1.0f, 1.0f);
SkPaint redStroke;
redStroke.setColor(SK_ColorRED);
redStroke.setStyle(SkPaint::kStroke_Style);
redStroke.setStrokeWidth(2.0f);
canvas->drawRect(r, redStroke);
}
}
namespace skiagm {
// This GM draws the BC1 compressed texture filled with "make_compressed_data"s data twice.
//
// It is drawn once (on the top) as a kBC1_RGB8_UNORM texture and then again (on the bottom)
// as a kBC1_RGBA8_UNORM texture.
//
// If BC1 behaves as expected we should see:
//
// RGB8 Black MidGrey Black* White ...
// Black DrkGrey LtGrey White ...
//
// RGBA8 Black MidGrey Green+ White ...
// Black DrkGrey LtGrey White ...
//
// * We expect this to be black bc the transparent black will be forced to opaque. If BC1 were
// treating it as an opaque block then it would be LtGrey - not black.
// + This is just the background showing through the transparent black
class BC1TransparencyGM : public GM {
public:
BC1TransparencyGM() {
this->setBGColor(SK_ColorGREEN);
}
protected:
SkString getName() const override { return SkString("bc1_transparency"); }
SkISize getISize() override {
return SkISize::Make(kImgWidth + 2 * kPad, 2 * kImgHeight + 3 * kPad);
}
DrawResult onGpuSetup(SkCanvas* canvas, SkString* errorMsg, GraphiteTestContext*) override {
auto dContext = GrAsDirectContext(canvas->recordingContext());
if (dContext && dContext->abandoned()) {
// This isn't a GpuGM so a null 'context' is okay but an abandoned context
// if forbidden.
return DrawResult::kSkip;
}
sk_sp<SkData> bc1Data = make_compressed_data();
fRGBImage = data_to_img(dContext, bc1Data, SkTextureCompressionType::kBC1_RGB8_UNORM);
fRGBAImage = data_to_img(dContext, std::move(bc1Data),
SkTextureCompressionType::kBC1_RGBA8_UNORM);
if (!fRGBImage || !fRGBAImage) {
*errorMsg = "Failed to create BC1 images.";
return DrawResult::kFail;
}
return DrawResult::kOk;
}
void onGpuTeardown() override {
fRGBImage = nullptr;
fRGBAImage = nullptr;
}
void onDraw(SkCanvas* canvas) override {
draw_image(canvas, fRGBImage, kPad, kPad);
draw_image(canvas, fRGBAImage, kPad, 2 * kPad + kImgHeight);
}
private:
sk_sp<SkImage> fRGBImage;
sk_sp<SkImage> fRGBAImage;
using INHERITED = GM;
};
//////////////////////////////////////////////////////////////////////////////
DEF_GM(return new BC1TransparencyGM;)
} // namespace skiagm