static void check_texture(skiatest::Reporter* reporter, GrResourceProvider* provider, GrTextureProxy* texProxy, SkBackingFit fit) { GrSurfaceProxy::UniqueID idBefore = texProxy->uniqueID(); bool preinstantiated = texProxy->isInstantiated(); REPORTER_ASSERT(reporter, texProxy->instantiate(provider)); GrTexture* tex = texProxy->peekTexture(); REPORTER_ASSERT(reporter, texProxy->uniqueID() == idBefore); // Deferred resources should always have a different ID from their instantiated texture if (preinstantiated) { REPORTER_ASSERT(reporter, texProxy->uniqueID().asUInt() == tex->uniqueID().asUInt()); } else { REPORTER_ASSERT(reporter, texProxy->uniqueID().asUInt() != tex->uniqueID().asUInt()); } if (SkBackingFit::kExact == fit) { REPORTER_ASSERT(reporter, tex->width() == texProxy->width()); REPORTER_ASSERT(reporter, tex->height() == texProxy->height()); } else { REPORTER_ASSERT(reporter, tex->width() >= texProxy->width()); REPORTER_ASSERT(reporter, tex->height() >= texProxy->height()); } REPORTER_ASSERT(reporter, tex->config() == texProxy->config()); }
static void add_texture_key(GrProcessorKeyBuilder* b, const GrProcessor& proc, const GrGLSLCaps& caps) { int numTextures = proc.numTextures(); SkASSERT(0 == proc.numBuffers()); // Need two bytes per key (swizzle, sampler type, and precision). int word32Count = (proc.numTextures() + 1) / 2; if (0 == word32Count) { return; } uint16_t* k16 = SkTCast<uint16_t*>(b->add32n(word32Count)); for (int i = 0; i < numTextures; ++i) { const GrTextureAccess& access = proc.textureAccess(i); GrTexture* texture = access.getTexture(); k16[i] = SkToU16(caps.configTextureSwizzle(texture->config()).asKey() | (caps.samplerPrecision(texture->config(), access.getVisibility()) << 8)); } // zero the last 16 bits if the number of textures is odd. if (numTextures & 0x1) { k16[numTextures] = 0; } }
std::unique_ptr<SkCrossContextImageData> SkCrossContextImageData::MakeFromEncoded( GrContext* context, sk_sp<SkData> encoded, SkColorSpace* dstColorSpace) { sk_sp<SkImage> codecImage = SkImage::MakeFromEncoded(std::move(encoded)); if (!codecImage) { return nullptr; } // Some backends or drivers don't support (safely) moving resources between contexts if (!context->caps()->crossContextTextureSupport()) { return std::unique_ptr<SkCrossContextImageData>( new SkCrossContextImageData(std::move(codecImage))); } sk_sp<SkImage> textureImage = codecImage->makeTextureImage(context, dstColorSpace); if (!textureImage) { // TODO: Force decode to raster here? Do mip-mapping, like getDeferredTextureImageData? return std::unique_ptr<SkCrossContextImageData>( new SkCrossContextImageData(std::move(codecImage))); } // Crack open the gpu image, extract the backend data, stick it in the SkCCID GrTexture* texture = as_IB(textureImage)->peekTexture(); SkASSERT(texture); GrBackendTextureDesc desc; desc.fFlags = kNone_GrBackendTextureFlag; desc.fOrigin = texture->origin(); desc.fWidth = texture->width(); desc.fHeight = texture->height(); desc.fConfig = texture->config(); desc.fSampleCnt = 0; context->contextPriv().prepareSurfaceForExternalIO(as_IB(textureImage)->peekProxy()); auto textureData = texture->texturePriv().detachBackendTexture(); SkASSERT(textureData); SkImageInfo info = as_IB(textureImage)->onImageInfo(); return std::unique_ptr<SkCrossContextImageData>(new SkCrossContextImageData( desc, std::move(textureData), info.alphaType(), info.refColorSpace())); }
virtual void onDraw(SkCanvas* canvas) { SkDevice* device = canvas->getDevice(); GrRenderTarget* target = (GrRenderTarget*) device->accessRenderTarget(); GrContext* ctx = GetGr(); if (ctx && target) { SkPMColor gTextureData[(2 * S) * (2 * S)]; static const int stride = 2 * S; static const SkPMColor gray = SkPackARGB32(0x40, 0x40, 0x40, 0x40); static const SkPMColor white = SkPackARGB32(0xff, 0xff, 0xff, 0xff); static const SkPMColor red = SkPackARGB32(0x80, 0x80, 0x00, 0x00); static const SkPMColor blue = SkPackARGB32(0x80, 0x00, 0x00, 0x80); static const SkPMColor green = SkPackARGB32(0x80, 0x00, 0x80, 0x00); static const SkPMColor black = SkPackARGB32(0x00, 0x00, 0x00, 0x00); for (int i = 0; i < 2; ++i) { int offset = 0; // fill upper-left for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = gray; } } // fill upper-right offset = S; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = white; } } // fill lower left offset = S * stride; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = black; } } // fill lower right offset = S * stride + S; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = gray; } } GrTextureDesc desc; desc.fAALevel = kNone_GrAALevel; // use RT flag bit because in GL it makes the texture be bottom-up desc.fFlags = i ? kRenderTarget_GrTextureFlagBit : kNone_GrTextureFlags; desc.fConfig = kSkia8888_PM_GrPixelConfig; desc.fWidth = 2 * S; desc.fHeight = 2 * S; GrTexture* texture = ctx->createUncachedTexture(desc, gTextureData, 0); if (!texture) { return; } GrAutoUnref au(texture); ctx->setClip(GrRect::MakeWH(2*S, 2*S)); ctx->setRenderTarget(target); GrPaint paint; paint.reset(); paint.fColor = 0xffffffff; paint.fSrcBlendCoeff = kOne_BlendCoeff; paint.fDstBlendCoeff = kISA_BlendCoeff; GrMatrix vm; if (i) { vm.setRotate(90 * SK_Scalar1, S * SK_Scalar1, S * SK_Scalar1); } else { vm.reset(); } ctx->setMatrix(vm); GrMatrix tm; tm = vm; tm.postIDiv(2*S, 2*S); paint.textureSampler(0)->setMatrix(tm); paint.setTexture(0, texture); ctx->drawRect(paint, GrRect::MakeWH(2*S, 2*S)); // now update the lower right of the texture in first pass // or upper right in second pass offset = 0; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = ((x + y) % 2) ? (i ? green : red) : blue; } } texture->writePixels(S, (i ? 0 : S), S, S, texture->config(), gTextureData, 4 * stride); ctx->drawRect(paint, GrRect::MakeWH(2*S, 2*S)); } } }