sk_sp<SkSurface> SkSurface_Compute::MakeComputeBackedSurface(SkWindow * const window, const SkWindow::AttachmentInfo & attachmentInfo, GrGLInterface const * const grInterface, GrContext * const grContext, sk_sp<SkContext_Compute> compute) { GrBackendRenderTargetDesc desc; desc.fWidth = SkScalarRoundToInt(window->width()); desc.fHeight = SkScalarRoundToInt(window->height()); if (0 == desc.fWidth || 0 == desc.fHeight) { return nullptr; } // TODO: Query the actual framebuffer for sRGB capable. However, to // preserve old (fake-linear) behavior, we don't do this. Instead, rely // on the flag (currently driven via 'C' mode in SampleApp). // // Also, we may not have real sRGB support (ANGLE, in particular), so check for // that, and fall back to L32: // // ... and, if we're using a 10-bit/channel FB0, it doesn't do sRGB conversion on write, // so pretend that it's non-sRGB 8888: desc.fConfig = grContext->caps()->srgbSupport() && SkImageInfoIsGammaCorrect(window->info()) && (attachmentInfo.fColorBits != 30) ? kSkiaGamma8888_GrPixelConfig : kSkia8888_GrPixelConfig; desc.fOrigin = kBottomLeft_GrSurfaceOrigin; desc.fSampleCnt = 0; // attachmentInfo.fSampleCount; desc.fStencilBits = 0; // attachmentInfo.fStencilBits; GrGLint buffer; GR_GL_GetIntegerv(grInterface,GR_GL_FRAMEBUFFER_BINDING,&buffer); desc.fRenderTargetHandle = buffer; sk_sp<SkColorSpace> colorSpace = grContext->caps()->srgbSupport() && SkImageInfoIsGammaCorrect(window->info()) ? SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named) : nullptr; // // // if (!grContext) { return nullptr; } if (!SkSurface_Gpu::Valid(grContext,desc.fConfig,colorSpace.get())) { return nullptr; } return sk_make_sp<SkSurface_Compute>(compute,desc.fWidth,desc.fHeight); }
void WindowContext::presentRenderSurface(sk_sp<SkSurface> renderSurface, sk_sp<GrRenderTarget> rt, int colorBits) { if (!this->isGpuContext() || colorBits > 24 || kRGBA_F16_SkColorType == fDisplayParams.fColorType) { // We made/have an off-screen surface. Get the contents as an SkImage: SkImageInfo info = SkImageInfo::Make(fWidth, fHeight, fDisplayParams.fColorType, kUnknown_SkAlphaType, fDisplayParams.fColorSpace); SkBitmap bm; bm.allocPixels(info); renderSurface->getCanvas()->readPixels(&bm, 0, 0); SkPixmap pm; bm.peekPixels(&pm); sk_sp<SkImage> image(SkImage::MakeTextureFromPixmap(fContext, pm, SkBudgeted::kNo)); GrTexture* texture = as_IB(image)->peekTexture(); SkASSERT(texture); // With ten-bit output, we need to manually apply the gamma of the output device // (unless we're in non-gamma correct mode, in which case our data is already // fake-sRGB, like we're expected to put in the 10-bit buffer): bool doGamma = (colorBits == 30) && SkImageInfoIsGammaCorrect(info); fContext->applyGamma(rt.get(), texture, doGamma ? 1.0f / 2.2f : 1.0f); } }
GrRenderTarget* SkWindow::renderTarget(const AttachmentInfo& attachmentInfo, const GrGLInterface* interface, GrContext* grContext) { GrBackendRenderTargetDesc desc; desc.fWidth = SkScalarRoundToInt(this->width()); desc.fHeight = SkScalarRoundToInt(this->height()); // TODO: Query the actual framebuffer for sRGB capable. However, to // preserve old (fake-linear) behavior, we don't do this. Instead, rely // on the flag (currently driven via 'C' mode in SampleApp). // // Also, we may not have real sRGB support (ANGLE, in particular), so check for // that, and fall back to L32: desc.fConfig = grContext->caps()->srgbSupport() && SkImageInfoIsGammaCorrect(info()) ? kSkiaGamma8888_GrPixelConfig : kSkia8888_GrPixelConfig; desc.fOrigin = kBottomLeft_GrSurfaceOrigin; desc.fSampleCnt = attachmentInfo.fSampleCount; desc.fStencilBits = attachmentInfo.fStencilBits; GrGLint buffer; GR_GL_GetIntegerv(interface, GR_GL_FRAMEBUFFER_BINDING, &buffer); desc.fRenderTargetHandle = buffer; return grContext->textureProvider()->wrapBackendRenderTarget(desc); }