sk_sp<GrFragmentProcessor> SkPerlinNoiseShader::asFragmentProcessor(const AsFPArgs& args) const { SkASSERT(args.fContext); SkMatrix localMatrix = this->getLocalMatrix(); if (args.fLocalMatrix) { localMatrix.preConcat(*args.fLocalMatrix); } SkMatrix matrix = *args.fViewMatrix; matrix.preConcat(localMatrix); if (0 == fNumOctaves) { if (kFractalNoise_Type == fType) { // Extract the incoming alpha and emit rgba = (a/4, a/4, a/4, a/2) // TODO: Either treat the output of this shader as sRGB or allow client to specify a // color space of the noise. Either way, this case (and the GLSL) need to convert to // the destination. sk_sp<GrFragmentProcessor> inner( GrConstColorProcessor::Make(GrColor4f::FromGrColor(0x80404040), GrConstColorProcessor::kModulateRGBA_InputMode)); return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner)); } // Emit zero. return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(), GrConstColorProcessor::kIgnore_InputMode); } // Either we don't stitch tiles, either we have a valid tile size SkASSERT(!fStitchTiles || !fTileSize.isEmpty()); SkPerlinNoiseShader::PaintingData* paintingData = new PaintingData(fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY, matrix); sk_sp<GrTextureProxy> permutationsProxy(GrMakeCachedBitmapProxy( args.fContext->resourceProvider(), paintingData->getPermutationsBitmap())); sk_sp<GrTextureProxy> noiseProxy(GrMakeCachedBitmapProxy(args.fContext->resourceProvider(), paintingData->getNoiseBitmap())); SkMatrix m = *args.fViewMatrix; m.setTranslateX(-localMatrix.getTranslateX() + SK_Scalar1); m.setTranslateY(-localMatrix.getTranslateY() + SK_Scalar1); if (permutationsProxy && noiseProxy) { sk_sp<GrFragmentProcessor> inner( GrPerlinNoiseEffect::Make(args.fContext->resourceProvider(), fType, fNumOctaves, fStitchTiles, paintingData, std::move(permutationsProxy), std::move(noiseProxy), m)); return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner)); } delete paintingData; return nullptr; }
sk_sp<GrTextureProxy> onAsTextureProxyRef(GrContext* context) const override { if (context) { return GrMakeCachedBitmapProxy(context->contextPriv().proxyProvider(), fBitmap); } return nullptr; }
sk_sp<SkSpecialImage> SkSpecialImage::makeTextureImage(GrContext* context) { #if SK_SUPPORT_GPU if (!context) { return nullptr; } if (GrContext* curContext = as_SIB(this)->onGetContext()) { return curContext == context ? sk_sp<SkSpecialImage>(SkRef(this)) : nullptr; } auto proxyProvider = context->contextPriv().proxyProvider(); SkBitmap bmp; // At this point, we are definitely not texture-backed, so we must be raster or generator // backed. If we remove the special-wrapping-an-image subclass, we may be able to assert that // we are strictly raster-backed (i.e. generator images become raster when they are specialized) // in which case getROPixels could turn into peekPixels... if (!this->getROPixels(&bmp)) { return nullptr; } if (bmp.empty()) { return SkSpecialImage::MakeFromRaster(SkIRect::MakeEmpty(), bmp, &this->props()); } // TODO: this is a tight copy of 'bmp' but it doesn't have to be (given SkSpecialImage's // semantics). Since this is cached though we would have to bake the fit into the cache key. sk_sp<GrTextureProxy> proxy = GrMakeCachedBitmapProxy(proxyProvider, bmp); if (!proxy) { return nullptr; } const SkIRect rect = SkIRect::MakeWH(proxy->width(), proxy->height()); // GrMakeCachedBitmapProxy has uploaded only the specified subset of 'bmp' so we need not // bother with SkBitmap::getSubset return SkSpecialImage::MakeDeferredFromGpu(context, rect, this->uniqueID(), std::move(proxy), sk_ref_sp(this->getColorSpace()), &this->props(), this->alphaType()); #else return nullptr; #endif }