compressed_textures.cpp File Reference

#include "include/core/SkTypes.h"
#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkData.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPath.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.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/core/SkMipmap.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrDataUtils.h"
#include "src/gpu/ganesh/GrImageContextPriv.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/image/SkImage_GaneshBase.h"
#include "src/image/SkImage_Base.h"
#include "third_party/etc1/etc1.h"
#include "tools/gpu/ProxyUtils.h"

Go to the source code of this file.

Classes
struct	CompressedImageObjects
class	CompressedTexturesGM

Functions
static SkPoint	gen_pt (float angle, const SkVector &scale)
static SkPath	make_gear (SkISize dimensions, int numTeeth)
SkBitmap	render_level (SkISize dimensions, SkColor color, SkColorType colorType, bool opaque)
static CompressedImageObjects	make_compressed_image (SkCanvas *canvas, const SkISize dimensions, SkColorType colorType, bool opaque, SkTextureCompressionType compression)

Function Documentation

gen_pt()

static SkPoint gen_pt ( float  angle, const SkVector &  scale  )

static

Definition at line 48 of file compressed_textures.cpp.

                                                          {
    SkScalar s = SkScalarSin(angle);
    SkScalar c = SkScalarCos(angle);
 
    return { scale.fX * c, scale.fY * s };
}

make_compressed_image()

static CompressedImageObjects make_compressed_image ( SkCanvas *  canvas, const SkISize  dimensions, SkColorType  colorType, bool  opaque, SkTextureCompressionType  compression  )

static

Definition at line 122 of file compressed_textures.cpp.

                                                                                          {
    size_t totalSize = SkCompressedDataSize(compression, dimensions, nullptr, true);
 
    sk_sp<SkData> tmp = SkData::MakeUninitialized(totalSize);
    char* pixels = (char*) tmp->writable_data();
 
    int numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
 
    size_t offset = 0;
 
    // Use a different color for each mipmap level so we can visually evaluate the draws
    static const SkColor kColors[] = {
        SK_ColorRED,
        SK_ColorGREEN,
        SK_ColorBLUE,
        SK_ColorCYAN,
        SK_ColorMAGENTA,
        SK_ColorYELLOW,
        SK_ColorWHITE,
    };
 
    SkISize levelDims = dimensions;
    for (int i = 0; i < numMipLevels; ++i) {
        size_t levelSize = SkCompressedDataSize(compression, levelDims, nullptr, false);
 
        SkBitmap bm = render_level(levelDims, kColors[i%7], colorType, opaque);
        if (compression == SkTextureCompressionType::kETC2_RGB8_UNORM) {
            SkASSERT(bm.colorType() == kRGB_565_SkColorType);
            SkASSERT(opaque);
 
            if (etc1_encode_image((unsigned char*)bm.getAddr16(0, 0),
                                  bm.width(), bm.height(), 2, bm.rowBytes(),
                                  (unsigned char*) &pixels[offset])) {
                return {nullptr, nullptr};
            }
        } else {
            GrTwoColorBC1Compress(bm.pixmap(), kColors[i%7], &pixels[offset]);
        }
 
        offset += levelSize;
        levelDims = {std::max(1, levelDims.width()/2), std::max(1, levelDims.height()/2)};
    }
 
    sk_sp<SkImage> image;
#if defined(SK_GRAPHITE)
    skgpu::graphite::Recorder* recorder = canvas->recorder();
    if (recorder) {
        sk_sp<sk_gpu_test::ManagedGraphiteTexture> texture =
                sk_gpu_test::ManagedGraphiteTexture::MakeFromCompressedData(recorder,
                                                                            dimensions,
                                                                            compression,
                                                                            tmp,
                                                                            skgpu::Mipmapped::kYes);
        if (texture) {
            image = SkImages::WrapTexture(recorder,
                                          texture->texture(),
                                          skgpu::CompressionTypeToSkColorType(compression),
                                          kPremul_SkAlphaType,
                                          /*colorSpace=*/nullptr);
            if (image) {
                return {image, texture};
            }
        }
    }
#endif
    auto dContext = GrAsDirectContext(canvas->recordingContext());
    if (dContext) {
        image = SkImages::TextureFromCompressedTextureData(dContext,
                                                           std::move(tmp),
                                                           dimensions.width(),
                                                           dimensions.height(),
                                                           compression,
                                                           skgpu::Mipmapped::kYes);
    } else {
        image = SkImages::RasterFromCompressedTextureData(
                std::move(tmp), dimensions.width(), dimensions.height(), compression);
    }
    return {image, nullptr};
}

make_gear()

static SkPath make_gear ( SkISize  dimensions, int  numTeeth  )

static

Definition at line 56 of file compressed_textures.cpp.

                                                          {
    SkVector outerRad{ dimensions.fWidth / 2.0f, dimensions.fHeight / 2.0f };
    SkVector innerRad{ dimensions.fWidth / 2.5f, dimensions.fHeight / 2.5f };
    const float kAnglePerTooth = 2.0f * SK_ScalarPI / (3 * numTeeth);
 
    float angle = 0.0f;
 
    SkPath tmp;
    tmp.setFillType(SkPathFillType::kWinding);
 
    tmp.moveTo(gen_pt(angle, outerRad));
 
    for (int i = 0; i < numTeeth; ++i, angle += 3*kAnglePerTooth) {
        tmp.lineTo(gen_pt(angle+kAnglePerTooth, outerRad));
        tmp.lineTo(gen_pt(angle+(1.5f*kAnglePerTooth), innerRad));
        tmp.lineTo(gen_pt(angle+(2.5f*kAnglePerTooth), innerRad));
        tmp.lineTo(gen_pt(angle+(3.0f*kAnglePerTooth), outerRad));
    }
 
    tmp.close();
 
    float fInnerRad = 0.1f * std::min(dimensions.fWidth, dimensions.fHeight);
    if (fInnerRad > 0.5f) {
        tmp.addCircle(0.0f, 0.0f, fInnerRad, SkPathDirection::kCCW);
    }
 
    return tmp;
}

render_level()

SkBitmap render_level	(	SkISize	dimensions,
		SkColor	color,
		SkColorType	colorType,
		bool	opaque
	)

Definition at line 86 of file compressed_textures.cpp.

                                                                                             {
    SkPath path = make_gear(dimensions, 9);
 
    SkImageInfo ii = SkImageInfo::Make(dimensions.width(), dimensions.height(),
                                       colorType, opaque ? kOpaque_SkAlphaType
                                                         : kPremul_SkAlphaType);
    SkBitmap bm;
    bm.allocPixels(ii);
 
    bm.eraseColor(opaque ? SK_ColorBLACK : SK_ColorTRANSPARENT);
 
    SkCanvas c(bm);
 
    SkPaint paint;
    paint.setColor(color | 0xFF000000);
    paint.setAntiAlias(false);
 
    c.translate(dimensions.width() / 2.0f, dimensions.height() / 2.0f);
    c.drawPath(path, paint);
 
    return bm;
}