From 18c52a7b52211de5d0dcd86dc048adef758c6c75 Mon Sep 17 00:00:00 2001 From: Brian Salomon Date: Fri, 2 Feb 2018 06:53:26 -0500 Subject: Revert "Revert "Revert "Redefine the meaning of sample counts in GPU backend.""" This reverts commit d0d7270fcc32546005b8e847df516cb11592cd30. Revert "More sample count cleanup:" This reverts commit d653cac70ed17983125ceed053138c09f1401846. Revert "Add new GrContext queries for imagability, surfacability, and max sample count of color types" This reverts commit 85ae7159c9c8a9186a4c7e74304eabb35bca9a79. Need to understand NVPR perf changes before relanding Change-Id: I0db075fb42438ef2a1f9885df184dce52892ac4b Reviewed-on: https://skia-review.googlesource.com/102780 Reviewed-by: Brian Salomon Commit-Queue: Brian Salomon --- bench/nanobench.cpp | 3 +- debugger/QT/SkGLWidget.cpp | 3 +- dm/DMSrcSink.h | 2 +- example/HelloWorld.cpp | 2 +- include/core/SkSurface.h | 10 +- include/gpu/GrCaps.h | 33 +----- include/gpu/GrContext.h | 24 +--- include/gpu/GrRenderTarget.h | 7 +- include/gpu/GrTypes.h | 19 ++-- include/gpu/mock/GrMockTypes.h | 7 +- include/private/GrRenderTargetProxy.h | 4 +- src/gpu/GrBackendSurface.cpp | 6 +- src/gpu/GrBackendTextureImageGenerator.cpp | 4 +- src/gpu/GrBlurUtils.cpp | 2 +- src/gpu/GrCaps.cpp | 42 +------ src/gpu/GrContext.cpp | 19 +--- src/gpu/GrGpu.cpp | 75 ++++++++++--- src/gpu/GrGpu.h | 4 - src/gpu/GrProxyProvider.cpp | 41 +++++-- src/gpu/GrRenderTarget.cpp | 2 +- src/gpu/GrRenderTargetProxy.cpp | 8 +- src/gpu/GrResourceProvider.cpp | 34 +++++- src/gpu/GrResourceProvider.h | 2 +- src/gpu/GrSurface.cpp | 5 +- src/gpu/GrSurfaceProxy.cpp | 4 +- src/gpu/GrTexture.cpp | 8 +- src/gpu/GrTextureProducer.cpp | 4 +- src/gpu/GrTextureProxy.cpp | 4 +- src/gpu/GrTextureRenderTargetProxy.cpp | 6 +- src/gpu/SkGr.cpp | 4 +- src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp | 2 +- src/gpu/ddl/GrDDLGpu.h | 2 +- src/gpu/gl/GrGLCaps.cpp | 41 ++----- src/gpu/gl/GrGLCaps.h | 11 +- src/gpu/gl/GrGLGpu.cpp | 48 ++++---- src/gpu/gl/GrGLRenderTarget.cpp | 2 +- src/gpu/gl/GrGLStencilAttachment.cpp | 2 +- src/gpu/mock/GrMockCaps.h | 34 +----- src/gpu/mock/GrMockTexture.h | 7 +- src/gpu/mtl/GrMtlCaps.h | 12 +- src/gpu/mtl/GrMtlCaps.mm | 30 ++--- src/gpu/vk/GrVkCaps.cpp | 24 +--- src/gpu/vk/GrVkCaps.h | 9 +- src/gpu/vk/GrVkGpu.cpp | 33 +++--- src/gpu/vk/GrVkRenderTarget.cpp | 19 ++-- src/gpu/vk/GrVkRenderTarget.h | 7 +- src/gpu/vk/GrVkStencilAttachment.cpp | 2 +- src/gpu/vk/GrVkTextureRenderTarget.cpp | 15 +-- src/gpu/vk/GrVkUtil.cpp | 2 +- src/image/SkImage_Gpu.cpp | 9 +- src/image/SkImage_Lazy.cpp | 5 +- src/image/SkSurface.cpp | 4 +- src/image/SkSurface_Gpu.cpp | 20 ++-- src/utils/win/SkWGL.h | 8 +- src/utils/win/SkWGL_win.cpp | 7 +- tests/BlendTest.cpp | 4 +- tests/DeferredDisplayListTest.cpp | 9 +- tests/DeviceTest.cpp | 2 +- tests/EGLImageTest.cpp | 2 +- tests/GLProgramsTest.cpp | 5 +- tests/GpuDrawPathTest.cpp | 2 +- tests/GpuSampleLocationsTest.cpp | 32 ++---- tests/GrCCPRTest.cpp | 3 +- tests/GrSurfaceTest.cpp | 28 ++--- tests/ImageTest.cpp | 24 ---- tests/LazyProxyTest.cpp | 3 +- tests/PathRendererCacheTests.cpp | 4 +- tests/ProxyTest.cpp | 19 ++-- tests/ResourceAllocatorTest.cpp | 4 +- tests/ResourceCacheTest.cpp | 40 ++++--- tests/SRGBReadWritePixelsTest.cpp | 2 +- tests/SkpSkGrTest.cpp | 2 +- tests/SurfaceTest.cpp | 137 ++--------------------- tests/TessellatingPathRendererTests.cpp | 9 +- tests/TestConfigParsing.cpp | 10 +- tests/TextureProxyTest.cpp | 2 +- tests/TransferPixelsTest.cpp | 2 +- tests/VkClearTests.cpp | 4 +- tests/VkUploadPixelsTests.cpp | 2 +- tests/VkWrapTests.cpp | 20 ++-- tests/WritePixelsTest.cpp | 6 +- tools/fiddle/fiddle_main.cpp | 2 +- tools/flags/SkCommonFlagsConfig.cpp | 2 +- tools/gpu/GrTest.cpp | 7 -- tools/sk_app/DisplayParams.h | 5 +- tools/sk_app/GLWindowContext.cpp | 6 +- tools/sk_app/Window.cpp | 2 +- tools/sk_app/WindowContext.h | 10 +- tools/sk_app/android/GLWindowContext_android.cpp | 7 +- tools/sk_app/ios/GLWindowContext_ios.cpp | 1 - tools/sk_app/ios/RasterWindowContext_ios.cpp | 1 - tools/sk_app/ios/Window_ios.cpp | 2 +- tools/sk_app/ios/Window_ios.h | 6 +- tools/sk_app/mac/GLWindowContext_mac.cpp | 1 - tools/sk_app/mac/RasterWindowContext_mac.cpp | 1 - tools/sk_app/mac/Window_mac.cpp | 2 +- tools/sk_app/mac/Window_mac.h | 6 +- tools/sk_app/unix/GLWindowContext_unix.cpp | 1 - tools/sk_app/unix/Window_unix.cpp | 2 +- tools/sk_app/unix/Window_unix.h | 15 ++- tools/sk_app/win/ANGLEWindowContext_win.cpp | 5 +- tools/sk_app/win/GLWindowContext_win.cpp | 3 +- tools/skpbench/skpbench.cpp | 3 +- tools/viewer/Viewer.cpp | 15 ++- 104 files changed, 489 insertions(+), 736 deletions(-) diff --git a/bench/nanobench.cpp b/bench/nanobench.cpp index f7f0bff82b..b9ecfa7b51 100644 --- a/bench/nanobench.cpp +++ b/bench/nanobench.cpp @@ -428,8 +428,7 @@ static void create_config(const SkCommandLineConfig* config, SkTArray* c if (const GrContext* ctx = factory.get(ctxType, ctxOverrides)) { GrPixelConfig grPixConfig = SkImageInfo2GrPixelConfig(colorType, colorSpace, *ctx->caps()); - int supportedSampleCount = - ctx->caps()->getRenderTargetSampleCount(sampleCount, grPixConfig); + int supportedSampleCount = ctx->caps()->getSampleCount(sampleCount, grPixConfig); if (sampleCount != supportedSampleCount) { SkDebugf("Configuration '%s' sample count %d is not a supported sample count.\n", config->getTag().c_str(), sampleCount); diff --git a/debugger/QT/SkGLWidget.cpp b/debugger/QT/SkGLWidget.cpp index 44a15dca38..baee2bbdac 100644 --- a/debugger/QT/SkGLWidget.cpp +++ b/debugger/QT/SkGLWidget.cpp @@ -20,7 +20,7 @@ SkGLWidget::~SkGLWidget() { void SkGLWidget::setSampleCount(int sampleCount) { QGLFormat currentFormat = format(); - currentFormat.setSampleBuffers(sampleCount > 1); + currentFormat.setSampleBuffers(sampleCount > 0); currentFormat.setSamples(sampleCount); setFormat(currentFormat); } @@ -89,7 +89,6 @@ GrBackendRenderTarget SkGLWidget::getBackendRenderTarget() { int sampleCnt; GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_FRAMEBUFFER_BINDING, &info.fFBOID); GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_SAMPLES, &sampleCnt); - sampleCnt = SkTMax(sampleCnt, 1); GR_GL_GetIntegerv(fCurIntf.get(), GR_GL_STENCIL_BITS, &stencilBits); // We are on desktop so we assume the internal config is RGBA info.fFormat = GR_GL_RGBA8; diff --git a/dm/DMSrcSink.h b/dm/DMSrcSink.h index 157a484d2b..db1e064d72 100644 --- a/dm/DMSrcSink.h +++ b/dm/DMSrcSink.h @@ -350,7 +350,7 @@ public: bool serial() const override { return !fThreaded; } const char* fileExtension() const override { return "png"; } SinkFlags flags() const override { - SinkFlags::Multisampled ms = fSampleCount > 1 ? SinkFlags::kMultisampled + SinkFlags::Multisampled ms = fSampleCount > 0 ? SinkFlags::kMultisampled : SinkFlags::kNotMultisampled; return SinkFlags{ SinkFlags::kGPU, SinkFlags::kDirect, ms }; } diff --git a/example/HelloWorld.cpp b/example/HelloWorld.cpp index b20d30a780..5954e71532 100644 --- a/example/HelloWorld.cpp +++ b/example/HelloWorld.cpp @@ -38,7 +38,7 @@ HelloWorld::~HelloWorld() { } void HelloWorld::updateTitle() { - if (!fWindow || fWindow->sampleCount() <= 1) { + if (!fWindow || fWindow->sampleCount() < 0) { return; } diff --git a/include/core/SkSurface.h b/include/core/SkSurface.h index d621fdf062..1f2c4b7f07 100644 --- a/include/core/SkSurface.h +++ b/include/core/SkSurface.h @@ -90,7 +90,7 @@ public: /** * Used to wrap a pre-existing backend 3D API texture as a SkSurface. Skia will not assume * ownership of the texture and the client must ensure the texture is valid for the lifetime - * of the SkSurface. If sampleCnt > 1, then we will create an intermediate mssa surface which + * of the SkSurface. If sampleCnt > 0, then we will create an intermediate mssa surface which * we will use for rendering. We then resolve into the passed in texture. */ static sk_sp MakeFromBackendTexture(GrContext* context, @@ -102,13 +102,13 @@ public: /** * Used to wrap a pre-existing backend 3D API texture as a SkSurface. Skia will not assume * ownership of the texture and the client must ensure the texture is valid for the lifetime - * of the SkSurface. If sampleCnt > 1, then we will create an intermediate mssa surface which + * of the SkSurface. If sampleCnt > 0, then we will create an intermediate mssa surface which * we will use for rendering. We then resolve into the passed in texture. * * The GrBackendTexture must have a valid backend format supplied (GrGLTextureInfo::fFormat, * GrVkImageInfo::fFormat, etc.) in it. The passed in SkColorType informs skia how it should * interpret the backend format supplied by the GrBackendTexture. If the format in the - * GrBackendTexture is not compatible with the sampleCnt, SkColorType, and SkColorSpace we + * GrBackendTexture is not compitable with the sampleCnt, SkColorType, and SkColorSpace we * will return nullptr. */ static sk_sp MakeFromBackendTexture(GrContext* context, @@ -128,7 +128,7 @@ public: * The GrBackendRenderTarget must have a valid backend format set (GrGLTextureInfo::fFormat, * GrVkImageInfo::fFormat, etc.) in it. The passed in SkColorType informs skia how it should * interpret the backend format supplied by the GrBackendRenderTarget. If the format in the - * GrBackendRenderTarget is not compatible with the sampleCnt, SkColorType, and SkColorSpace + * GrBackendRenderTarget is not compitable with the sampleCnt, SkColorType, and SkColorSpace * we will return nullptr. */ static sk_sp MakeFromBackendRenderTarget(GrContext* context, @@ -162,7 +162,7 @@ public: * The GrBackendTexture must have a valid backend format supplied (GrGLTextureInfo::fFormat, * GrVkImageInfo::fFormat, etc.) in it. The passed in SkColorType informs skia how it should * interpret the backend format supplied by the GrBackendTexture. If the format in the - * GrBackendTexture is not compatible with the sampleCnt, SkColorType, and SkColorSpace we + * GrBackendTexture is not compitable with the sampleCnt, SkColorType, and SkColorSpace we * will return nullptr. */ static sk_sp MakeFromBackendTextureAsRenderTarget(GrContext* context, diff --git a/include/gpu/GrCaps.h b/include/gpu/GrCaps.h index 0f03f162f0..f4d6e06280 100644 --- a/include/gpu/GrCaps.h +++ b/include/gpu/GrCaps.h @@ -134,6 +134,10 @@ public: int maxRasterSamples() const { return fMaxRasterSamples; } + // Find a sample count greater than or equal to the requested count which is supported for a + // color buffer of the given config. If MSAA is not support for the config we will return 0. + virtual int getSampleCount(int requestedCount, GrPixelConfig config) const = 0; + int maxWindowRectangles() const { return fMaxWindowRectangles; } // A tuned, platform-specific value for the maximum number of analytic fragment processors we @@ -141,32 +145,9 @@ public: int maxClipAnalyticFPs() const { return fMaxClipAnalyticFPs; } virtual bool isConfigTexturable(GrPixelConfig) const = 0; - + virtual bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const = 0; // Returns whether a texture of the given config can be copied to a texture of the same config. - virtual bool isConfigCopyable(GrPixelConfig) const = 0; - - // Returns the maximum supported sample count for a config. 0 means the config is not renderable - // 1 means the config is renderable but doesn't support MSAA. - virtual int maxRenderTargetSampleCount(GrPixelConfig) const = 0; - - bool isConfigRenderable(GrPixelConfig config) const { - return this->maxRenderTargetSampleCount(config) > 0; - } - - // TODO: Remove this after Flutter updated to no longer use it. - bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const { - return this->maxRenderTargetSampleCount(config) > (withMSAA ? 1 : 0); - } - - // Find a sample count greater than or equal to the requested count which is supported for a - // color buffer of the given config or 0 if no such sample count is supported. If the requested - // sample count is 1 then 1 will be returned if non-MSAA rendering is supported, otherwise 0. - // For historical reasons requestedCount==0 is handled identically to requestedCount==1. - virtual int getRenderTargetSampleCount(int requestedCount, GrPixelConfig) const = 0; - // TODO: Remove. Legacy name used by Chrome. - int getSampleCount(int requestedCount, GrPixelConfig config) const { - return this->getRenderTargetSampleCount(requestedCount, config); - } + virtual bool isConfigCopyable(GrPixelConfig config) const = 0; bool suppressPrints() const { return fSuppressPrints; } @@ -197,8 +178,6 @@ public: virtual bool initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* desc, bool* rectsMustMatch, bool* disallowSubrect) const = 0; - bool validateSurfaceDesc(const GrSurfaceDesc&, GrMipMapped) const; - /** * Returns true if the GrBackendTexutre can we used with the supplied SkColorType. If it is * compatible, the passed in GrPixelConfig will be set to a config that matches the backend diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h index d0ca90e0f0..f85efc4940 100644 --- a/include/gpu/GrContext.h +++ b/include/gpu/GrContext.h @@ -216,26 +216,6 @@ public: /** Access the context capabilities */ const GrCaps* caps() const { return fCaps.get(); } - /** - * Can a SkImage be created with the given color type. - */ - bool colorTypeSupportedAsImage(SkColorType) const; - - /** - * Can a SkSurface be created with the given color type. To check whether MSAA is supported - * use maxSurfaceSampleCountForColorType(). - */ - bool colorTypeSupportedAsSurface(SkColorType colorType) const { - return this->maxSurfaceSampleCountForColorType(colorType) > 0; - } - - /** - * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA - * rendering is supported for the color type. 0 is returned if rendering to this color type - * is not supported at all. - */ - int maxSurfaceSampleCountForColorType(SkColorType) const; - /* * Create a new render target context backed by a deferred-style * GrRenderTargetProxy. We guarantee that "asTextureProxy" will succeed for @@ -246,7 +226,7 @@ public: int width, int height, GrPixelConfig config, sk_sp colorSpace, - int sampleCnt = 1, + int sampleCnt = 0, GrMipMapped = GrMipMapped::kNo, GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin, const SkSurfaceProps* surfaceProps = nullptr, @@ -262,7 +242,7 @@ public: int width, int height, GrPixelConfig config, sk_sp colorSpace, - int sampleCnt = 1, + int sampleCnt = 0, GrMipMapped = GrMipMapped::kNo, GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin, const SkSurfaceProps* surfaceProps = nullptr, diff --git a/include/gpu/GrRenderTarget.h b/include/gpu/GrRenderTarget.h index 9be6e1d8d0..4eee7f63ce 100644 --- a/include/gpu/GrRenderTarget.h +++ b/include/gpu/GrRenderTarget.h @@ -33,11 +33,10 @@ public: const GrRenderTarget* asRenderTarget() const override { return this; } // GrRenderTarget - bool isStencilBufferMultisampled() const { return fSampleCnt > 1; } + bool isStencilBufferMultisampled() const { return fSampleCnt > 0; } GrFSAAType fsaaType() const { - SkASSERT(fSampleCnt >= 1); - if (fSampleCnt <= 1) { + if (!fSampleCnt) { SkASSERT(!(fFlags & GrRenderTargetFlags::kMixedSampled)); return GrFSAAType::kNone; } @@ -54,7 +53,7 @@ public: * Returns the number of samples/pixel in the color buffer (Zero if non-MSAA or mixed sampled). */ int numColorSamples() const { - return GrFSAAType::kMixedSamples == this->fsaaType() ? 1 : fSampleCnt; + return GrFSAAType::kMixedSamples == this->fsaaType() ? 0 : fSampleCnt; } /** diff --git a/include/gpu/GrTypes.h b/include/gpu/GrTypes.h index ab21fba732..3081543aac 100644 --- a/include/gpu/GrTypes.h +++ b/include/gpu/GrTypes.h @@ -402,12 +402,13 @@ struct GrMipLevel { */ struct GrSurfaceDesc { GrSurfaceDesc() - : fFlags(kNone_GrSurfaceFlags) - , fOrigin(kTopLeft_GrSurfaceOrigin) - , fWidth(0) - , fHeight(0) - , fConfig(kUnknown_GrPixelConfig) - , fSampleCnt(1) {} + : fFlags(kNone_GrSurfaceFlags) + , fOrigin(kTopLeft_GrSurfaceOrigin) + , fWidth(0) + , fHeight(0) + , fConfig(kUnknown_GrPixelConfig) + , fSampleCnt(0) { + } GrSurfaceFlags fFlags; //!< bitfield of TextureFlags GrSurfaceOrigin fOrigin; //!< origin of the texture @@ -421,11 +422,11 @@ struct GrSurfaceDesc { GrPixelConfig fConfig; /** - * The number of samples per pixel. Zero is treated equivalently to 1. This only + * The number of samples per pixel or 0 to disable full scene AA. This only * applies if the kRenderTarget_GrSurfaceFlag is set. The actual number * of samples may not exactly match the request. The request will be rounded - * up to the next supported sample count. A value larger than the largest - * supported sample count will fail. + * up to the next supported sample count, or down if it is larger than the + * max supported count. */ int fSampleCnt; }; diff --git a/include/gpu/mock/GrMockTypes.h b/include/gpu/mock/GrMockTypes.h index 0954c5eadc..cf30a333f3 100644 --- a/include/gpu/mock/GrMockTypes.h +++ b/include/gpu/mock/GrMockTypes.h @@ -22,9 +22,8 @@ struct GrMockTextureInfo { */ struct GrMockOptions { GrMockOptions() { - using Renderability = ConfigOptions::Renderability; // By default RGBA_8888 is textureable and renderable and A8 and RGB565 are texturable. - fConfigOptions[kRGBA_8888_GrPixelConfig].fRenderability = Renderability::kNonMSAA; + fConfigOptions[kRGBA_8888_GrPixelConfig].fRenderable[0] = true; fConfigOptions[kRGBA_8888_GrPixelConfig].fTexturable = true; fConfigOptions[kAlpha_8_GrPixelConfig].fTexturable = true; fConfigOptions[kAlpha_8_as_Alpha_GrPixelConfig].fTexturable = true; @@ -33,8 +32,8 @@ struct GrMockOptions { } struct ConfigOptions { - enum Renderability { kNo, kNonMSAA, kMSAA }; - Renderability fRenderability; + /** The first value is for non-MSAA rendering, the second for MSAA. */ + bool fRenderable[2] = {false, false}; bool fTexturable = false; }; diff --git a/include/private/GrRenderTargetProxy.h b/include/private/GrRenderTargetProxy.h index 1d5d8042ce..1cd3d5d1a2 100644 --- a/include/private/GrRenderTargetProxy.h +++ b/include/private/GrRenderTargetProxy.h @@ -26,7 +26,7 @@ public: bool instantiate(GrResourceProvider*) override; GrFSAAType fsaaType() const { - if (fSampleCnt <= 1) { + if (!fSampleCnt) { SkASSERT(!(fRenderTargetFlags & GrRenderTargetFlags::kMixedSampled)); return GrFSAAType::kNone; } @@ -50,7 +50,7 @@ public: * Returns the number of samples/pixel in the color buffer (Zero if non-MSAA or mixed sampled). */ int numColorSamples() const { - return GrFSAAType::kMixedSamples == this->fsaaType() ? 1 : fSampleCnt; + return GrFSAAType::kMixedSamples == this->fsaaType() ? 0 : fSampleCnt; } int maxWindowRectangles(const GrCaps& caps) const; diff --git a/src/gpu/GrBackendSurface.cpp b/src/gpu/GrBackendSurface.cpp index 16fa793d25..406cb228ea 100644 --- a/src/gpu/GrBackendSurface.cpp +++ b/src/gpu/GrBackendSurface.cpp @@ -106,7 +106,7 @@ GrBackendRenderTarget::GrBackendRenderTarget(int width, const GrVkImageInfo& vkInfo) : fWidth(width) , fHeight(height) - , fSampleCnt(SkTMax(1, sampleCnt)) + , fSampleCnt(sampleCnt) , fStencilBits(stencilBits) , fConfig(GrVkFormatToPixelConfig(vkInfo.fFormat)) , fBackend(kVulkan_GrBackend) @@ -121,7 +121,7 @@ GrBackendRenderTarget::GrBackendRenderTarget(int width, const GrGLFramebufferInfo& glInfo) : fWidth(width) , fHeight(height) - , fSampleCnt(SkTMax(1, sampleCnt)) + , fSampleCnt(sampleCnt) , fStencilBits(stencilBits) , fConfig(config) , fBackend(kOpenGL_GrBackend) @@ -134,7 +134,7 @@ GrBackendRenderTarget::GrBackendRenderTarget(int width, const GrGLFramebufferInfo& glInfo) : fWidth(width) , fHeight(height) - , fSampleCnt(SkTMax(1, sampleCnt)) + , fSampleCnt(sampleCnt) , fStencilBits(stencilBits) , fConfig(GrGLSizedFormatToPixelConfig(glInfo.fFormat)) , fBackend(kOpenGL_GrBackend) diff --git a/src/gpu/GrBackendTextureImageGenerator.cpp b/src/gpu/GrBackendTextureImageGenerator.cpp index af28409cfe..ae27912b32 100644 --- a/src/gpu/GrBackendTextureImageGenerator.cpp +++ b/src/gpu/GrBackendTextureImageGenerator.cpp @@ -186,8 +186,8 @@ sk_sp GrBackendTextureImageGenerator::onGenerateTexture( GrMipMapped mipMapped = willNeedMipMaps ? GrMipMapped::kYes : GrMipMapped::kNo; sk_sp rtContext(context->makeDeferredRenderTargetContext( - SkBackingFit::kExact, info.width(), info.height(), proxy->config(), nullptr, 1, - mipMapped, proxy->origin(), nullptr, SkBudgeted::kYes)); + SkBackingFit::kExact, info.width(), info.height(), proxy->config(), nullptr, + 0, mipMapped, proxy->origin(), nullptr, SkBudgeted::kYes)); if (!rtContext) { return nullptr; diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp index b6e3092d5a..b79a38a884 100644 --- a/src/gpu/GrBlurUtils.cpp +++ b/src/gpu/GrBlurUtils.cpp @@ -110,7 +110,7 @@ static sk_sp create_mask_GPU(GrContext* context, int sampleCnt) { if (GrAA::kNo == aa) { // Don't need MSAA if mask isn't AA - sampleCnt = 1; + sampleCnt = 0; } sk_sp rtContext(context->makeDeferredRenderTargetContextWithFallback( diff --git a/src/gpu/GrCaps.cpp b/src/gpu/GrCaps.cpp index dd589b436f..427b20425a 100644 --- a/src/gpu/GrCaps.cpp +++ b/src/gpu/GrCaps.cpp @@ -196,7 +196,8 @@ void GrCaps::dumpJSON(SkJSONWriter* writer) const { kBlendEquationSupportNames[fBlendEquationSupport]); writer->appendString("Map Buffer Support", map_flags_to_string(fMapBufferFlags).c_str()); - SkASSERT(!this->isConfigRenderable(kUnknown_GrPixelConfig)); + SkASSERT(!this->isConfigRenderable(kUnknown_GrPixelConfig, false)); + SkASSERT(!this->isConfigRenderable(kUnknown_GrPixelConfig, true)); SkASSERT(!this->isConfigTexturable(kUnknown_GrPixelConfig)); writer->beginArray("configs"); @@ -205,7 +206,8 @@ void GrCaps::dumpJSON(SkJSONWriter* writer) const { GrPixelConfig config = static_cast(i); writer->beginObject(nullptr, false); writer->appendString("name", pixel_config_name(config)); - writer->appendS32("max sample count", this->maxRenderTargetSampleCount(config)); + writer->appendBool("renderable", this->isConfigRenderable(config, false)); + writer->appendBool("renderableMSAA", this->isConfigRenderable(config, true)); writer->appendBool("texturable", this->isConfigTexturable(config)); writer->endObject(); } @@ -220,39 +222,3 @@ void GrCaps::dumpJSON(SkJSONWriter* writer) const { writer->endObject(); } -bool GrCaps::validateSurfaceDesc(const GrSurfaceDesc& desc, GrMipMapped mipped) const { - if (!this->isConfigTexturable(desc.fConfig)) { - return false; - } - - if (GrMipMapped::kYes == mipped) { - if (GrPixelConfigIsSint(desc.fConfig) || !this->mipMapSupport()) { - return false; - } - } - - if (desc.fWidth < 1 || desc.fHeight < 1) { - return false; - } - - if (SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag)) { - if (0 == this->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig)) { - return false; - } - int maxRTSize = this->maxRenderTargetSize(); - if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) { - return false; - } - } else { - // We currently do not support multisampled textures - if (desc.fSampleCnt > 1) { - return false; - } - int maxSize = this->maxTextureSize(); - if (desc.fWidth > maxSize || desc.fHeight > maxSize) { - return false; - } - } - - return true; -} diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index 05908f4889..b427e70beb 100644 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -420,18 +420,6 @@ size_t GrContext::getResourceCachePurgeableBytes() const { //////////////////////////////////////////////////////////////////////////////// -bool GrContext::colorTypeSupportedAsImage(SkColorType colorType) const { - GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps()); - return this->caps()->isConfigTexturable(config); -} - -int GrContext::maxSurfaceSampleCountForColorType(SkColorType colorType) const { - GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps()); - return this->caps()->maxRenderTargetSampleCount(config); -} - -//////////////////////////////////////////////////////////////////////////////// - void GrContext::TextBlobCacheOverBudgetCB(void* data) { SkASSERT(data); // TextBlobs are drawn at the SkGpuDevice level, therefore they cannot rely on @@ -874,7 +862,6 @@ sk_sp GrContextPriv::makeBackendTextureRenderTargetContex sk_sp colorSpace, const SkSurfaceProps* props) { ASSERT_SINGLE_OWNER_PRIV - SkASSERT(sampleCnt > 0); sk_sp proxy(this->proxyProvider()->createWrappedTextureProxy(tex, origin, sampleCnt)); @@ -911,7 +898,7 @@ sk_sp GrContextPriv::makeBackendTextureAsRenderTargetRend sk_sp colorSpace, const SkSurfaceProps* props) { ASSERT_SINGLE_OWNER_PRIV - SkASSERT(sampleCnt > 0); + sk_sp proxy(this->proxyProvider()->createWrappedRenderTargetProxy(tex, origin, sampleCnt)); if (!proxy) { @@ -962,8 +949,7 @@ sk_sp GrContext::makeDeferredRenderTargetContextWithFallb GrSurfaceOrigin origin, const SkSurfaceProps* surfaceProps, SkBudgeted budgeted) { - SkASSERT(sampleCnt > 0); - if (0 == this->caps()->getRenderTargetSampleCount(sampleCnt, config)) { + if (!this->caps()->isConfigRenderable(config, sampleCnt > 0)) { config = GrPixelConfigFallback(config); } @@ -982,7 +968,6 @@ sk_sp GrContext::makeDeferredRenderTargetContext( GrSurfaceOrigin origin, const SkSurfaceProps* surfaceProps, SkBudgeted budgeted) { - SkASSERT(sampleCnt > 0); if (this->abandoned()) { return nullptr; } diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp index 955d57ddb0..eb005d110a 100644 --- a/src/gpu/GrGpu.cpp +++ b/src/gpu/GrGpu.cpp @@ -72,22 +72,68 @@ bool GrGpu::isACopyNeededForTextureParams(int width, int height, return false; } +/** + * Prior to creating a texture, make sure the type of texture being created is + * supported by calling check_texture_creation_params. + * + * @param caps The capabilities of the GL device. + * @param desc The descriptor of the texture to create. + * @param isRT Indicates if the texture can be a render target. + * @param texels The texel data for the mipmap levels + * @param mipLevelCount The number of GrMipLevels in 'texels' + */ +static bool check_texture_creation_params(const GrCaps& caps, const GrSurfaceDesc& desc, + bool* isRT, + const GrMipLevel texels[], int mipLevelCount) { + if (!caps.isConfigTexturable(desc.fConfig)) { + return false; + } + + if (GrPixelConfigIsSint(desc.fConfig) && mipLevelCount > 1) { + return false; + } + + *isRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag); + if (*isRT && !caps.isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) { + return false; + } + + // We currently do not support multisampled textures + if (!*isRT && desc.fSampleCnt > 0) { + return false; + } + + if (*isRT) { + int maxRTSize = caps.maxRenderTargetSize(); + if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) { + return false; + } + } else { + int maxSize = caps.maxTextureSize(); + if (desc.fWidth > maxSize || desc.fHeight > maxSize) { + return false; + } + } + + return true; +} + sk_sp GrGpu::createTexture(const GrSurfaceDesc& origDesc, SkBudgeted budgeted, const GrMipLevel texels[], int mipLevelCount) { GR_CREATE_TRACE_MARKER_CONTEXT("GrGpu", "createTexture", fContext); GrSurfaceDesc desc = origDesc; - GrMipMapped mipMapped = mipLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo; - if (!this->caps()->validateSurfaceDesc(desc, mipMapped)) { + const GrCaps* caps = this->caps(); + bool isRT = false; + bool textureCreationParamsValid = check_texture_creation_params(*caps, desc, &isRT, + texels, mipLevelCount); + if (!textureCreationParamsValid) { return nullptr; } - bool isRT = desc.fFlags & kRenderTarget_GrSurfaceFlag; - if (isRT) { - desc.fSampleCnt = this->caps()->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig); - } + desc.fSampleCnt = caps->getSampleCount(desc.fSampleCnt, desc.fConfig); // Attempt to catch un- or wrongly initialized sample counts. - SkASSERT(desc.fSampleCnt > 0 && desc.fSampleCnt <= 64); + SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64); if (mipLevelCount && (desc.fFlags & kPerformInitialClear_GrSurfaceFlag)) { return nullptr; @@ -96,7 +142,7 @@ sk_sp GrGpu::createTexture(const GrSurfaceDesc& origDesc, SkBudgeted this->handleDirtyContext(); sk_sp tex = this->onCreateTexture(desc, budgeted, texels, mipLevelCount); if (tex) { - if (!this->caps()->reuseScratchTextures() && !isRT) { + if (!caps->reuseScratchTextures() && !isRT) { tex->resourcePriv().removeScratchKey(); } fStats.incTextureCreates(); @@ -133,11 +179,8 @@ sk_sp GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex, sk_sp GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& backendTex, int sampleCnt, GrWrapOwnership ownership) { this->handleDirtyContext(); - if (sampleCnt < 1) { - return nullptr; - } if (!this->caps()->isConfigTexturable(backendTex.config()) || - !this->caps()->getRenderTargetSampleCount(sampleCnt, backendTex.config())) { + !this->caps()->isConfigRenderable(backendTex.config(), sampleCnt > 0)) { return nullptr; } @@ -154,7 +197,7 @@ sk_sp GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& bac } sk_sp GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) { - if (0 == this->caps()->getRenderTargetSampleCount(backendRT.sampleCnt(), backendRT.config())) { + if (!this->caps()->isConfigRenderable(backendRT.config(), backendRT.sampleCnt() > 0)) { return nullptr; } this->handleDirtyContext(); @@ -163,14 +206,14 @@ sk_sp GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget sk_sp GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& tex, int sampleCnt) { - if (0 == this->caps()->getRenderTargetSampleCount(sampleCnt, tex.config())) { + this->handleDirtyContext(); + if (!this->caps()->isConfigRenderable(tex.config(), sampleCnt > 0)) { return nullptr; } int maxSize = this->caps()->maxTextureSize(); if (tex.width() > maxSize || tex.height() > maxSize) { return nullptr; } - this->handleDirtyContext(); return this->onWrapBackendTextureAsRenderTarget(tex, sampleCnt); } @@ -219,7 +262,7 @@ bool GrGpu::getReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin, // Check to see if we're going to request that the caller draw when drawing is not possible. if (!srcSurface->asTexture() || - !this->caps()->isConfigRenderable(tempDrawInfo->fTempSurfaceDesc.fConfig)) { + !this->caps()->isConfigRenderable(tempDrawInfo->fTempSurfaceDesc.fConfig, false)) { // If we don't have a fallback to a straight read then fail. if (kRequireDraw_DrawPreference == *drawPreference) { return false; diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h index 6527064b93..2f12073f8a 100644 --- a/src/gpu/GrGpu.h +++ b/src/gpu/GrGpu.h @@ -455,10 +455,6 @@ public: /** Creates a texture directly in the backend API without wrapping it in a GrTexture. This is only to be used for testing (particularly for testing the methods that import an externally created texture into Skia. Must be matched with a call to deleteTestingOnlyTexture(). */ - GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h, SkColorType, - bool isRenderTarget, GrMipMapped); - - /** Older version based on GrPixelConfig. Currently the preferred one above devolves to this. */ virtual GrBackendTexture createTestingOnlyBackendTexture( void* pixels, int w, int h, GrPixelConfig config, diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp index 1a099144cf..ec05243d18 100644 --- a/src/gpu/GrProxyProvider.cpp +++ b/src/gpu/GrProxyProvider.cpp @@ -313,15 +313,38 @@ sk_sp GrProxyProvider::createProxy(const GrSurfaceDesc& desc, uint32_t flags) { SkASSERT(0 == flags || GrResourceProvider::kNoPendingIO_Flag == flags); - if (!this->caps()->validateSurfaceDesc(desc, GrMipMapped::kNo)) { + const GrCaps* caps = this->caps(); + + // TODO: move this logic into GrResourceProvider! + // TODO: share this testing code with check_texture_creation_params + if (!caps->isConfigTexturable(desc.fConfig)) { return nullptr; } - GrSurfaceDesc copyDesc = desc; - if (desc.fFlags & kRenderTarget_GrSurfaceFlag) { - copyDesc.fSampleCnt = - this->caps()->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig); + + bool willBeRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag); + if (willBeRT && !caps->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) { + return nullptr; } + // We currently do not support multisampled textures + if (!willBeRT && desc.fSampleCnt > 0) { + return nullptr; + } + + int maxSize; + if (willBeRT) { + maxSize = caps->maxRenderTargetSize(); + } else { + maxSize = caps->maxTextureSize(); + } + + if (desc.fWidth > maxSize || desc.fHeight > maxSize || desc.fWidth <= 0 || desc.fHeight <= 0) { + return nullptr; + } + + GrSurfaceDesc copyDesc = desc; + copyDesc.fSampleCnt = caps->getSampleCount(desc.fSampleCnt, desc.fConfig); + #ifdef SK_DISABLE_DEFERRED_PROXIES // Temporarily force instantiation for crbug.com/769760 and crbug.com/769898 sk_sp tex; @@ -338,11 +361,11 @@ sk_sp GrProxyProvider::createProxy(const GrSurfaceDesc& desc, return GrSurfaceProxy::MakeWrapped(std::move(tex), copyDesc.fOrigin); #else - if (copyDesc.fFlags & kRenderTarget_GrSurfaceFlag) { + if (willBeRT) { // We know anything we instantiate later from this deferred path will be // both texturable and renderable - return sk_sp( - new GrTextureRenderTargetProxy(*this->caps(), copyDesc, fit, budgeted, flags)); + return sk_sp(new GrTextureRenderTargetProxy(*caps, copyDesc, fit, + budgeted, flags)); } return sk_sp(new GrTextureProxy(copyDesc, fit, budgeted, nullptr, 0, flags)); @@ -482,7 +505,7 @@ sk_sp GrProxyProvider::createFullyLazyProxy(LazyInstantiateCallb desc.fWidth = -1; desc.fHeight = -1; desc.fConfig = config; - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; return this->createLazyProxy(std::move(callback), desc, GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes); diff --git a/src/gpu/GrRenderTarget.cpp b/src/gpu/GrRenderTarget.cpp index 36fa4ddf1b..3090219751 100644 --- a/src/gpu/GrRenderTarget.cpp +++ b/src/gpu/GrRenderTarget.cpp @@ -27,7 +27,7 @@ GrRenderTarget::GrRenderTarget(GrGpu* gpu, const GrSurfaceDesc& desc, , fMultisampleSpecsID(0) , fFlags(flags) { SkASSERT(desc.fFlags & kRenderTarget_GrSurfaceFlag); - SkASSERT(!(fFlags & GrRenderTargetFlags::kMixedSampled) || fSampleCnt > 1); + SkASSERT(!(fFlags & GrRenderTargetFlags::kMixedSampled) || fSampleCnt > 0); SkASSERT(!(fFlags & GrRenderTargetFlags::kWindowRectsSupport) || gpu->caps()->maxWindowRectangles() > 0); fResolveRect = SkRectPriv::MakeILargestInverted(); diff --git a/src/gpu/GrRenderTargetProxy.cpp b/src/gpu/GrRenderTargetProxy.cpp index 841d4b18fd..9eb37a0b2f 100644 --- a/src/gpu/GrRenderTargetProxy.cpp +++ b/src/gpu/GrRenderTargetProxy.cpp @@ -26,7 +26,7 @@ GrRenderTargetProxy::GrRenderTargetProxy(const GrCaps& caps, const GrSurfaceDesc , fRenderTargetFlags(GrRenderTargetFlags::kNone) { // Since we know the newly created render target will be internal, we are able to precompute // what the flags will ultimately end up being. - if (caps.usesMixedSamples() && fSampleCnt > 1) { + if (caps.usesMixedSamples() && fSampleCnt > 0) { fRenderTargetFlags |= GrRenderTargetFlags::kMixedSampled; } if (caps.maxWindowRectangles() > 0) { @@ -97,11 +97,7 @@ sk_sp GrRenderTargetProxy::createSurface(GrResourceProvider* resource } size_t GrRenderTargetProxy::onUninstantiatedGpuMemorySize() const { - int colorSamplesPerPixel = this->numColorSamples(); - if (colorSamplesPerPixel > 1) { - // Add one for the resolve buffer. - ++colorSamplesPerPixel; - } + int colorSamplesPerPixel = this->numColorSamples() + 1; // TODO: do we have enough information to improve this worst case estimate? return GrSurface::ComputeSize(this->config(), this->width(), this->height(), diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp index 226a034bea..9cf4e6c3e7 100644 --- a/src/gpu/GrResourceProvider.cpp +++ b/src/gpu/GrResourceProvider.cpp @@ -46,6 +46,28 @@ GrResourceProvider::GrResourceProvider(GrGpu* gpu, GrResourceCache* cache, GrSin fQuadIndexBufferKey = gQuadIndexBufferKey; } +bool validate_desc(const GrSurfaceDesc& desc, const GrCaps& caps, int levelCount = 0) { + if (desc.fWidth <= 0 || desc.fHeight <= 0) { + return false; + } + if (!caps.isConfigTexturable(desc.fConfig)) { + return false; + } + if (desc.fFlags & kRenderTarget_GrSurfaceFlag) { + if (!caps.isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) { + return false; + } + } else { + if (desc.fSampleCnt) { + return false; + } + } + if (levelCount > 1 && (GrPixelConfigIsSint(desc.fConfig) || !caps.mipMapSupport())) { + return false; + } + return true; +} + sk_sp GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, const GrMipLevel texels[], int mipLevelCount, SkDestinationSurfaceColorMode mipColorMode) { @@ -57,8 +79,7 @@ sk_sp GrResourceProvider::createTexture(const GrSurfaceDesc& desc, Sk return nullptr; } - GrMipMapped mipMapped = mipLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo; - if (!fCaps->validateSurfaceDesc(desc, mipMapped)) { + if (!validate_desc(desc, *fCaps, mipLevelCount)) { return nullptr; } @@ -103,7 +124,7 @@ sk_sp GrResourceProvider::createTexture(const GrSurfaceDesc& desc, return nullptr; } - if (!fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)) { + if (!validate_desc(desc, *fCaps)) { return nullptr; } @@ -135,11 +156,12 @@ sk_sp GrResourceProvider::createTexture(const GrSurfaceDesc& desc, sk_sp GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, uint32_t flags) { ASSERT_SINGLE_OWNER + if (this->isAbandoned()) { return nullptr; } - if (!fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)) { + if (!validate_desc(desc, *fCaps)) { return nullptr; } @@ -160,7 +182,7 @@ sk_sp GrResourceProvider::createApproxTexture(const GrSurfaceDesc& de return nullptr; } - if (!fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)) { + if (!validate_desc(desc, *fCaps)) { return nullptr; } @@ -189,7 +211,7 @@ sk_sp GrResourceProvider::refScratchTexture(const GrSurfaceDesc& desc uint32_t flags) { ASSERT_SINGLE_OWNER SkASSERT(!this->isAbandoned()); - SkASSERT(fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)); + SkASSERT(validate_desc(desc, *fCaps)); // We could make initial clears work with scratch textures but it is a rare case so we just opt // to fall back to making a new texture. diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h index 18df8597bd..bf7f28e93d 100644 --- a/src/gpu/GrResourceProvider.h +++ b/src/gpu/GrResourceProvider.h @@ -88,7 +88,7 @@ public: GrWrapOwnership = kBorrow_GrWrapOwnership); /** - * This makes the backend texture be renderable. If sampleCnt is > 1 and the underlying API + * This makes the backend texture be renderable. If sampleCnt is > 0 and the underlying API * uses separate MSAA render buffers then a MSAA render buffer is created that resolves * to the texture. */ diff --git a/src/gpu/GrSurface.cpp b/src/gpu/GrSurface.cpp index b35683c548..ec503d7066 100644 --- a/src/gpu/GrSurface.cpp +++ b/src/gpu/GrSurface.cpp @@ -29,9 +29,8 @@ size_t GrSurface::WorstCaseSize(const GrSurfaceDesc& desc, bool useNextPow2) { bool isRenderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag); if (isRenderTarget) { // We own one color value for each MSAA sample. - SkASSERT(desc.fSampleCnt >= 1); - int colorValuesPerPixel = desc.fSampleCnt; - if (desc.fSampleCnt > 1) { + int colorValuesPerPixel = SkTMax(1, desc.fSampleCnt); + if (desc.fSampleCnt) { // Worse case, we own the resolve buffer so that is one more sample per pixel. colorValuesPerPixel += 1; } diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp index 4020758259..64c47b56b1 100644 --- a/src/gpu/GrSurfaceProxy.cpp +++ b/src/gpu/GrSurfaceProxy.cpp @@ -26,7 +26,7 @@ static bool is_valid_fully_lazy(const GrSurfaceDesc& desc, SkBackingFit fit) { return desc.fWidth <= 0 && desc.fHeight <= 0 && desc.fConfig != kUnknown_GrPixelConfig && - desc.fSampleCnt == 1 && + desc.fSampleCnt == 0 && SkBackingFit::kApprox == fit; } @@ -190,7 +190,7 @@ bool GrSurfaceProxy::instantiateImpl(GrResourceProvider* resourceProvider, int s void GrSurfaceProxy::computeScratchKey(GrScratchKey* key) const { SkASSERT(LazyState::kFully != this->lazyInstantiationState()); const GrRenderTargetProxy* rtp = this->asRenderTargetProxy(); - int sampleCount = 1; + int sampleCount = 0; if (rtp) { sampleCount = rtp->numStencilSamples(); } diff --git a/src/gpu/GrTexture.cpp b/src/gpu/GrTexture.cpp index dd0631775f..b4cefb0174 100644 --- a/src/gpu/GrTexture.cpp +++ b/src/gpu/GrTexture.cpp @@ -78,7 +78,7 @@ bool GrTexture::StealBackendTexture(sk_sp&& texture, void GrTexture::computeScratchKey(GrScratchKey* key) const { const GrRenderTarget* rt = this->asRenderTarget(); - int sampleCount = 1; + int sampleCount = 0; if (rt) { sampleCount = rt->numStencilSamples(); } @@ -92,10 +92,8 @@ void GrTexturePriv::ComputeScratchKey(GrPixelConfig config, int width, int heigh GrMipMapped mipMapped, GrScratchKey* key) { static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType(); uint32_t flags = isRenderTarget; - SkASSERT(width > 0); - SkASSERT(height > 0); - SkASSERT(sampleCnt > 0); - SkASSERT(1 == sampleCnt || isRenderTarget); + + SkASSERT(0 == sampleCnt || isRenderTarget); // make sure desc.fConfig fits in 5 bits SkASSERT(sk_float_log2(kLast_GrPixelConfig) <= 5); diff --git a/src/gpu/GrTextureProducer.cpp b/src/gpu/GrTextureProducer.cpp index 9b344cb831..9593cb6873 100644 --- a/src/gpu/GrTextureProducer.cpp +++ b/src/gpu/GrTextureProducer.cpp @@ -25,8 +25,8 @@ sk_sp GrTextureProducer::CopyOnGpu(GrContext* context, GrMipMapped mipMapped = dstWillRequireMipMaps ? GrMipMapped::kYes : GrMipMapped::kNo; sk_sp copyRTC = context->makeDeferredRenderTargetContextWithFallback( - SkBackingFit::kExact, dstRect.width(), dstRect.height(), inputProxy->config(), nullptr, - 1, mipMapped, inputProxy->origin()); + SkBackingFit::kExact, dstRect.width(), dstRect.height(), inputProxy->config(), nullptr, + 0, mipMapped, inputProxy->origin()); if (!copyRTC) { return nullptr; } diff --git a/src/gpu/GrTextureProxy.cpp b/src/gpu/GrTextureProxy.cpp index 54d0769a63..8e6afbf0a7 100644 --- a/src/gpu/GrTextureProxy.cpp +++ b/src/gpu/GrTextureProxy.cpp @@ -64,7 +64,7 @@ bool GrTextureProxy::instantiate(GrResourceProvider* resourceProvider) { if (LazyState::kNot != this->lazyInstantiationState()) { return false; } - if (!this->instantiateImpl(resourceProvider, 1, /* needsStencil = */ false, + if (!this->instantiateImpl(resourceProvider, 0, /* needsStencil = */ false, kNone_GrSurfaceFlags, fMipMapped, fMipColorMode, fUniqueKey.isValid() ? &fUniqueKey : nullptr)) { return false; @@ -76,7 +76,7 @@ bool GrTextureProxy::instantiate(GrResourceProvider* resourceProvider) { } sk_sp GrTextureProxy::createSurface(GrResourceProvider* resourceProvider) const { - sk_sp surface= this->createSurfaceImpl(resourceProvider, 1, + sk_sp surface= this->createSurfaceImpl(resourceProvider, 0, /* needsStencil = */ false, kNone_GrSurfaceFlags, fMipMapped, fMipColorMode); diff --git a/src/gpu/GrTextureRenderTargetProxy.cpp b/src/gpu/GrTextureRenderTargetProxy.cpp index 843524c062..da8e48307d 100644 --- a/src/gpu/GrTextureRenderTargetProxy.cpp +++ b/src/gpu/GrTextureRenderTargetProxy.cpp @@ -53,11 +53,7 @@ GrTextureRenderTargetProxy::GrTextureRenderTargetProxy(sk_sp surf, } size_t GrTextureRenderTargetProxy::onUninstantiatedGpuMemorySize() const { - int colorSamplesPerPixel = this->numColorSamples(); - if (colorSamplesPerPixel > 1) { - // Add one to account for the resolve buffer. - ++colorSamplesPerPixel += 1; - } + int colorSamplesPerPixel = this->numColorSamples() + 1; // TODO: do we have enough information to improve this worst case estimate? return GrSurface::ComputeSize(this->config(), this->width(), this->height(), diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp index af0579a098..90fe4f62d6 100644 --- a/src/gpu/SkGr.cpp +++ b/src/gpu/SkGr.cpp @@ -47,7 +47,7 @@ GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo& info, const GrCaps& ca desc.fWidth = info.width(); desc.fHeight = info.height(); desc.fConfig = SkImageInfo2GrPixelConfig(info, caps); - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; return desc; } @@ -169,7 +169,7 @@ sk_sp GrCopyBaseMipMapToTextureProxy(GrContext* ctx, GrTexturePr desc.fWidth = baseProxy->width(); desc.fHeight = baseProxy->height(); desc.fConfig = baseProxy->config(); - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp proxy = proxyProvider->createMipMapProxy(desc, SkBudgeted::kYes); if (!proxy) { diff --git a/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp b/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp index da6991745f..abe888044e 100644 --- a/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp +++ b/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp @@ -42,7 +42,7 @@ bool GrCoverageCountingPathRenderer::IsSupported(const GrCaps& caps) { return shaderCaps.integerSupport() && shaderCaps.flatInterpolationSupport() && caps.instanceAttribSupport() && GrCaps::kNone_MapFlags != caps.mapBufferFlags() && caps.isConfigTexturable(kAlpha_half_GrPixelConfig) && - caps.isConfigRenderable(kAlpha_half_GrPixelConfig) && + caps.isConfigRenderable(kAlpha_half_GrPixelConfig, /*withMSAA=*/false) && !caps.blacklistCoverageCounting(); } diff --git a/src/gpu/ddl/GrDDLGpu.h b/src/gpu/ddl/GrDDLGpu.h index e1f463f073..16deab0353 100644 --- a/src/gpu/ddl/GrDDLGpu.h +++ b/src/gpu/ddl/GrDDLGpu.h @@ -46,7 +46,7 @@ public: void onQueryMultisampleSpecs(GrRenderTarget* rt, GrSurfaceOrigin, const GrStencilSettings&, int* effectiveSampleCnt, SamplePattern*) override { SkASSERT(0); - *effectiveSampleCnt = 1; // ?? + *effectiveSampleCnt = 0; // ?? } GrGpuRTCommandBuffer* createCommandBuffer( diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp index 066bf03512..3b90676be1 100644 --- a/src/gpu/gl/GrGLCaps.cpp +++ b/src/gpu/gl/GrGLCaps.cpp @@ -1958,8 +1958,6 @@ void GrGLCaps::initConfigTable(const GrContextOptions& contextOptions, for (int i = 0; i < kGrPixelConfigCnt; ++i) { if (ConfigInfo::kRenderableWithMSAA_Flag & fConfigTable[i].fFlags) { - // We assume that MSAA rendering is supported only if we support non-MSAA rendering. - SkASSERT(ConfigInfo::kRenderable_Flag & fConfigTable[i].fFlags); if ((kGL_GrGLStandard == ctxInfo.standard() && (ctxInfo.version() >= GR_GL_VER(4,2) || ctxInfo.hasExtension("GL_ARB_internalformat_query"))) || @@ -1972,15 +1970,10 @@ void GrGLCaps::initConfigTable(const GrContextOptions& contextOptions, int* temp = new int[count]; GR_GL_GetInternalformativ(gli, GR_GL_RENDERBUFFER, format, GR_GL_SAMPLES, count, temp); - // GL has a concept of MSAA rasterization with a single sample but we do not. - if (count && temp[count - 1] == 1) { - --count; - SkASSERT(!count || temp[count -1] > 1); - } fConfigTable[i].fColorSampleCounts.setCount(count+1); - // We initialize our supported values with 1 (no msaa) and reverse the order + // We initialize our supported values with 0 (no msaa) and reverse the order // returned by GL so that the array is ascending. - fConfigTable[i].fColorSampleCounts[0] = 1; + fConfigTable[i].fColorSampleCounts[0] = 0; for (int j = 0; j < count; ++j) { fConfigTable[i].fColorSampleCounts[j+1] = temp[count - j - 1]; } @@ -1989,16 +1982,14 @@ void GrGLCaps::initConfigTable(const GrContextOptions& contextOptions, } else { // Fake out the table using some semi-standard counts up to the max allowed sample // count. - int maxSampleCnt = 1; + int maxSampleCnt = 0; if (GrGLCaps::kES_IMG_MsToTexture_MSFBOType == fMSFBOType) { GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES_IMG, &maxSampleCnt); } else if (GrGLCaps::kNone_MSFBOType != fMSFBOType) { GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES, &maxSampleCnt); } - // Chrome has a mock GL implementation that returns 0. - maxSampleCnt = SkTMax(1, maxSampleCnt); - static constexpr int kDefaultSamples[] = {1, 2, 4, 8}; + static constexpr int kDefaultSamples[] = {0, 1, 2, 4, 8}; int count = SK_ARRAY_COUNT(kDefaultSamples); for (; count > 0; --count) { if (kDefaultSamples[count - 1] <= maxSampleCnt) { @@ -2009,9 +2000,6 @@ void GrGLCaps::initConfigTable(const GrContextOptions& contextOptions, fConfigTable[i].fColorSampleCounts.append(count, kDefaultSamples); } } - } else if (ConfigInfo::kRenderable_Flag & fConfigTable[i].fFlags) { - fConfigTable[i].fColorSampleCounts.setCount(1); - fConfigTable[i].fColorSampleCounts[0] = 1; } } @@ -2046,7 +2034,7 @@ bool GrGLCaps::initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* // If the src is a texture, we can implement the blit as a draw assuming the config is // renderable. - if (src->asTextureProxy() && !this->isConfigRenderable(src->config())) { + if (src->asTextureProxy() && this->isConfigRenderable(src->config(), false)) { desc->fOrigin = kBottomLeft_GrSurfaceOrigin; desc->fFlags = kRenderTarget_GrSurfaceFlag; desc->fConfig = src->config(); @@ -2468,31 +2456,18 @@ void GrGLCaps::onApplyOptionsOverrides(const GrContextOptions& options) { } } -int GrGLCaps::getRenderTargetSampleCount(int requestedCount, GrPixelConfig config) const { - requestedCount = SkTMax(1, requestedCount); +int GrGLCaps::getSampleCount(int requestedCount, GrPixelConfig config) const { int count = fConfigTable[config].fColorSampleCounts.count(); - if (!count) { + if (!count || !this->isConfigRenderable(config, true)) { return 0; } - if (1 == requestedCount) { - return fConfigTable[config].fColorSampleCounts[0] == 1 ? 1 : 0; - } - for (int i = 0; i < count; ++i) { if (fConfigTable[config].fColorSampleCounts[i] >= requestedCount) { return fConfigTable[config].fColorSampleCounts[i]; } } - return 0; -} - -int GrGLCaps::maxRenderTargetSampleCount(GrPixelConfig config) const { - const auto& table = fConfigTable[config].fColorSampleCounts; - if (!table.count()) { - return 0; - } - return table[table.count() - 1]; + return fConfigTable[config].fColorSampleCounts[count-1]; } bool validate_sized_format(GrGLenum format, SkColorType ct, GrPixelConfig* config, diff --git a/src/gpu/gl/GrGLCaps.h b/src/gpu/gl/GrGLCaps.h index 7a443e49b0..fd49a65598 100644 --- a/src/gpu/gl/GrGLCaps.h +++ b/src/gpu/gl/GrGLCaps.h @@ -112,12 +112,19 @@ public: GrGLCaps(const GrContextOptions& contextOptions, const GrGLContextInfo& ctxInfo, const GrGLInterface* glInterface); + int getSampleCount(int requestedCount, GrPixelConfig config) const override; + bool isConfigTexturable(GrPixelConfig config) const override { return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kTextureable_Flag); } - int getRenderTargetSampleCount(int requestedCount, GrPixelConfig config) const override; - int maxRenderTargetSampleCount(GrPixelConfig config) const override; + bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const override { + if (withMSAA) { + return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kRenderableWithMSAA_Flag); + } else { + return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kRenderable_Flag); + } + } bool isConfigCopyable(GrPixelConfig config) const override { // In GL we have three ways to be able to copy. CopyTexImage, blit, and draw. CopyTexImage diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp index 7547803e6f..ae31495b06 100644 --- a/src/gpu/gl/GrGLGpu.cpp +++ b/src/gpu/gl/GrGLGpu.cpp @@ -545,7 +545,7 @@ sk_sp GrGLGpu::onWrapBackendTexture(const GrBackendTexture& backendTe surfDesc.fWidth = backendTex.width(); surfDesc.fHeight = backendTex.height(); surfDesc.fConfig = backendTex.config(); - surfDesc.fSampleCnt = 1; + surfDesc.fSampleCnt = 0; GrMipMapsStatus mipMapsStatus = backendTex.hasMipMaps() ? GrMipMapsStatus::kValid : GrMipMapsStatus::kNotAllocated; @@ -581,10 +581,7 @@ sk_sp GrGLGpu::onWrapRenderableBackendTexture(const GrBackendTexture& surfDesc.fWidth = backendTex.width(); surfDesc.fHeight = backendTex.height(); surfDesc.fConfig = backendTex.config(); - surfDesc.fSampleCnt = this->caps()->getRenderTargetSampleCount(sampleCnt, backendTex.config()); - if (surfDesc.fSampleCnt < 1) { - return nullptr; - } + surfDesc.fSampleCnt = this->caps()->getSampleCount(sampleCnt, backendTex.config()); GrGLRenderTarget::IDDesc rtIDDesc; if (!this->createRenderTargetObjects(surfDesc, idDesc.fInfo, &rtIDDesc)) { @@ -619,8 +616,7 @@ sk_sp GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTa desc.fWidth = backendRT.width(); desc.fHeight = backendRT.height(); desc.fConfig = backendRT.config(); - desc.fSampleCnt = - this->caps()->getRenderTargetSampleCount(backendRT.sampleCnt(), backendRT.config()); + desc.fSampleCnt = this->caps()->getSampleCount(backendRT.sampleCnt(), backendRT.config()); return GrGLRenderTarget::MakeWrapped(this, desc, idDesc, backendRT.stencilBits()); } @@ -649,7 +645,7 @@ sk_sp GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBacken surfDesc.fWidth = tex.width(); surfDesc.fHeight = tex.height(); surfDesc.fConfig = tex.config(); - surfDesc.fSampleCnt = this->caps()->getRenderTargetSampleCount(sampleCnt, tex.config()); + surfDesc.fSampleCnt = this->caps()->getSampleCount(sampleCnt, tex.config()); GrGLRenderTarget::IDDesc rtIDDesc; if (!this->createRenderTargetObjects(surfDesc, texInfo, &rtIDDesc)) { @@ -690,7 +686,7 @@ bool GrGLGpu::onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOri } // If the dst is MSAA, we have to draw, or we'll just be writing to the resolve target. - if (dstSurface->asRenderTarget() && dstSurface->asRenderTarget()->numColorSamples() > 1) { + if (dstSurface->asRenderTarget() && dstSurface->asRenderTarget()->numColorSamples() > 0) { ElevateDrawPreference(drawPreference, kRequireDraw_DrawPreference); } @@ -708,7 +704,7 @@ bool GrGLGpu::onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOri tempDrawInfo->fTempSurfaceDesc.fConfig = srcConfig; tempDrawInfo->fTempSurfaceDesc.fWidth = width; tempDrawInfo->fTempSurfaceDesc.fHeight = height; - tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 1; + tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 0; tempDrawInfo->fTempSurfaceDesc.fOrigin = kTopLeft_GrSurfaceOrigin; // no CPU y-flip for TL. bool configsAreRBSwaps = GrPixelConfigSwapRAndB(srcConfig) == dstSurface->config(); @@ -1281,13 +1277,13 @@ bool GrGLGpu::createRenderTargetObjects(const GrSurfaceDesc& desc, idDesc->fTexFBOID = 0; SkASSERT((GrGLCaps::kMixedSamples_MSFBOType == this->glCaps().msFBOType()) == this->caps()->usesMixedSamples()); - idDesc->fIsMixedSampled = desc.fSampleCnt > 1 && this->caps()->usesMixedSamples(); + idDesc->fIsMixedSampled = desc.fSampleCnt > 0 && this->caps()->usesMixedSamples(); GrGLenum status; GrGLenum colorRenderbufferFormat = 0; // suppress warning - if (desc.fSampleCnt > 1 && GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType()) { + if (desc.fSampleCnt > 0 && GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType()) { goto FAILED; } @@ -1300,7 +1296,7 @@ bool GrGLGpu::createRenderTargetObjects(const GrSurfaceDesc& desc, // the texture bound to the other. The exception is the IMG multisample extension. With this // extension the texture is multisampled when rendered to and then auto-resolves it when it is // rendered from. - if (desc.fSampleCnt > 1 && this->glCaps().usesMSAARenderBuffers()) { + if (desc.fSampleCnt > 0 && this->glCaps().usesMSAARenderBuffers()) { GL_CALL(GenFramebuffers(1, &idDesc->fRTFBOID)); GL_CALL(GenRenderbuffers(1, &idDesc->fMSColorRenderbufferID)); if (!idDesc->fRTFBOID || @@ -1317,7 +1313,7 @@ bool GrGLGpu::createRenderTargetObjects(const GrSurfaceDesc& desc, // below here we may bind the FBO fHWBoundRenderTargetUniqueID.makeInvalid(); if (idDesc->fRTFBOID != idDesc->fTexFBOID) { - SkASSERT(desc.fSampleCnt > 1); + SkASSERT(desc.fSampleCnt > 0); GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, idDesc->fMSColorRenderbufferID)); if (!renderbuffer_storage_msaa(*fGLContext, desc.fSampleCnt, @@ -1342,7 +1338,7 @@ bool GrGLGpu::createRenderTargetObjects(const GrSurfaceDesc& desc, fStats.incRenderTargetBinds(); GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, idDesc->fTexFBOID)); - if (this->glCaps().usesImplicitMSAAResolve() && desc.fSampleCnt > 1) { + if (this->glCaps().usesImplicitMSAAResolve() && desc.fSampleCnt > 0) { GL_CALL(FramebufferTexture2DMultisample(GR_GL_FRAMEBUFFER, GR_GL_COLOR_ATTACHMENT0, texInfo.fTarget, @@ -1419,7 +1415,7 @@ sk_sp GrGLGpu::onCreateTexture(const GrSurfaceDesc& desc, const GrMipLevel texels[], int mipLevelCount) { // We fail if the MSAA was requested and is not available. - if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType() && desc.fSampleCnt > 1) { + if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType() && desc.fSampleCnt) { //SkDebugf("MSAA RT requested but not supported on this platform."); return return_null_texture(); } @@ -1528,7 +1524,7 @@ void inline get_stencil_rb_sizes(const GrGLInterface* gl, int GrGLGpu::getCompatibleStencilIndex(GrPixelConfig config) { static const int kSize = 16; - SkASSERT(this->caps()->isConfigRenderable(config)); + SkASSERT(this->caps()->isConfigRenderable(config, false)); if (!this->glCaps().hasStencilFormatBeenDeterminedForConfig(config)) { // Default to unsupported, set this if we find a stencil format that works. int firstWorkingStencilFormatIndex = -1; @@ -1698,7 +1694,7 @@ GrStencilAttachment* GrGLGpu::createStencilAttachmentForRenderTarget(const GrRen CLEAR_ERROR_BEFORE_ALLOC(this->glInterface()); // we do this "if" so that we don't call the multisample // version on a GL that doesn't have an MSAA extension. - if (samples > 1) { + if (samples > 0) { SkAssertResult(renderbuffer_storage_msaa(*fGLContext, samples, sFmt.fInternalFormat, @@ -2137,7 +2133,7 @@ bool GrGLGpu::readPixelsSupported(GrPixelConfig rtConfig, GrPixelConfig readConf GrSurfaceDesc desc; desc.fConfig = rtConfig; desc.fWidth = desc.fHeight = 16; - if (this->glCaps().isConfigRenderable(rtConfig)) { + if (this->glCaps().isConfigRenderable(rtConfig, false)) { desc.fFlags = kRenderTarget_GrSurfaceFlag; desc.fOrigin = kBottomLeft_GrSurfaceOrigin; temp = this->createTexture(desc, SkBudgeted::kNo); @@ -2198,7 +2194,7 @@ bool GrGLGpu::onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrig tempDrawInfo->fTempSurfaceDesc.fFlags = kRenderTarget_GrSurfaceFlag; tempDrawInfo->fTempSurfaceDesc.fWidth = width; tempDrawInfo->fTempSurfaceDesc.fHeight = height; - tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 1; + tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 0; tempDrawInfo->fTempSurfaceDesc.fOrigin = kTopLeft_GrSurfaceOrigin; // no CPU y-flip for TL. tempDrawInfo->fTempSurfaceFit = this->glCaps().partialFBOReadIsSlow() ? SkBackingFit::kExact : SkBackingFit::kApprox; @@ -3338,8 +3334,8 @@ static inline bool can_blit_framebuffer_for_copy_surface( } } if (GrGLCaps::kResolveMustBeFull_BlitFrambufferFlag & blitFramebufferFlags) { - if (srcRT && srcRT->numColorSamples() > 1) { - if (dstRT && 1 == dstRT->numColorSamples()) { + if (srcRT && srcRT->numColorSamples()) { + if (dstRT && !dstRT->numColorSamples()) { return false; } if (SkRect::Make(srcRect) != srcRT->getBoundsRect()) { @@ -3348,7 +3344,7 @@ static inline bool can_blit_framebuffer_for_copy_surface( } } if (GrGLCaps::kNoMSAADst_BlitFramebufferFlag & blitFramebufferFlags) { - if (dstRT && dstRT->numColorSamples() > 1) { + if (dstRT && dstRT->numColorSamples() > 0) { return false; } } @@ -3358,12 +3354,12 @@ static inline bool can_blit_framebuffer_for_copy_surface( } } else if (GrGLCaps::kNoFormatConversionForMSAASrc_BlitFramebufferFlag & blitFramebufferFlags) { const GrRenderTarget* srcRT = src->asRenderTarget(); - if (srcRT && srcRT->numColorSamples() > 1 && dst->config() != src->config()) { + if (srcRT && srcRT->numColorSamples() && dst->config() != src->config()) { return false; } } if (GrGLCaps::kRectsMustMatchForMSAASrc_BlitFramebufferFlag & blitFramebufferFlags) { - if (srcRT && srcRT->numColorSamples() > 1) { + if (srcRT && srcRT->numColorSamples()) { if (dstPoint.fX != srcRect.fLeft || dstPoint.fY != srcRect.fTop) { return false; } @@ -3380,7 +3376,7 @@ static bool rt_has_msaa_render_buffer(const GrGLRenderTarget* rt, const GrGLCaps // 1) It's multisampled // 2) We're using an extension with separate MSAA renderbuffers // 3) It's not FBO 0, which is special and always auto-resolves - return rt->numColorSamples() > 1 && glCaps.usesMSAARenderBuffers() && rt->renderFBOID() != 0; + return rt->numColorSamples() > 0 && glCaps.usesMSAARenderBuffers() && rt->renderFBOID() != 0; } static inline bool can_copy_texsubimage(const GrSurface* dst, GrSurfaceOrigin dstOrigin, diff --git a/src/gpu/gl/GrGLRenderTarget.cpp b/src/gpu/gl/GrGLRenderTarget.cpp index 6f3714c504..443128d4d4 100644 --- a/src/gpu/gl/GrGLRenderTarget.cpp +++ b/src/gpu/gl/GrGLRenderTarget.cpp @@ -224,7 +224,7 @@ int GrGLRenderTarget::msaaSamples() const { if (fTexFBOID == kUnresolvableFBOID || fTexFBOID != fRTFBOID) { // If the render target's FBO is external (fTexFBOID == kUnresolvableFBOID), or if we own // the render target's FBO (fTexFBOID == fRTFBOID) then we use the provided sample count. - return this->numStencilSamples(); + return SkTMax(1, this->numStencilSamples()); } // When fTexFBOID == fRTFBOID, we either are not using MSAA, or MSAA is auto resolving, so use diff --git a/src/gpu/gl/GrGLStencilAttachment.cpp b/src/gpu/gl/GrGLStencilAttachment.cpp index 5c07a7d383..aa813ed50e 100644 --- a/src/gpu/gl/GrGLStencilAttachment.cpp +++ b/src/gpu/gl/GrGLStencilAttachment.cpp @@ -14,7 +14,7 @@ size_t GrGLStencilAttachment::onGpuMemorySize() const { uint64_t size = this->width(); size *= this->height(); size *= fFormat.fTotalBits; - size *= this->numSamples(); + size *= SkTMax(1,this->numSamples()); return static_cast(size / 8); } diff --git a/src/gpu/mock/GrMockCaps.h b/src/gpu/mock/GrMockCaps.h index 1e448516d7..edec5563c4 100644 --- a/src/gpu/mock/GrMockCaps.h +++ b/src/gpu/mock/GrMockCaps.h @@ -33,39 +33,19 @@ public: this->applyOptionsOverrides(contextOptions); } + int getSampleCount(int /*requestCount*/, GrPixelConfig /*config*/) const override { + return 0; + } bool isConfigTexturable(GrPixelConfig config) const override { return fOptions.fConfigOptions[config].fTexturable; } - + bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const override { + return fOptions.fConfigOptions[config].fRenderable[withMSAA]; + } bool isConfigCopyable(GrPixelConfig config) const override { return false; } - int getRenderTargetSampleCount(int requestCount, GrPixelConfig config) const override { - requestCount = SkTMax(requestCount, 1); - switch (fOptions.fConfigOptions[config].fRenderability) { - case GrMockOptions::ConfigOptions::Renderability::kNo: - return 0; - case GrMockOptions::ConfigOptions::Renderability::kNonMSAA: - return requestCount > 1 ? 0 : 1; - case GrMockOptions::ConfigOptions::Renderability::kMSAA: - return requestCount > kMaxSampleCnt ? 0 : GrNextPow2(requestCount); - } - return 0; - } - - int maxRenderTargetSampleCount(GrPixelConfig config) const override { - switch (fOptions.fConfigOptions[config].fRenderability) { - case GrMockOptions::ConfigOptions::Renderability::kNo: - return 0; - case GrMockOptions::ConfigOptions::Renderability::kNonMSAA: - return 1; - case GrMockOptions::ConfigOptions::Renderability::kMSAA: - return kMaxSampleCnt; - } - return 0; - } - bool initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* desc, bool* rectsMustMatch, bool* disallowSubrect) const override { return false; @@ -82,8 +62,6 @@ public: } private: - static const int kMaxSampleCnt = 16; - GrMockOptions fOptions; typedef GrCaps INHERITED; }; diff --git a/src/gpu/mock/GrMockTexture.h b/src/gpu/mock/GrMockTexture.h index b5cc4a27c0..9b6501a3c4 100644 --- a/src/gpu/mock/GrMockTexture.h +++ b/src/gpu/mock/GrMockTexture.h @@ -90,11 +90,8 @@ private: } size_t onGpuMemorySize() const override { - int numColorSamples = this->numColorSamples(); - if (numColorSamples > 1) { - // Add one to account for the resolve buffer. - ++numColorSamples; - } + // The plus 1 is to account for the resolve texture. + int numColorSamples = this->numColorSamples() + 1; return GrSurface::ComputeSize(this->config(), this->width(), this->height(), numColorSamples, this->texturePriv().mipMapped()); diff --git a/src/gpu/mtl/GrMtlCaps.h b/src/gpu/mtl/GrMtlCaps.h index 935cb07822..6204eaac5a 100644 --- a/src/gpu/mtl/GrMtlCaps.h +++ b/src/gpu/mtl/GrMtlCaps.h @@ -24,12 +24,20 @@ public: GrMtlCaps(const GrContextOptions& contextOptions, id device, MTLFeatureSet featureSet); + int getSampleCount(int requestedCount, GrPixelConfig config) const override; + bool isConfigTexturable(GrPixelConfig config) const override { return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kTextureable_Flag); } - int getRenderTargetSampleCount(int requestedCount, GrPixelConfig) const override; - int maxRenderTargetSampleCount(GrPixelConfig) const override; + bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const override { + if (withMSAA) { + return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kRenderable_Flag) && + SkToBool(fConfigTable[config].fFlags & ConfigInfo::kMSAA_Flag); + } else { + return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kRenderable_Flag); + } + } bool isConfigCopyable(GrPixelConfig config) const override { return true; diff --git a/src/gpu/mtl/GrMtlCaps.mm b/src/gpu/mtl/GrMtlCaps.mm index 0bb7530fe2..2bce74a261 100644 --- a/src/gpu/mtl/GrMtlCaps.mm +++ b/src/gpu/mtl/GrMtlCaps.mm @@ -121,7 +121,7 @@ void GrMtlCaps::initGrCaps(const id device) { fMaxTextureSize = fMaxRenderTargetSize; // Init sample counts. All devices support 1 (i.e. 0 in skia). - fSampleCounts.push(1); + fSampleCounts.push(0); for (auto sampleCnt : {2, 4, 8}) { if ([device supportsTextureSampleCount:sampleCnt]) { fSampleCounts.push(sampleCnt); @@ -164,29 +164,19 @@ void GrMtlCaps::initGrCaps(const id device) { fCrossContextTextureSupport = false; } - -int GrMtlCaps::maxRenderTargetSampleCount(GrPixelConfig config) const { - if (fConfigTable[config].fFlags & ConfigInfo::kMSAA_Flag) { - return fSampleCounts[fSampleCounts.count() - 1]; - } else if (fConfigTable[config].fFlags & ConfigInfo::kRenderable_Flag) { - return 1; +int GrMtlCaps::getSampleCount(int requestedCount, GrPixelConfig config) const { + int count = fSampleCounts.count(); + SkASSERT(count > 0); // We always add 0 as a valid sample count + if (!this->isConfigRenderable(config, true)) { + return 0; } - return 0; -} -int GrMtlCaps::getRenderTargetSampleCount(int requestedCount, GrPixelConfig config) const { - requestedCount = SkTMax(requestedCount, 1); - if (fConfigTable[config].fFlags & ConfigInfo::kMSAA_Flag) { - int count = fSampleCounts.count(); - for (int i = 0; i < count; ++i) { - if (fSampleCounts[i] >= requestedCount) { - return fSampleCounts[i]; - } + for (int i = 0; i < count; ++i) { + if (fSampleCounts[i] >= requestedCount) { + return fSampleCounts[i]; } - } else if (fConfigTable[config].fFlags & ConfigInfo::kRenderable_Flag) { - return 1 == requestedCount ? 1 : 0; } - return 0; + return fSampleCounts[count-1]; } void GrMtlCaps::initShaderCaps() { diff --git a/src/gpu/vk/GrVkCaps.cpp b/src/gpu/vk/GrVkCaps.cpp index 8af81190af..0ae7c00995 100644 --- a/src/gpu/vk/GrVkCaps.cpp +++ b/src/gpu/vk/GrVkCaps.cpp @@ -346,7 +346,7 @@ void GrVkCaps::ConfigInfo::initSampleCounts(const GrVkInterface* interface, &properties)); VkSampleCountFlags flags = properties.sampleCounts; if (flags & VK_SAMPLE_COUNT_1_BIT) { - fColorSampleCounts.push(1); + fColorSampleCounts.push(0); } if (kImagination_VkVendor == physProps.vendorID) { // MSAA does not work on imagination @@ -386,34 +386,18 @@ void GrVkCaps::ConfigInfo::init(const GrVkInterface* interface, } } -int GrVkCaps::getRenderTargetSampleCount(int requestedCount, GrPixelConfig config) const { - requestedCount = SkTMax(1, requestedCount); +int GrVkCaps::getSampleCount(int requestedCount, GrPixelConfig config) const { int count = fConfigTable[config].fColorSampleCounts.count(); - - if (!count) { + if (!count || !this->isConfigRenderable(config, true)) { return 0; } - if (1 == requestedCount) { - SkASSERT(fConfigTable[config].fColorSampleCounts.count() && - fConfigTable[config].fColorSampleCounts[0] == 1); - return 1; - } - for (int i = 0; i < count; ++i) { if (fConfigTable[config].fColorSampleCounts[i] >= requestedCount) { return fConfigTable[config].fColorSampleCounts[i]; } } - return 0; -} - -int GrVkCaps::maxRenderTargetSampleCount(GrPixelConfig config) const { - const auto& table = fConfigTable[config].fColorSampleCounts; - if (!table.count()) { - return 0; - } - return table[table.count() - 1]; + return fConfigTable[config].fColorSampleCounts[count-1]; } bool validate_image_info(const GrVkImageInfo* imageInfo, SkColorType ct, GrPixelConfig* config) { diff --git a/src/gpu/vk/GrVkCaps.h b/src/gpu/vk/GrVkCaps.h index 3449dd2ccc..d63c2ba9b5 100644 --- a/src/gpu/vk/GrVkCaps.h +++ b/src/gpu/vk/GrVkCaps.h @@ -29,17 +29,20 @@ public: GrVkCaps(const GrContextOptions& contextOptions, const GrVkInterface* vkInterface, VkPhysicalDevice device, uint32_t featureFlags, uint32_t extensionFlags); + int getSampleCount(int requestedCount, GrPixelConfig config) const override; + bool isConfigTexturable(GrPixelConfig config) const override { return SkToBool(ConfigInfo::kTextureable_Flag & fConfigTable[config].fOptimalFlags); } + bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const override { + return SkToBool(ConfigInfo::kRenderable_Flag & fConfigTable[config].fOptimalFlags); + } + bool isConfigCopyable(GrPixelConfig config) const override { return true; } - int getRenderTargetSampleCount(int requestedCount, GrPixelConfig config) const override; - int maxRenderTargetSampleCount(GrPixelConfig config) const override; - bool isConfigTexturableLinearly(GrPixelConfig config) const { return SkToBool(ConfigInfo::kTextureable_Flag & fConfigTable[config].fLinearFlags); } diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp index 362ac1fa2b..f7e3d47dd9 100644 --- a/src/gpu/vk/GrVkGpu.cpp +++ b/src/gpu/vk/GrVkGpu.cpp @@ -352,7 +352,7 @@ bool GrVkGpu::onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOri tempDrawInfo->fTempSurfaceDesc.fConfig = srcConfig; tempDrawInfo->fTempSurfaceDesc.fWidth = width; tempDrawInfo->fTempSurfaceDesc.fHeight = height; - tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 1; + tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 0; tempDrawInfo->fTempSurfaceDesc.fOrigin = kTopLeft_GrSurfaceOrigin; if (dstSurface->config() == srcConfig) { @@ -777,7 +777,17 @@ sk_sp GrVkGpu::onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag); VkFormat pixelFormat; - SkAssertResult(GrPixelConfigToVkFormat(desc.fConfig, &pixelFormat)); + if (!GrPixelConfigToVkFormat(desc.fConfig, &pixelFormat)) { + return nullptr; + } + + if (!fVkCaps->isConfigTexturable(desc.fConfig)) { + return nullptr; + } + + if (renderTarget && !fVkCaps->isConfigRenderable(desc.fConfig, false)) { + return nullptr; + } VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT; if (renderTarget) { @@ -904,7 +914,7 @@ sk_sp GrVkGpu::onWrapBackendTexture(const GrBackendTexture& backendTe surfDesc.fWidth = backendTex.width(); surfDesc.fHeight = backendTex.height(); surfDesc.fConfig = backendTex.config(); - surfDesc.fSampleCnt = 1; + surfDesc.fSampleCnt = 0; return GrVkTexture::MakeWrappedTexture(this, surfDesc, ownership, backendTex.getVkImageInfo()); } @@ -922,7 +932,7 @@ sk_sp GrVkGpu::onWrapRenderableBackendTexture(const GrBackendTexture& surfDesc.fWidth = backendTex.width(); surfDesc.fHeight = backendTex.height(); surfDesc.fConfig = backendTex.config(); - surfDesc.fSampleCnt = this->caps()->getRenderTargetSampleCount(sampleCnt, backendTex.config()); + surfDesc.fSampleCnt = this->caps()->getSampleCount(sampleCnt, backendTex.config()); return GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(this, surfDesc, ownership, backendTex.getVkImageInfo()); @@ -933,7 +943,7 @@ sk_sp GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTa // general this is not an issue since swapchain images in vulkan are never multisampled. Thus if // you want a multisampled RT it is best to wrap the swapchain images and then let Skia handle // creating and owning the MSAA images. - if (backendRT.sampleCnt() > 1) { + if (backendRT.sampleCnt()) { return nullptr; } @@ -951,7 +961,7 @@ sk_sp GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTa desc.fWidth = backendRT.width(); desc.fHeight = backendRT.height(); desc.fConfig = backendRT.config(); - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp tgt = GrVkRenderTarget::MakeWrappedRenderTarget(this, desc, info); if (tgt && backendRT.stencilBits()) { @@ -979,10 +989,7 @@ sk_sp GrVkGpu::onWrapBackendTextureAsRenderTarget(const GrBacken desc.fWidth = tex.width(); desc.fHeight = tex.height(); desc.fConfig = tex.config(); - desc.fSampleCnt = this->caps()->getRenderTargetSampleCount(sampleCnt, tex.config()); - if (!desc.fSampleCnt) { - return nullptr; - } + desc.fSampleCnt = this->caps()->getSampleCount(sampleCnt, tex.config()); sk_sp tgt = GrVkRenderTarget::MakeWrappedRenderTarget(this, desc, info); return tgt; @@ -1181,7 +1188,7 @@ GrBackendTexture GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, return GrBackendTexture(); // invalid } - if (isRenderTarget && !fVkCaps->isConfigRenderable(config)) { + if (isRenderTarget && !fVkCaps->isConfigRenderable(config, false)) { return GrBackendTexture(); // invalid } @@ -1789,7 +1796,7 @@ inline bool can_copy_as_resolve(const GrSurface* dst, GrSurfaceOrigin dstOrigin, const GrSurface* src, GrSurfaceOrigin srcOrigin, const GrVkGpu* gpu) { // Our src must be a multisampled render target - if (!src->asRenderTarget() || 1 == src->asRenderTarget()->numColorSamples()) { + if (!src->asRenderTarget() || src->asRenderTarget()->numColorSamples() <= 1) { return false; } @@ -1887,7 +1894,7 @@ bool GrVkGpu::onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrig tempDrawInfo->fTempSurfaceDesc.fFlags = kRenderTarget_GrSurfaceFlag; tempDrawInfo->fTempSurfaceDesc.fWidth = width; tempDrawInfo->fTempSurfaceDesc.fHeight = height; - tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 1; + tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 0; tempDrawInfo->fTempSurfaceDesc.fOrigin = kTopLeft_GrSurfaceOrigin; // no CPU y-flip for TL. tempDrawInfo->fTempSurfaceFit = SkBackingFit::kApprox; diff --git a/src/gpu/vk/GrVkRenderTarget.cpp b/src/gpu/vk/GrVkRenderTarget.cpp index 2a745ed51c..c5a8628cc4 100644 --- a/src/gpu/vk/GrVkRenderTarget.cpp +++ b/src/gpu/vk/GrVkRenderTarget.cpp @@ -39,7 +39,7 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu, , fResolveAttachmentView(resolveAttachmentView) , fFramebuffer(nullptr) , fCachedSimpleRenderPass(nullptr) { - SkASSERT(desc.fSampleCnt > 1); + SkASSERT(desc.fSampleCnt); this->createFramebuffer(gpu); this->registerWithCache(budgeted); } @@ -62,7 +62,7 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu, , fResolveAttachmentView(resolveAttachmentView) , fFramebuffer(nullptr) , fCachedSimpleRenderPass(nullptr) { - SkASSERT(desc.fSampleCnt > 1); + SkASSERT(desc.fSampleCnt); this->createFramebuffer(gpu); } @@ -82,7 +82,7 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu, , fResolveAttachmentView(nullptr) , fFramebuffer(nullptr) , fCachedSimpleRenderPass(nullptr) { - SkASSERT(1 == desc.fSampleCnt); + SkASSERT(!desc.fSampleCnt); this->createFramebuffer(gpu); this->registerWithCache(budgeted); } @@ -102,7 +102,7 @@ GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu, , fResolveAttachmentView(nullptr) , fFramebuffer(nullptr) , fCachedSimpleRenderPass(nullptr) { - SkASSERT(1 == desc.fSampleCnt); + SkASSERT(!desc.fSampleCnt); this->createFramebuffer(gpu); } @@ -121,7 +121,7 @@ GrVkRenderTarget::Create(GrVkGpu* gpu, // create msaa surface if necessary GrVkImageInfo msInfo; const GrVkImageView* resolveAttachmentView = nullptr; - if (desc.fSampleCnt > 1) { + if (desc.fSampleCnt) { GrVkImage::ImageDesc msImageDesc; msImageDesc.fImageType = VK_IMAGE_TYPE_2D; msImageDesc.fFormat = pixelFormat; @@ -158,7 +158,7 @@ GrVkRenderTarget::Create(GrVkGpu* gpu, const GrVkImageView* colorAttachmentView = GrVkImageView::Create(gpu, colorImage, pixelFormat, GrVkImageView::kColor_Type, 1); if (!colorAttachmentView) { - if (desc.fSampleCnt > 1) { + if (desc.fSampleCnt) { resolveAttachmentView->unref(gpu); GrVkImage::DestroyImageInfo(gpu, &msInfo); } @@ -166,7 +166,7 @@ GrVkRenderTarget::Create(GrVkGpu* gpu, } GrVkRenderTarget* texRT; - if (desc.fSampleCnt > 1) { + if (desc.fSampleCnt) { texRT = new GrVkRenderTarget(gpu, budgeted, desc, info, msInfo, colorAttachmentView, resolveAttachmentView, ownership); } else { @@ -237,10 +237,11 @@ void GrVkRenderTarget::createFramebuffer(GrVkGpu* gpu) { void GrVkRenderTarget::getAttachmentsDescriptor( GrVkRenderPass::AttachmentsDescriptor* desc, GrVkRenderPass::AttachmentFlags* attachmentFlags) const { + int colorSamples = this->numColorSamples(); VkFormat colorFormat; GrPixelConfigToVkFormat(this->config(), &colorFormat); desc->fColor.fFormat = colorFormat; - desc->fColor.fSamples = this->numColorSamples(); + desc->fColor.fSamples = colorSamples ? colorSamples : 1; *attachmentFlags = GrVkRenderPass::kColor_AttachmentFlag; uint32_t attachmentCount = 1; @@ -248,7 +249,7 @@ void GrVkRenderTarget::getAttachmentsDescriptor( if (stencil) { const GrVkStencilAttachment* vkStencil = static_cast(stencil); desc->fStencil.fFormat = vkStencil->vkFormat(); - desc->fStencil.fSamples = vkStencil->numSamples(); + desc->fStencil.fSamples = vkStencil->numSamples() ? vkStencil->numSamples() : 1; // Currently in vulkan stencil and color attachments must all have same number of samples SkASSERT(desc->fColor.fSamples == desc->fStencil.fSamples); *attachmentFlags |= GrVkRenderPass::kStencil_AttachmentFlag; diff --git a/src/gpu/vk/GrVkRenderTarget.h b/src/gpu/vk/GrVkRenderTarget.h index bea90a759b..eb297a8a1d 100644 --- a/src/gpu/vk/GrVkRenderTarget.h +++ b/src/gpu/vk/GrVkRenderTarget.h @@ -99,11 +99,8 @@ protected: // This accounts for the texture's memory and any MSAA renderbuffer's memory. size_t onGpuMemorySize() const override { - int numColorSamples = this->numColorSamples(); - if (numColorSamples > 1) { - // Add one to account for the resolved VkImage. - numColorSamples += 1; - } + // The plus 1 is to account for the resolve texture or if not using msaa the RT itself + int numColorSamples = this->numColorSamples() + 1; return GrSurface::ComputeSize(this->config(), this->width(), this->height(), numColorSamples, GrMipMapped::kNo); } diff --git a/src/gpu/vk/GrVkStencilAttachment.cpp b/src/gpu/vk/GrVkStencilAttachment.cpp index 139c00f3b2..5348885a6b 100644 --- a/src/gpu/vk/GrVkStencilAttachment.cpp +++ b/src/gpu/vk/GrVkStencilAttachment.cpp @@ -72,7 +72,7 @@ size_t GrVkStencilAttachment::onGpuMemorySize() const { uint64_t size = this->width(); size *= this->height(); size *= fFormat.fTotalBits; - size *= this->numSamples(); + size *= SkTMax(1,this->numSamples()); return static_cast(size / 8); } diff --git a/src/gpu/vk/GrVkTextureRenderTarget.cpp b/src/gpu/vk/GrVkTextureRenderTarget.cpp index ee31f2364a..9a211e208a 100644 --- a/src/gpu/vk/GrVkTextureRenderTarget.cpp +++ b/src/gpu/vk/GrVkTextureRenderTarget.cpp @@ -106,7 +106,7 @@ sk_sp GrVkTextureRenderTarget::Make(GrVkGpu* gpu, // create msaa surface if necessary GrVkImageInfo msInfo; const GrVkImageView* resolveAttachmentView = nullptr; - if (desc.fSampleCnt > 1) { + if (desc.fSampleCnt) { GrVkImage::ImageDesc msImageDesc; msImageDesc.fImageType = VK_IMAGE_TYPE_2D; msImageDesc.fFormat = pixelFormat; @@ -145,7 +145,7 @@ sk_sp GrVkTextureRenderTarget::Make(GrVkGpu* gpu, const GrVkImageView* colorAttachmentView = GrVkImageView::Create(gpu, colorImage, pixelFormat, GrVkImageView::kColor_Type, 1); if (!colorAttachmentView) { - if (desc.fSampleCnt > 1) { + if (desc.fSampleCnt) { resolveAttachmentView->unref(gpu); GrVkImage::DestroyImageInfo(gpu, &msInfo); } @@ -154,7 +154,7 @@ sk_sp GrVkTextureRenderTarget::Make(GrVkGpu* gpu, } sk_sp texRT; - if (desc.fSampleCnt > 1) { + if (desc.fSampleCnt) { if (!isWrapped) { texRT = sk_sp(new GrVkTextureRenderTarget( gpu, budgeted, desc, @@ -232,7 +232,7 @@ GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(GrVkGpu* gpu, bool GrVkTextureRenderTarget::updateForMipmap(GrVkGpu* gpu, const GrVkImageInfo& newInfo) { VkFormat pixelFormat; GrPixelConfigToVkFormat(this->config(), &pixelFormat); - if (this->numStencilSamples() > 1) { + if (this->numStencilSamples()) { const GrVkImageView* resolveAttachmentView = GrVkImageView::Create(gpu, newInfo.fImage, @@ -262,11 +262,8 @@ bool GrVkTextureRenderTarget::updateForMipmap(GrVkGpu* gpu, const GrVkImageInfo& } size_t GrVkTextureRenderTarget::onGpuMemorySize() const { - int numColorSamples = this->numColorSamples(); - if (numColorSamples > 1) { - // Add one to account for the resolve VkImage. - ++numColorSamples; - } + // The plus 1 is to account for the resolve texture. + int numColorSamples = this->numColorSamples() + 1; return GrSurface::ComputeSize(this->config(), this->width(), this->height(), numColorSamples, // TODO: this still correct? this->texturePriv().mipMapped()); diff --git a/src/gpu/vk/GrVkUtil.cpp b/src/gpu/vk/GrVkUtil.cpp index 12db4c111e..cb0046e58c 100644 --- a/src/gpu/vk/GrVkUtil.cpp +++ b/src/gpu/vk/GrVkUtil.cpp @@ -263,8 +263,8 @@ bool GrVkFormatIsSRGB(VkFormat format, VkFormat* linearFormat) { } bool GrSampleCountToVkSampleCount(uint32_t samples, VkSampleCountFlagBits* vkSamples) { - SkASSERT(samples >= 1); switch (samples) { + case 0: // fall through case 1: *vkSamples = VK_SAMPLE_COUNT_1_BIT; return true; diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp index a136c7b49c..c00c50d000 100644 --- a/src/image/SkImage_Gpu.cpp +++ b/src/image/SkImage_Gpu.cpp @@ -438,8 +438,13 @@ static sk_sp make_from_yuv_textures_copy(GrContext* ctx, SkYUVColorSpac // Needs to be a render target in order to draw to it for the yuv->rgb conversion. sk_sp renderTargetContext(ctx->makeDeferredRenderTargetContext( - SkBackingFit::kExact, width, height, kRGBA_8888_GrPixelConfig, - std::move(imageColorSpace), 1, GrMipMapped::kNo, origin)); + SkBackingFit::kExact, + width, height, + kRGBA_8888_GrPixelConfig, + std::move(imageColorSpace), + 0, + GrMipMapped::kNo, + origin)); if (!renderTargetContext) { return nullptr; } diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp index 92d3a2fed9..ed4683542f 100644 --- a/src/image/SkImage_Lazy.cpp +++ b/src/image/SkImage_Lazy.cpp @@ -267,8 +267,9 @@ struct CacheCaps { #if SK_SUPPORT_GPU bool supportsHalfFloat() const { - return !fCaps || (fCaps->isConfigTexturable(kRGBA_half_GrPixelConfig) && - fCaps->isConfigRenderable(kRGBA_half_GrPixelConfig)); + return !fCaps || + (fCaps->isConfigTexturable(kRGBA_half_GrPixelConfig) && + fCaps->isConfigRenderable(kRGBA_half_GrPixelConfig, false)); } bool supportsSRGB() const { diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp index ef6d809957..0a684cce60 100644 --- a/src/image/SkSurface.cpp +++ b/src/image/SkSurface.cpp @@ -247,8 +247,8 @@ sk_sp SkSurface::MakeNull(int width, int height) { #if !SK_SUPPORT_GPU -sk_sp SkSurface::MakeRenderTarget(GrContext*, SkBudgeted, const SkImageInfo&, int, - GrSurfaceOrigin, const SkSurfaceProps*, bool) { +sk_sp SkSurface::MakeRenderTarget(GrContext*, SkBudgeted, const SkImageInfo&, + int, GrSurfaceOrigin, const SkSurfaceProps*, bool) { return nullptr; } diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp index 8759f3eeed..9f7ec3b7f5 100644 --- a/src/image/SkSurface_Gpu.cpp +++ b/src/image/SkSurface_Gpu.cpp @@ -256,7 +256,7 @@ sk_sp SkSurface::MakeRenderTarget(GrContext* ctx, SkBudgeted budgeted if (!SkSurface_Gpu::Valid(info)) { return nullptr; } - sampleCount = SkTMax(1, sampleCount); + GrMipMapped mipMapped = shouldCreateWithMips ? GrMipMapped::kYes : GrMipMapped::kNo; if (!ctx->caps()->mipMapSupport()) { @@ -299,7 +299,6 @@ sk_sp SkSurface::MakeFromBackendTexture(GrContext* context, const GrB if (!SkSurface_Gpu::Valid(context, tex.config(), colorSpace.get())) { return nullptr; } - sampleCnt = SkTMax(1, sampleCnt); sk_sp rtc(context->contextPriv().makeBackendTextureRenderTargetContext( tex, @@ -334,9 +333,11 @@ bool validate_backend_texture(GrContext* ctx, const GrBackendTexture& tex, GrPix return false; } - // We don't require that the client gave us an exact valid sample cnt. However, it must be - // less than the max supported sample count and 1 if MSAA is unsupported for the color type. - if (!ctx->caps()->getRenderTargetSampleCount(sampleCnt, *config)) { + if (!ctx->caps()->isConfigRenderable(*config, sampleCnt > 0)) { + return false; + } + + if (ctx->caps()->getSampleCount(sampleCnt, *config) != sampleCnt) { return false; } @@ -354,7 +355,6 @@ sk_sp SkSurface::MakeFromBackendTexture(GrContext* context, const GrB if (!context) { return nullptr; } - sampleCnt = SkTMax(1, sampleCnt); GrBackendTexture texCopy = tex; if (!validate_backend_texture(context, texCopy, &texCopy.fConfig, sampleCnt, colorType, colorSpace, true)) { @@ -409,11 +409,7 @@ bool validate_backend_render_target(GrContext* ctx, const GrBackendRenderTarget& return false; } - if (rt.sampleCnt() > 1) { - if (ctx->caps()->maxRenderTargetSampleCount(*config) <= 1) { - return false; - } - } else if (ctx->caps()->isConfigRenderable(*config)) { + if (!ctx->caps()->isConfigRenderable(*config, false)) { return false; } @@ -449,7 +445,6 @@ sk_sp SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* cont if (!SkSurface_Gpu::Valid(context, tex.config(), colorSpace.get())) { return nullptr; } - sampleCnt = SkTMax(1, sampleCnt); sk_sp rtc( context->contextPriv().makeBackendTextureAsRenderTargetRenderTargetContext( @@ -480,7 +475,6 @@ sk_sp SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* cont if (!context) { return nullptr; } - sampleCnt = SkTMax(1, sampleCnt); GrBackendTexture texCopy = tex; if (!validate_backend_texture(context, texCopy, &texCopy.fConfig, sampleCnt, colorType, colorSpace, false)) { diff --git a/src/utils/win/SkWGL.h b/src/utils/win/SkWGL.h index cd19f2eeba..c6c9479abe 100644 --- a/src/utils/win/SkWGL.h +++ b/src/utils/win/SkWGL.h @@ -83,8 +83,7 @@ public: * priority are: * * Choose formats with the smallest sample count that is >= * desiredSampleCount (or the largest sample count if all formats have - * fewer samples than desiredSampleCount.) If desiredSampleCount is 1 then - * all msaa formats are excluded from consideration. + * fewer samples than desiredSampleCount.) * * Choose formats with the fewest color samples when coverage sampling * is available. * * If the above rules leave multiple formats, choose the one that @@ -131,9 +130,8 @@ enum SkWGLContextRequest { /** * Helper to create an OpenGL context for a DC using WGL. Configs with a sample count >= to * msaaSampleCount are preferred but if none is available then a context with a lower sample count - * (including non-MSAA) will be created. If msaaSampleCount is 1 then this will fail if a non-msaa - * context cannot be created. If preferCoreProfile is true but a core profile cannot be created - * then a compatible profile context will be created. + * (including non-MSAA) will be created. If preferCoreProfile is true but a core profile cannot be + * created then a compatible profile context will be created. */ HGLRC SkCreateWGLContext(HDC dc, int msaaSampleCount, bool deepColor, SkWGLContextRequest context, HGLRC shareContext = nullptr); diff --git a/src/utils/win/SkWGL_win.cpp b/src/utils/win/SkWGL_win.cpp index 441d7a4ebb..b7c89944e0 100644 --- a/src/utils/win/SkWGL_win.cpp +++ b/src/utils/win/SkWGL_win.cpp @@ -126,7 +126,6 @@ int SkWGLExtensions::selectFormat(const int formats[], int formatCount, HDC dc, int desiredSampleCount) const { - SkASSERT(desiredSampleCount >= 1); if (formatCount <= 0) { return -1; } @@ -147,7 +146,7 @@ int SkWGLExtensions::selectFormat(const int formats[], &kQueryAttr, &numSamples); rankedFormats[i].fFormat = formats[i]; - rankedFormats[i].fSampleCnt = SkTMax(1, numSamples); + rankedFormats[i].fSampleCnt = numSamples; rankedFormats[i].fChoosePixelFormatRank = i; } SkTQSort(rankedFormats.begin(), @@ -160,10 +159,6 @@ int SkWGLExtensions::selectFormat(const int formats[], if (idx < 0) { idx = ~idx; } - // If the caller asked for non-MSAA fail if the closest format has MSAA. - if (desiredSampleCount == 1 && rankedFormats[idx].fSampleCnt != 1) { - return -1; - } return rankedFormats[idx].fFormat; } diff --git a/tests/BlendTest.cpp b/tests/BlendTest.cpp index 3ac7e3c41c..b17b9f1e45 100644 --- a/tests/BlendTest.cpp +++ b/tests/BlendTest.cpp @@ -140,7 +140,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ES2BlendWithNoTexture, reporter, ctxInfo) std::vector testCases; for (auto origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) { - for (int sampleCnt : {1, 4}) { + for (int sampleCnt : {0, 4}) { for (auto rectAndPoints : allRectsAndPoints) { for (auto clip : {SkRect::MakeXYWH(0, 0, 10, 10), SkRect::MakeXYWH(1, 1, 8, 8)}) { testCases.push_back({rectAndPoints, clip, sampleCnt, origin}); @@ -162,7 +162,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ES2BlendWithNoTexture, reporter, ctxInfo) sk_sp surface = create_gpu_surface_backend_texture_as_render_target( context, sampleCnt, kWidth, kHeight, kColorType, kConfig, origin, &backingSurface); - if (!surface && sampleCnt > 1) { + if (!surface && sampleCnt > 0) { // Some platforms don't support MSAA. continue; } diff --git a/tests/DeferredDisplayListTest.cpp b/tests/DeferredDisplayListTest.cpp index b3637cbfa3..049b97154c 100644 --- a/tests/DeferredDisplayListTest.cpp +++ b/tests/DeferredDisplayListTest.cpp @@ -31,8 +31,9 @@ public: , fOrigin(kTopLeft_GrSurfaceOrigin) , fColorType(kRGBA_8888_SkColorType) , fColorSpace(SkColorSpace::MakeSRGB()) - , fSampleCount(1) - , fSurfaceProps(0x0, kUnknown_SkPixelGeometry) {} + , fSampleCount(0) + , fSurfaceProps(0x0, kUnknown_SkPixelGeometry) { + } int sampleCount() const { return fSampleCount; } @@ -137,10 +138,10 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(SkSurfaceCharacterization, reporter, ctxInfo) { if (SurfaceParameters::kSampleCount == i) { SkSurface_Gpu* gpuSurf = static_cast(s.get()); - int supportedSampleCount = context->caps()->getRenderTargetSampleCount( + int supportedSampleCount = context->caps()->getSampleCount( params.sampleCount(), gpuSurf->getDevice()->accessRenderTargetContext()->asRenderTargetProxy()->config()); - if (1 == supportedSampleCount) { + if (0 == supportedSampleCount) { // If changing the sample count won't result in a different // surface characterization, skip this step continue; diff --git a/tests/DeviceTest.cpp b/tests/DeviceTest.cpp index 58369cc149..64b83fcb3c 100644 --- a/tests/DeviceTest.cpp +++ b/tests/DeviceTest.cpp @@ -81,7 +81,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_GPUDevice, reporter, ctxInfo) { SkImageInfo ii = SkImageInfo::MakeN32Premul(2*kWidth, 2*kHeight); sk_sp gpuDev(SkGpuDevice::Make(context, SkBudgeted::kNo, ii, - 1, kBottomLeft_GrSurfaceOrigin, nullptr, + 0, kBottomLeft_GrSurfaceOrigin, nullptr, GrMipMapped::kNo, SkGpuDevice::kClear_InitContents)); diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp index b0631d0b3c..dac78a89c0 100644 --- a/tests/EGLImageTest.cpp +++ b/tests/EGLImageTest.cpp @@ -163,7 +163,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) { { sk_sp temp = context0->contextPriv().makeBackendTextureRenderTargetContext( - backendTex, kBottomLeft_GrSurfaceOrigin, 1, nullptr); + backendTex, kBottomLeft_GrSurfaceOrigin, 0, nullptr); if (temp) { ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture as a RT."); } diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp index f625a771bf..6c2e8d2f04 100644 --- a/tests/GLProgramsTest.cpp +++ b/tests/GLProgramsTest.cpp @@ -150,10 +150,7 @@ static sk_sp random_render_target_context(GrContext* cont const GrCaps* caps) { GrSurfaceOrigin origin = random->nextBool() ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin; - int sampleCnt = - random->nextBool() ? caps->getRenderTargetSampleCount(2, kRGBA_8888_GrPixelConfig) : 1; - // Above could be 0 if msaa isn't supported. - sampleCnt = SkTMax(1, sampleCnt); + int sampleCnt = random->nextBool() ? caps->getSampleCount(4, kRGBA_8888_GrPixelConfig) : 0; sk_sp renderTargetContext(context->makeDeferredRenderTargetContext( SkBackingFit::kExact, diff --git a/tests/GpuDrawPathTest.cpp b/tests/GpuDrawPathTest.cpp index 79afa63f2d..012dc61cb8 100644 --- a/tests/GpuDrawPathTest.cpp +++ b/tests/GpuDrawPathTest.cpp @@ -78,7 +78,7 @@ static void test_drawSameRectOvals(skiatest::Reporter*, SkCanvas* canvas) { DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(GpuDrawPath, reporter, ctxInfo) { for (auto& test_func : { &test_drawPathEmpty, &test_drawSameRectOvals }) { - for (auto& sampleCount : {1, 4, 16}) { + for (auto& sampleCount : {0, 4, 16}) { SkImageInfo info = SkImageInfo::MakeN32Premul(255, 255); auto surface( SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo, info, diff --git a/tests/GpuSampleLocationsTest.cpp b/tests/GpuSampleLocationsTest.cpp index 56764cfc9b..de15e03389 100644 --- a/tests/GpuSampleLocationsTest.cpp +++ b/tests/GpuSampleLocationsTest.cpp @@ -109,36 +109,22 @@ void assert_equal(skiatest::Reporter* reporter, const SamplePattern& pattern, } } -static int pick_random_sample_count(int testPatternSize, SkRandom* rand, const GrCaps* caps) { - GrAlwaysAssert(testPatternSize > 1 && SkIsPow2(testPatternSize)); - int randSampCnt = rand->nextRangeU(1 + testPatternSize / 2, testPatternSize); - do { - int cnt = caps->getRenderTargetSampleCount(randSampCnt, kRGBA_8888_GrPixelConfig); - if (cnt) { - return cnt; - } - --randSampCnt; - } while (randSampCnt); - // This test assumes an MSAA kRGBA_8888 RTC can be created. - GrAlwaysAssert(false); - return 0; -} - void test_sampleLocations(skiatest::Reporter* reporter, TestSampleLocationsInterface* testInterface, GrContext* ctx) { SkRandom rand; sk_sp bottomUps[numTestPatterns]; sk_sp topDowns[numTestPatterns]; for (int i = 0; i < numTestPatterns; ++i) { - int patternSize = (int)kTestPatterns[i].size(); - int randNumSamples = pick_random_sample_count(patternSize, &rand, ctx->caps()); + int numSamples = (int)kTestPatterns[i].size(); + GrAlwaysAssert(numSamples > 1 && SkIsPow2(numSamples)); bottomUps[i] = ctx->makeDeferredRenderTargetContext( - SkBackingFit::kExact, 100, 100, kRGBA_8888_GrPixelConfig, nullptr, randNumSamples, - GrMipMapped::kNo, kBottomLeft_GrSurfaceOrigin); - randNumSamples = pick_random_sample_count(patternSize, &rand, ctx->caps()); + SkBackingFit::kExact, 100, 100, kRGBA_8888_GrPixelConfig, nullptr, + rand.nextRangeU(1 + numSamples / 2, numSamples), GrMipMapped::kNo, + kBottomLeft_GrSurfaceOrigin); topDowns[i] = ctx->makeDeferredRenderTargetContext( - SkBackingFit::kExact, 100, 100, kRGBA_8888_GrPixelConfig, nullptr, randNumSamples, - GrMipMapped::kNo, kTopLeft_GrSurfaceOrigin); + SkBackingFit::kExact, 100, 100, kRGBA_8888_GrPixelConfig, nullptr, + rand.nextRangeU(1 + numSamples / 2, numSamples), GrMipMapped::kNo, + kTopLeft_GrSurfaceOrigin); } // Ensure all sample locations get queried and/or cached properly. @@ -203,7 +189,7 @@ DEF_GPUTEST(GLSampleLocations, reporter, /* options */) { sk_sp ctx(GrContext::MakeGL(testInterface)); // This test relies on at least 2 samples. - int supportedSample = ctx->caps()->getRenderTargetSampleCount(2, kRGBA_8888_GrPixelConfig); + int supportedSample = ctx->caps()->getSampleCount(2, kRGBA_8888_GrPixelConfig); if (supportedSample < 2) { return; } diff --git a/tests/GrCCPRTest.cpp b/tests/GrCCPRTest.cpp index cba94b4bf5..9f770d6b50 100644 --- a/tests/GrCCPRTest.cpp +++ b/tests/GrCCPRTest.cpp @@ -119,8 +119,7 @@ public: GrMockOptions mockOptions; mockOptions.fInstanceAttribSupport = true; mockOptions.fMapBufferFlags = GrCaps::kCanMap_MapFlag; - mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fRenderability = - GrMockOptions::ConfigOptions::Renderability::kNonMSAA; + mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fRenderable[0] = true; mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fTexturable = true; mockOptions.fGeometryShaderSupport = true; mockOptions.fIntegerSupport = true; diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp index 32ac0c71e6..3e246ccd93 100644 --- a/tests/GrSurfaceTest.cpp +++ b/tests/GrSurfaceTest.cpp @@ -33,7 +33,7 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) { desc.fWidth = 256; desc.fHeight = 256; desc.fConfig = kRGBA_8888_GrPixelConfig; - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp texRT1 = resourceProvider->createTexture(desc, SkBudgeted::kNo); REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asRenderTarget()); @@ -55,8 +55,8 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) { GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture( nullptr, 256, 256, kRGBA_8888_GrPixelConfig, false, GrMipMapped::kNo); - sk_sp texRT2 = - resourceProvider->wrapRenderableBackendTexture(backendTex, 1, kBorrow_GrWrapOwnership); + sk_sp texRT2 = resourceProvider->wrapRenderableBackendTexture( + backendTex, 0, kBorrow_GrWrapOwnership); REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asRenderTarget()); REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asTexture()); @@ -120,7 +120,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(GrSurfaceRenderability, reporter, ctxInfo) { desc.fFlags = kNone_GrSurfaceFlags; desc.fOrigin = origin; desc.fConfig = config; - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp tex = resourceProvider->createTexture(desc, SkBudgeted::kNo); bool ict = caps->isConfigTexturable(desc.fConfig); @@ -143,17 +143,17 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(GrSurfaceRenderability, reporter, ctxInfo) { desc.fFlags = kRenderTarget_GrSurfaceFlag; tex = resourceProvider->createTexture(desc, SkBudgeted::kNo); - bool isRenderable = caps->isConfigRenderable(config); - REPORTER_ASSERT(reporter, SkToBool(tex) == isRenderable, - "config:%d, tex:%d, isRenderable:%d", config, SkToBool(tex), - isRenderable); + bool icr = caps->isConfigRenderable(config, false); + REPORTER_ASSERT(reporter, SkToBool(tex) == icr, + "config:%d, tex:%d, isConfigRenderable(false):%d", config, + SkToBool(tex), icr); - desc.fSampleCnt = 2; + desc.fSampleCnt = 4; tex = resourceProvider->createTexture(desc, SkBudgeted::kNo); - isRenderable = SkToBool(caps->getRenderTargetSampleCount(2, config)); - REPORTER_ASSERT(reporter, SkToBool(tex) == isRenderable, - "config:%d, tex:%d, isRenderable:%d", config, SkToBool(tex), - isRenderable); + icr = caps->isConfigRenderable(config, true); + REPORTER_ASSERT(reporter, SkToBool(tex) == icr, + "config:%d, tex:%d, isConfigRenderable(true):%d", config, SkToBool(tex), + icr); } } } @@ -178,7 +178,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(InitialTextureClear, reporter, context_info) } desc.fFlags = kPerformInitialClear_GrSurfaceFlag; for (bool rt : {false, true}) { - if (rt && !context->caps()->isConfigRenderable(desc.fConfig)) { + if (rt && !context->caps()->isConfigRenderable(desc.fConfig, false)) { continue; } desc.fFlags |= rt ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags; diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp index 9a89000748..a1472d42dd 100644 --- a/tests/ImageTest.cpp +++ b/tests/ImageTest.cpp @@ -38,7 +38,6 @@ #include "GrResourceCache.h" #include "GrTest.h" #include "GrTexture.h" -#include "SkGr.h" #endif using namespace sk_gpu_test; @@ -487,29 +486,6 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkImage_drawAbandonedGpuImage, reporter, c surface->getCanvas()->drawImage(image, 0, 0); } -DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrContext_colorTypeSupportedAsImage, reporter, ctxInfo) { - for (int ct = 0; ct < kLastEnum_SkColorType; ++ct) { - static constexpr int kSize = 10; - SkColorType colorType = static_cast(ct); - bool can = ctxInfo.grContext()->colorTypeSupportedAsImage(colorType); - auto* gpu = ctxInfo.grContext()->contextPriv().getGpu(); - GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture( - nullptr, kSize, kSize, colorType, false, GrMipMapped::kNo); - auto img = - SkImage::MakeFromTexture(ctxInfo.grContext(), backendTex, kTopLeft_GrSurfaceOrigin, - colorType, kOpaque_SkAlphaType, nullptr); - REPORTER_ASSERT(reporter, can == SkToBool(img), - "%d, colorTypeSupportedAsImage:%d, actual:%d, ct:%d", can, SkToBool(img), - colorType); - - img.reset(); - ctxInfo.grContext()->flush(); - if (backendTex.isValid()) { - gpu->deleteTestingOnlyBackendTexture(&backendTex); - } - } -} - #endif class EmptyGenerator : public SkImageGenerator { diff --git a/tests/LazyProxyTest.cpp b/tests/LazyProxyTest.cpp index 5c0532701d..f1bffa527b 100644 --- a/tests/LazyProxyTest.cpp +++ b/tests/LazyProxyTest.cpp @@ -179,8 +179,7 @@ private: DEF_GPUTEST(LazyProxyTest, reporter, /* options */) { GrMockOptions mockOptions; - mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fRenderability = - GrMockOptions::ConfigOptions::Renderability::kNonMSAA; + mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fRenderable[0] = true; mockOptions.fConfigOptions[kAlpha_half_GrPixelConfig].fTexturable = true; sk_sp ctx = GrContext::MakeMock(&mockOptions, GrContextOptions()); GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider(); diff --git a/tests/PathRendererCacheTests.cpp b/tests/PathRendererCacheTests.cpp index 19197b0d5f..15b1faa4ba 100644 --- a/tests/PathRendererCacheTests.cpp +++ b/tests/PathRendererCacheTests.cpp @@ -80,8 +80,8 @@ static void test_path(skiatest::Reporter* reporter, GrResourceCache* cache = ctx->contextPriv().getResourceCache(); sk_sp rtc(ctx->makeDeferredRenderTargetContext( - SkBackingFit::kApprox, 800, 800, kRGBA_8888_GrPixelConfig, nullptr, 1, GrMipMapped::kNo, - kTopLeft_GrSurfaceOrigin)); + SkBackingFit::kApprox, 800, 800, kRGBA_8888_GrPixelConfig, nullptr, 0, + GrMipMapped::kNo, kTopLeft_GrSurfaceOrigin)); if (!rtc) { return; } diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp index dff230c9bb..0636ed4ce4 100644 --- a/tests/ProxyTest.cpp +++ b/tests/ProxyTest.cpp @@ -118,7 +118,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) { kRGBA_8888_GrPixelConfig }) { for (auto fit : { SkBackingFit::kExact, SkBackingFit::kApprox }) { for (auto budgeted : { SkBudgeted::kYes, SkBudgeted::kNo }) { - for (auto numSamples : {1, 4, 16, 128}) { + for (auto numSamples : { 0, 4, 16, 128 }) { GrSurfaceDesc desc; desc.fFlags = kRenderTarget_GrSurfaceFlag; desc.fOrigin = origin; @@ -149,8 +149,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) { check_surface(reporter, proxy.get(), origin, widthHeight, widthHeight, config, budgeted); - int supportedSamples = - caps.getRenderTargetSampleCount(numSamples, config); + int supportedSamples = caps.getSampleCount(numSamples, config); check_rendertarget(reporter, caps, resourceProvider, proxy->asRenderTargetProxy(), supportedSamples, @@ -205,8 +204,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) { for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) { for (auto config : { kAlpha_8_GrPixelConfig, kRGBA_8888_GrPixelConfig }) { for (auto budgeted : { SkBudgeted::kYes, SkBudgeted::kNo }) { - for (auto numSamples : {1, 4}) { - int supportedNumSamples = caps.getRenderTargetSampleCount(numSamples, config); + for (auto numSamples: { 0, 4}) { + int supportedNumSamples = caps.getSampleCount(numSamples, config); + + bool renderable = caps.isConfigRenderable(config, numSamples > 0); GrSurfaceDesc desc; desc.fOrigin = origin; @@ -216,7 +217,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) { desc.fSampleCnt = supportedNumSamples; // External on-screen render target. - if (supportedNumSamples && kOpenGL_GrBackend == ctxInfo.backend()) { + if (renderable && kOpenGL_GrBackend == ctxInfo.backend()) { GrGLFramebufferInfo fboInfo; fboInfo.fFBOID = 0; GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples, 8, @@ -231,7 +232,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) { supportedNumSamples, SkBackingFit::kExact, 0, true); } - if (supportedNumSamples) { + if (renderable) { // Internal offscreen render target. desc.fFlags = kRenderTarget_GrSurfaceFlag; @@ -250,7 +251,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) { } else { // Internal offscreen texture SkASSERT(kNone_GrSurfaceFlags == desc.fFlags ); - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp sProxy = proxyProvider->createInstantiatedProxy( desc, SkBackingFit::kExact, budgeted); @@ -286,7 +287,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ZeroSizedProxyTest, reporter, ctxInfo) { desc.fWidth = width; desc.fHeight = height; desc.fConfig = kRGBA_8888_GrPixelConfig; - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp proxy = provider->createProxy(desc, fit, SkBudgeted::kNo); REPORTER_ASSERT(reporter, !proxy); diff --git a/tests/ResourceAllocatorTest.cpp b/tests/ResourceAllocatorTest.cpp index 173696be2b..7dcb0ee942 100644 --- a/tests/ResourceAllocatorTest.cpp +++ b/tests/ResourceAllocatorTest.cpp @@ -148,8 +148,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorTest, reporter, ctxInfo) { std::move(p1), std::move(p2), test.fExpectation); } - int k2 = ctxInfo.grContext()->caps()->getRenderTargetSampleCount(2, kRGBA); - int k4 = ctxInfo.grContext()->caps()->getRenderTargetSampleCount(4, kRGBA); + int k2 = ctxInfo.grContext()->caps()->getSampleCount(2, kRGBA); + int k4 = ctxInfo.grContext()->caps()->getSampleCount(4, kRGBA); //-------------------------------------------------------------------------------------------- TestCase gNonOverlappingTests[] = { diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp index 3bd6c4b4e3..34ed4f7328 100644 --- a/tests/ResourceCacheTest.cpp +++ b/tests/ResourceCacheTest.cpp @@ -129,20 +129,21 @@ DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angl GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider(); - sk_sp smallRT0 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kYes); + sk_sp smallRT0 = create_RT_with_SB(resourceProvider, 4, 0, SkBudgeted::kYes); REPORTER_ASSERT(reporter, smallRT0); { // Two budgeted RTs with the same desc should share a stencil buffer. - sk_sp smallRT1 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kYes); - REPORTER_ASSERT(reporter, smallRT1); + sk_sp smallRT1 = create_RT_with_SB(resourceProvider, 4, 0, + SkBudgeted::kYes); + REPORTER_ASSERT(reporter, smallRT1); - REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) == get_SB(smallRT1.get())); + REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) == get_SB(smallRT1.get())); } { // An unbudgeted RT with the same desc should also share. - sk_sp smallRT2 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kNo); + sk_sp smallRT2 = create_RT_with_SB(resourceProvider, 4, 0, SkBudgeted::kNo); REPORTER_ASSERT(reporter, smallRT2); REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) == get_SB(smallRT2.get())); @@ -150,14 +151,14 @@ DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angl { // An RT with a much larger size should not share. - sk_sp bigRT = create_RT_with_SB(resourceProvider, 400, 1, SkBudgeted::kNo); + sk_sp bigRT = create_RT_with_SB(resourceProvider, 400, 0, SkBudgeted::kNo); REPORTER_ASSERT(reporter, bigRT); REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) != get_SB(bigRT.get())); } - int smallSampleCount = context->caps()->getRenderTargetSampleCount(2, kRGBA_8888_GrPixelConfig); - if (smallSampleCount > 1) { + int smallSampleCount = context->caps()->getSampleCount(4, kRGBA_8888_GrPixelConfig); + if (smallSampleCount > 0) { // An RT with a different sample count should not share. sk_sp smallMSAART0 = create_RT_with_SB(resourceProvider, 4, smallSampleCount, SkBudgeted::kNo); @@ -182,11 +183,10 @@ DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angl REPORTER_ASSERT(reporter, get_SB(smallMSAART0.get()) == get_SB(smallMSAART1.get())); } - // But one with a larger sample count should not. (Also check that the two requests didn't - // rounded up to the same actual sample count or else they could share.). - int bigSampleCount = - context->caps()->getRenderTargetSampleCount(5, kRGBA_8888_GrPixelConfig); - if (bigSampleCount > 0 && bigSampleCount != smallSampleCount) { + // But not one with a larger sample count should not. (Also check that the request for 4 + // samples didn't get rounded up to >= 8 or else they could share.). + int bigSampleCount = context->caps()->getSampleCount(8, kRGBA_8888_GrPixelConfig); + if (bigSampleCount != smallSampleCount) { sk_sp smallMSAART2 = create_RT_with_SB(resourceProvider, 4, bigSampleCount, SkBudgeted::kNo); @@ -1707,12 +1707,11 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) { { sk_sp tex; - tex = make_normal_texture(resourceProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 1); + tex = make_normal_texture(resourceProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0); size_t size = tex->gpuMemorySize(); REPORTER_ASSERT(reporter, kSize*kSize*4 == size); - size_t sampleCount = - (size_t)context->caps()->getRenderTargetSampleCount(4, kRGBA_8888_GrPixelConfig); + size_t sampleCount = (size_t)context->caps()->getSampleCount(4, kRGBA_8888_GrPixelConfig); if (sampleCount >= 4) { tex = make_normal_texture(resourceProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, sampleCount); @@ -1723,7 +1722,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) { kSize*kSize*4*(sampleCount+1) == size); // explicit resolve buffer } - tex = make_normal_texture(resourceProvider, kNone_GrSurfaceFlags, kSize, kSize, 1); + tex = make_normal_texture(resourceProvider, kNone_GrSurfaceFlags, kSize, kSize, 0); size = tex->gpuMemorySize(); REPORTER_ASSERT(reporter, kSize*kSize*4 == size); } @@ -1733,12 +1732,11 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) { if (context->caps()->mipMapSupport()) { sk_sp proxy; - proxy = make_mipmap_proxy(proxyProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 1); + proxy = make_mipmap_proxy(proxyProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0); size_t size = proxy->gpuMemorySize(); REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size); - size_t sampleCount = - (size_t)context->caps()->getRenderTargetSampleCount(4, kRGBA_8888_GrPixelConfig); + size_t sampleCount = (size_t)context->caps()->getSampleCount(4, kRGBA_8888_GrPixelConfig); if (sampleCount >= 4) { proxy = make_mipmap_proxy(proxyProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, sampleCount); @@ -1749,7 +1747,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) { kSize*kSize*4*(sampleCount+1)+(kSize*kSize*4)/3 == size); // explicit resolve buffer } - proxy = make_mipmap_proxy(proxyProvider, kNone_GrSurfaceFlags, kSize, kSize, 1); + proxy = make_mipmap_proxy(proxyProvider, kNone_GrSurfaceFlags, kSize, kSize, 0); size = proxy->gpuMemorySize(); REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size); } diff --git a/tests/SRGBReadWritePixelsTest.cpp b/tests/SRGBReadWritePixelsTest.cpp index bb7b77c5b9..7013971b62 100644 --- a/tests/SRGBReadWritePixelsTest.cpp +++ b/tests/SRGBReadWritePixelsTest.cpp @@ -172,7 +172,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SRGBReadWritePixels, reporter, ctxInfo) { desc.fWidth = kW; desc.fHeight = kH; desc.fConfig = kSRGBA_8888_GrPixelConfig; - if (context->caps()->isConfigRenderable(desc.fConfig) && + if (context->caps()->isConfigRenderable(desc.fConfig, false) && context->caps()->isConfigTexturable(desc.fConfig)) { sk_sp sContext = context->contextPriv().makeDeferredSurfaceContext( diff --git a/tests/SkpSkGrTest.cpp b/tests/SkpSkGrTest.cpp index 898faf08a7..24d1b9cc3a 100644 --- a/tests/SkpSkGrTest.cpp +++ b/tests/SkpSkGrTest.cpp @@ -442,7 +442,7 @@ void TestResult::testOne() { desc.fFlags = kRenderTarget_GrTextureFlagBit; desc.fWidth = dim.fX; desc.fHeight = dim.fY; - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp texture(context->createUncachedTexture(desc, nullptr, 0)); if (!texture) { SkDebugf("unable to allocate texture for %s (w=%d h=%d)\n", fFilename, diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp index de1cd9a984..471953b373 100644 --- a/tests/SurfaceTest.cpp +++ b/tests/SurfaceTest.cpp @@ -19,17 +19,13 @@ #include "Test.h" #if SK_SUPPORT_GPU -#include #include "GrContext.h" #include "GrContextPriv.h" -#include "GrGpu.h" -#include "GrGpuResourcePriv.h" #include "GrRenderTargetContext.h" +#include "GrGpu.h" #include "GrResourceProvider.h" #include "GrTest.h" -#include "SkGpuDevice.h" -#include "SkImage_Gpu.h" -#include "SkSurface_Gpu.h" +#include #endif #include @@ -92,121 +88,6 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceEmpty_Gpu, reporter, ctxInfo) { } #endif -#if SK_SUPPORT_GPU -DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrContext_colorTypeSupportedAsSurface, reporter, ctxInfo) { - for (int ct = 0; ct < kLastEnum_SkColorType; ++ct) { - static constexpr int kSize = 10; - - SkColorType colorType = static_cast(ct); - auto info = SkImageInfo::Make(kSize, kSize, colorType, kOpaque_SkAlphaType, nullptr); - bool can = ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType); - auto surf = SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kYes, info, 1, - nullptr); - REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d", - colorType, can, SkToBool(surf)); - - auto* gpu = ctxInfo.grContext()->contextPriv().getGpu(); - GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture( - nullptr, kSize, kSize, colorType, true, GrMipMapped::kNo); - surf = SkSurface::MakeFromBackendTexture(ctxInfo.grContext(), backendTex, - kTopLeft_GrSurfaceOrigin, 0, colorType, nullptr, - nullptr); - REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d", - colorType, can, SkToBool(surf)); - - surf = SkSurface::MakeFromBackendTextureAsRenderTarget(ctxInfo.grContext(), backendTex, - kTopLeft_GrSurfaceOrigin, 1, - colorType, nullptr, nullptr); - REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d", - colorType, can, SkToBool(surf)); - - surf.reset(); - ctxInfo.grContext()->flush(); - if (backendTex.isValid()) { - gpu->deleteTestingOnlyBackendTexture(&backendTex); - } - - static constexpr int kSampleCnt = 2; - - can = ctxInfo.grContext()->maxSurfaceSampleCountForColorType(colorType) >= kSampleCnt; - surf = SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kYes, info, kSampleCnt, - nullptr); - REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d", - colorType, can, SkToBool(surf)); - - backendTex = gpu->createTestingOnlyBackendTexture(nullptr, kSize, kSize, colorType, true, - GrMipMapped::kNo); - surf = SkSurface::MakeFromBackendTexture(ctxInfo.grContext(), backendTex, - kTopLeft_GrSurfaceOrigin, kSampleCnt, colorType, - nullptr, nullptr); - REPORTER_ASSERT(reporter, can == SkToBool(surf), - "colorTypeSupportedAsSurface:%d, surf:%d, ct:%d", can, SkToBool(surf), - colorType); - // Ensure that the sample count stored on the resulting SkSurface is a valid value. - if (surf) { - auto* rtc = ((SkSurface_Gpu*)(surf.get()))->getDevice()->accessRenderTargetContext(); - int storedCnt = rtc->numStencilSamples(); - int allowedCnt = ctxInfo.grContext()->caps()->getSampleCount( - storedCnt, rtc->asSurfaceProxy()->config()); - REPORTER_ASSERT(reporter, storedCnt == allowedCnt, - "Should store an allowed sample count (%d vs %d)", allowedCnt, - storedCnt); - } - - surf = SkSurface::MakeFromBackendTextureAsRenderTarget(ctxInfo.grContext(), backendTex, - kTopLeft_GrSurfaceOrigin, kSampleCnt, - colorType, nullptr, nullptr); - REPORTER_ASSERT(reporter, can == SkToBool(surf), - "colorTypeSupportedAsSurface:%d, surf:%d, ct:%d", can, SkToBool(surf), - colorType); - if (surf) { - auto* rtc = ((SkSurface_Gpu*)(surf.get()))->getDevice()->accessRenderTargetContext(); - int storedCnt = rtc->numStencilSamples(); - int allowedCnt = ctxInfo.grContext()->caps()->getSampleCount( - storedCnt, rtc->asSurfaceProxy()->config()); - REPORTER_ASSERT(reporter, storedCnt == allowedCnt, - "Should store an allowed sample count (%d vs %d)", allowedCnt, - storedCnt); - } - - surf.reset(); - ctxInfo.grContext()->flush(); - if (backendTex.isValid()) { - gpu->deleteTestingOnlyBackendTexture(&backendTex); - } - } -} - -DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrContext_maxSurfaceSamplesForColorType, reporter, ctxInfo) { - for (int ct = 0; ct < kLastEnum_SkColorType; ++ct) { - static constexpr int kSize = 10; - - SkColorType colorType = static_cast(ct); - int max = ctxInfo.grContext()->maxSurfaceSampleCountForColorType(colorType); - if (!max) { - continue; - } - auto* gpu = ctxInfo.grContext()->contextPriv().getGpu(); - GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture( - nullptr, kSize, kSize, colorType, true, GrMipMapped::kNo); - - auto info = SkImageInfo::Make(kSize, kSize, colorType, kOpaque_SkAlphaType, nullptr); - auto surf = SkSurface::MakeFromBackendTexture(ctxInfo.grContext(), backendTex, - kTopLeft_GrSurfaceOrigin, max, - colorType, nullptr, nullptr); - REPORTER_ASSERT(reporter, surf); - if (!surf) { - continue; - } - int sampleCnt = ((SkSurface_Gpu*)(surf.get())) - ->getDevice() - ->accessRenderTargetContext() - ->numStencilSamples(); - REPORTER_ASSERT(reporter, sampleCnt == max, "Exected: %d, actual: %d", max, sampleCnt); - } -} -#endif - static void test_canvas_peek(skiatest::Reporter* reporter, sk_sp& surface, const SkImageInfo& requestInfo, @@ -556,6 +437,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacepeekTexture_Gpu, reporter, ctxInfo) { #endif #if SK_SUPPORT_GPU +#include "GrGpuResourcePriv.h" +#include "SkGpuDevice.h" +#include "SkImage_Gpu.h" +#include "SkSurface_Gpu.h" static SkBudgeted is_budgeted(const sk_sp& surf) { SkSurface_Gpu* gsurf = (SkSurface_Gpu*)surf.get(); @@ -819,7 +704,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, ctxInfo) { for (auto& surfaceFunc : {&create_gpu_surface_backend_texture, &create_gpu_surface_backend_texture_as_render_target}) { GrBackendTexture backendTex; - auto surface = surfaceFunc(context, 1, kOrigColor, &backendTex); + auto surface = surfaceFunc(context, 0, kOrigColor, &backendTex); test_surface_clear(reporter, surface, grSurfaceGetter, kOrigColor); surface.reset(); gpu->deleteTestingOnlyBackendTexture(&backendTex); @@ -882,7 +767,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacePartialDraw_Gpu, reporter, ctxInfo) { // preserved in pixels that aren't rendered to via the surface. // This works only for non-multisampled case. GrBackendTexture backendTex; - auto surface = surfaceFunc(ctxInfo.grContext(), 1, kOrigColor, &backendTex); + auto surface = surfaceFunc(ctxInfo.grContext(), 0, kOrigColor, &backendTex); if (surface) { test_surface_draw_partially(reporter, surface, kOrigColor); surface.reset(); @@ -906,11 +791,11 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceAttachStencil_Gpu, reporter, ctxInf for (auto& surfaceFunc : {&create_gpu_surface_backend_texture, &create_gpu_surface_backend_texture_as_render_target}) { - for (int sampleCnt : {1, 4, 8}) { + for (int sampleCnt : {0, 4, 8}) { GrBackendTexture backendTex; auto surface = surfaceFunc(ctxInfo.grContext(), sampleCnt, kOrigColor, &backendTex); - if (!surface && sampleCnt > 1) { + if (!surface && sampleCnt > 0) { // Certain platforms don't support MSAA, skip these. continue; } @@ -995,7 +880,7 @@ DEF_TEST(SurfaceCreationWithColorSpace, reporter) { DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCreationWithColorSpace_Gpu, reporter, ctxInfo) { GrContext* context = ctxInfo.grContext(); - bool f16Support = context->caps()->isConfigRenderable(kRGBA_half_GrPixelConfig); + bool f16Support = context->caps()->isConfigRenderable(kRGBA_half_GrPixelConfig, false); auto surfaceMaker = [context](const SkImageInfo& info) { return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info); }; diff --git a/tests/TessellatingPathRendererTests.cpp b/tests/TessellatingPathRendererTests.cpp index e24bf7a516..1eb055f53a 100644 --- a/tests/TessellatingPathRendererTests.cpp +++ b/tests/TessellatingPathRendererTests.cpp @@ -486,8 +486,13 @@ static void test_path(GrContext* ctx, DEF_GPUTEST_FOR_ALL_CONTEXTS(TessellatingPathRendererTests, reporter, ctxInfo) { GrContext* ctx = ctxInfo.grContext(); sk_sp rtc(ctx->makeDeferredRenderTargetContext( - SkBackingFit::kApprox, 800, 800, kRGBA_8888_GrPixelConfig, nullptr, 1, GrMipMapped::kNo, - kTopLeft_GrSurfaceOrigin)); + SkBackingFit::kApprox, + 800, 800, + kRGBA_8888_GrPixelConfig, + nullptr, + 0, + GrMipMapped::kNo, + kTopLeft_GrSurfaceOrigin)); if (!rtc) { return; } diff --git a/tests/TestConfigParsing.cpp b/tests/TestConfigParsing.cpp index 7e90730bfe..aa95ff7687 100644 --- a/tests/TestConfigParsing.cpp +++ b/tests/TestConfigParsing.cpp @@ -45,7 +45,7 @@ DEF_TEST(ParseConfigs_Gpu, reporter) { == GrContextFactory::kGL_ContextType); REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getUseNVPR() == false); REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getUseDIText() == false); - REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getSamples() == 1); + REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getSamples() == 0); REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getColorType() == kRGBA_8888_SkColorType); REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getColorSpace() == nullptr); #endif @@ -240,7 +240,7 @@ DEF_TEST(ParseConfigs_ExtendedGpuConfigsCorrect, reporter) { GrContextFactory::kGL_ContextType); REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getUseNVPR()); REPORTER_ASSERT(reporter, !configs[0]->asConfigGpu()->getUseDIText()); - REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getSamples() == 1); + REPORTER_ASSERT(reporter, configs[0]->asConfigGpu()->getSamples() == 0); REPORTER_ASSERT(reporter, configs[1]->asConfigGpu()->getContextType() == GrContextFactory::kANGLE_D3D9_ES2_ContextType); REPORTER_ASSERT(reporter, configs[1]->asConfigGpu()); @@ -254,18 +254,18 @@ DEF_TEST(ParseConfigs_ExtendedGpuConfigsCorrect, reporter) { GrContextFactory::kGLES_ContextType); REPORTER_ASSERT(reporter, !configs[5]->asConfigGpu()->getUseNVPR()); REPORTER_ASSERT(reporter, !configs[5]->asConfigGpu()->getUseDIText()); - REPORTER_ASSERT(reporter, configs[5]->asConfigGpu()->getSamples() == 1); + REPORTER_ASSERT(reporter, configs[5]->asConfigGpu()->getSamples() == 0); REPORTER_ASSERT(reporter, configs[6]->asConfigGpu()->getContextType() == GrContextFactory::kGL_ContextType); REPORTER_ASSERT(reporter, !configs[6]->asConfigGpu()->getUseNVPR()); REPORTER_ASSERT(reporter, !configs[6]->asConfigGpu()->getUseDIText()); - REPORTER_ASSERT(reporter, configs[6]->asConfigGpu()->getSamples() == 1); + REPORTER_ASSERT(reporter, configs[6]->asConfigGpu()->getSamples() == 0); #ifdef SK_VULKAN REPORTER_ASSERT(reporter, configs[7]->asConfigGpu()->getContextType() == GrContextFactory::kVulkan_ContextType); REPORTER_ASSERT(reporter, !configs[7]->asConfigGpu()->getUseNVPR()); REPORTER_ASSERT(reporter, !configs[7]->asConfigGpu()->getUseDIText()); - REPORTER_ASSERT(reporter, configs[7]->asConfigGpu()->getSamples() == 1); + REPORTER_ASSERT(reporter, configs[7]->asConfigGpu()->getSamples() == 0); #endif #ifdef SK_METAL REPORTER_ASSERT(reporter, configs[8]->asConfigGpu()->getContextType() == diff --git a/tests/TextureProxyTest.cpp b/tests/TextureProxyTest.cpp index 059113033a..d422b076ad 100644 --- a/tests/TextureProxyTest.cpp +++ b/tests/TextureProxyTest.cpp @@ -34,7 +34,7 @@ static GrSurfaceDesc make_desc(GrSurfaceFlags flags) { desc.fWidth = 64; desc.fHeight = 64; desc.fConfig = kRGBA_8888_GrPixelConfig; - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; return desc; } diff --git a/tests/TransferPixelsTest.cpp b/tests/TransferPixelsTest.cpp index 8f71528da6..ce8d1edc4f 100755 --- a/tests/TransferPixelsTest.cpp +++ b/tests/TransferPixelsTest.cpp @@ -104,7 +104,7 @@ void basic_transfer_test(skiatest::Reporter* reporter, GrContext* context, GrPix desc.fWidth = kTextureWidth; desc.fHeight = kTextureHeight; desc.fConfig = config; - desc.fSampleCnt = 1; + desc.fSampleCnt = 0; sk_sp tex = resourceProvider->createTexture(desc, SkBudgeted::kNo); ////////////////////////// diff --git a/tests/VkClearTests.cpp b/tests/VkClearTests.cpp index 0dcb446ee5..c797ef2c33 100644 --- a/tests/VkClearTests.cpp +++ b/tests/VkClearTests.cpp @@ -58,7 +58,7 @@ void basic_clear_test(skiatest::Reporter* reporter, GrContext* context, GrPixelC surfDesc.fWidth = 5; surfDesc.fHeight = 5; surfDesc.fConfig = config; - surfDesc.fSampleCnt = 1; + surfDesc.fSampleCnt = 0; GrTexture* tex = gpu->createTexture(surfDesc, SkBudgeted::kNo); SkASSERT(tex); SkASSERT(tex->asRenderTarget()); @@ -114,7 +114,7 @@ void sub_clear_test(skiatest::Reporter* reporter, GrContext* context, GrPixelCon surfDesc.fWidth = width; surfDesc.fHeight = height; surfDesc.fConfig = config; - surfDesc.fSampleCnt = 1; + surfDesc.fSampleCnt = 0; GrTexture* tex = gpu->createTexture(surfDesc, SkBudgeted::kNo); SkASSERT(tex); SkASSERT(tex->asRenderTarget()); diff --git a/tests/VkUploadPixelsTests.cpp b/tests/VkUploadPixelsTests.cpp index f35480a6ce..3b3fecae7f 100644 --- a/tests/VkUploadPixelsTests.cpp +++ b/tests/VkUploadPixelsTests.cpp @@ -69,7 +69,7 @@ void basic_texture_test(skiatest::Reporter* reporter, GrContext* context, GrPixe surfDesc.fWidth = kWidth; surfDesc.fHeight = kHeight; surfDesc.fConfig = config; - surfDesc.fSampleCnt = 1; + surfDesc.fSampleCnt = 0; SkColorType ct; SkAssertResult(GrPixelConfigToColorType(config, &ct)); diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp index 9723d5763b..6cfbba65b6 100644 --- a/tests/VkWrapTests.cpp +++ b/tests/VkWrapTests.cpp @@ -83,7 +83,7 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) { GrMipMapped::kNo); const GrVkImageInfo* imageInfo = origBackendTex.getVkImageInfo(); - GrBackendRenderTarget origBackendRT(kW, kH, 1, 0, *imageInfo); + GrBackendRenderTarget origBackendRT(kW, kH, 0, 0, *imageInfo); sk_sp rt = gpu->wrapBackendRenderTarget(origBackendRT); REPORTER_ASSERT(reporter, rt); @@ -92,7 +92,7 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) { { GrVkImageInfo backendCopy = *imageInfo; backendCopy.fImage = VK_NULL_HANDLE; - GrBackendRenderTarget backendRT(kW, kH, 1, 0, backendCopy); + GrBackendRenderTarget backendRT(kW, kH, 0, 0, backendCopy); rt = gpu->wrapBackendRenderTarget(backendRT); REPORTER_ASSERT(reporter, !rt); } @@ -102,7 +102,7 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) { GrVkImageInfo backendCopy = *imageInfo; backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 }; // can wrap null alloc - GrBackendRenderTarget backendRT(kW, kH, 1, 0, backendCopy); + GrBackendRenderTarget backendRT(kW, kH, 0, 0, backendCopy); rt = gpu->wrapBackendRenderTarget(backendRT); REPORTER_ASSERT(reporter, rt); } @@ -120,8 +120,8 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) { GrMipMapped::kNo); const GrVkImageInfo* imageInfo = origBackendTex.getVkImageInfo(); - sk_sp tex = - gpu->wrapRenderableBackendTexture(origBackendTex, 1, kBorrow_GrWrapOwnership); + sk_sp tex = gpu->wrapRenderableBackendTexture(origBackendTex, 0, + kBorrow_GrWrapOwnership); REPORTER_ASSERT(reporter, tex); // image is null @@ -129,9 +129,9 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) { GrVkImageInfo backendCopy = *imageInfo; backendCopy.fImage = VK_NULL_HANDLE; GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy); - tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kBorrow_GrWrapOwnership); + tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kBorrow_GrWrapOwnership); REPORTER_ASSERT(reporter, !tex); - tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kAdopt_GrWrapOwnership); + tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kAdopt_GrWrapOwnership); REPORTER_ASSERT(reporter, !tex); } @@ -140,9 +140,9 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) { GrVkImageInfo backendCopy = *imageInfo; backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 }; GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy); - tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kBorrow_GrWrapOwnership); + tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kBorrow_GrWrapOwnership); REPORTER_ASSERT(reporter, !tex); - tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kAdopt_GrWrapOwnership); + tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kAdopt_GrWrapOwnership); REPORTER_ASSERT(reporter, !tex); } @@ -150,7 +150,7 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) { { GrVkImageInfo backendCopy = *imageInfo; GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy); - tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kAdopt_GrWrapOwnership); + tex = gpu->wrapRenderableBackendTexture(backendTex, 0, kAdopt_GrWrapOwnership); REPORTER_ASSERT(reporter, tex); } diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp index 2a2ee397ef..a16752f229 100644 --- a/tests/WritePixelsTest.cpp +++ b/tests/WritePixelsTest.cpp @@ -412,11 +412,11 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixels_Gpu, reporter, ctxInfo) { const SkImageInfo ii = SkImageInfo::MakeN32Premul(DEV_W, DEV_H); for (auto& origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) { - for (int sampleCnt : {1, 4}) { + for (int sampleCnt : {0, 4}) { sk_sp surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo, ii, sampleCnt, origin, nullptr)); - if (!surface && sampleCnt > 1) { + if (!surface && sampleCnt > 0) { // Some platforms don't support MSAA continue; } @@ -430,7 +430,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixelsNonTexture_Gpu, reporter, ctxInfo) GrGpu* gpu = context->contextPriv().getGpu(); for (auto& origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) { - for (int sampleCnt : {1, 4}) { + for (int sampleCnt : {0, 4}) { GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture( nullptr, DEV_W, DEV_H, kSkia8888_GrPixelConfig, true, GrMipMapped::kNo); SkColorType colorType; diff --git a/tools/fiddle/fiddle_main.cpp b/tools/fiddle/fiddle_main.cpp index 684bc2ae48..4ba84f38ca 100644 --- a/tools/fiddle/fiddle_main.cpp +++ b/tools/fiddle/fiddle_main.cpp @@ -133,7 +133,7 @@ static bool setup_backend_objects(GrContext* context, backingDesc.fHeight = bm.height(); // This config must match the SkColorType used in draw.cpp in the SkImage and Surface factories backingDesc.fConfig = kRGBA_8888_GrPixelConfig; - backingDesc.fSampleCnt = 1; + backingDesc.fSampleCnt = 0; if (!bm.empty()) { SkPixmap originalPixmap; diff --git a/tools/flags/SkCommonFlagsConfig.cpp b/tools/flags/SkCommonFlagsConfig.cpp index 9d1c2ddadd..d38d70a1dc 100644 --- a/tools/flags/SkCommonFlagsConfig.cpp +++ b/tools/flags/SkCommonFlagsConfig.cpp @@ -391,7 +391,7 @@ SkCommandLineConfigGpu* parse_command_line_config_gpu(const SkString& tag, bool seenUseDIText =false; bool useDIText = false; bool seenSamples = false; - int samples = 1; + int samples = 0; bool seenColor = false; SkColorType colorType = kRGBA_8888_SkColorType; SkAlphaType alphaType = kPremul_SkAlphaType; diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp index 06d9b831a5..829ddcbe89 100644 --- a/tools/gpu/GrTest.cpp +++ b/tools/gpu/GrTest.cpp @@ -182,13 +182,6 @@ void GrGpu::Stats::dumpKeyValuePairs(SkTArray* keys, SkTArray* #endif -GrBackendTexture GrGpu::createTestingOnlyBackendTexture(void* pixels, int w, int h, - SkColorType colorType, bool isRenderTarget, - GrMipMapped mipMapped) { - GrPixelConfig config = SkImageInfo2GrPixelConfig(colorType, nullptr, *this->caps()); - return this->createTestingOnlyBackendTexture(pixels, w, h, config, isRenderTarget, mipMapped); -} - #if GR_CACHE_STATS void GrResourceCache::getStats(Stats* stats) const { stats->reset(); diff --git a/tools/sk_app/DisplayParams.h b/tools/sk_app/DisplayParams.h index 203e8bdeca..959735e8ff 100644 --- a/tools/sk_app/DisplayParams.h +++ b/tools/sk_app/DisplayParams.h @@ -13,7 +13,10 @@ namespace sk_app { struct DisplayParams { - DisplayParams() : fColorType(kN32_SkColorType), fColorSpace(nullptr), fMSAASampleCount(1) {} + DisplayParams() + : fColorType(kN32_SkColorType) + , fColorSpace(nullptr) + , fMSAASampleCount(0) {} SkColorType fColorType; sk_sp fColorSpace; diff --git a/tools/sk_app/GLWindowContext.cpp b/tools/sk_app/GLWindowContext.cpp index 9d042cf19e..9ef5141fee 100644 --- a/tools/sk_app/GLWindowContext.cpp +++ b/tools/sk_app/GLWindowContext.cpp @@ -24,7 +24,9 @@ GLWindowContext::GLWindowContext(const DisplayParams& params) : WindowContext(params) , fBackendContext(nullptr) , fSurface(nullptr) { - fDisplayParams.fMSAASampleCount = GrNextPow2(fDisplayParams.fMSAASampleCount); + fDisplayParams.fMSAASampleCount = fDisplayParams.fMSAASampleCount ? + GrNextPow2(fDisplayParams.fMSAASampleCount) : + 0; } void GLWindowContext::initializeContext() { @@ -32,7 +34,7 @@ void GLWindowContext::initializeContext() { fBackendContext = this->onInitializeContext(); fContext = GrContext::MakeGL(fBackendContext, fDisplayParams.fGrContextOptions); - if (!fContext && fDisplayParams.fMSAASampleCount > 1) { + if (!fContext && fDisplayParams.fMSAASampleCount) { fDisplayParams.fMSAASampleCount /= 2; this->initializeContext(); return; diff --git a/tools/sk_app/Window.cpp b/tools/sk_app/Window.cpp index 1694beaac8..29e4864ba1 100644 --- a/tools/sk_app/Window.cpp +++ b/tools/sk_app/Window.cpp @@ -117,7 +117,7 @@ void Window::setRequestedDisplayParams(const DisplayParams& params, bool /* allo int Window::sampleCount() const { if (!fWindowContext) { - return 0; + return -1; } return fWindowContext->sampleCount(); } diff --git a/tools/sk_app/WindowContext.h b/tools/sk_app/WindowContext.h index 71c21ac089..5e7d76d4ba 100644 --- a/tools/sk_app/WindowContext.h +++ b/tools/sk_app/WindowContext.h @@ -21,11 +21,11 @@ namespace sk_app { class WindowContext { public: WindowContext(const DisplayParams& params) - : fContext(nullptr) - , fDisplayParams(params) - , fSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType) - , fSampleCount(1) - , fStencilBits(0) {} + : fContext(nullptr) + , fDisplayParams(params) + , fSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType) + , fSampleCount(0) + , fStencilBits(0) {} virtual ~WindowContext() {} diff --git a/tools/sk_app/android/GLWindowContext_android.cpp b/tools/sk_app/android/GLWindowContext_android.cpp index 5111114115..acdb587230 100644 --- a/tools/sk_app/android/GLWindowContext_android.cpp +++ b/tools/sk_app/android/GLWindowContext_android.cpp @@ -70,8 +70,6 @@ sk_sp GLWindowContext_android::onInitializeContext() { SkAssertResult(eglBindAPI(EGL_OPENGL_ES_API)); EGLint numConfigs = 0; - EGLint eglSampleCnt = fDisplayParams.fMSAASampleCount > 1 ? fDisplayParams.fMSAASampleCount > 1 - : 0; const EGLint configAttribs[] = { EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, @@ -80,8 +78,8 @@ sk_sp GLWindowContext_android::onInitializeContext() { EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_STENCIL_SIZE, 8, - EGL_SAMPLE_BUFFERS, eglSampleCnt ? 1 : 0, - EGL_SAMPLES, eglSampleCnt, + EGL_SAMPLE_BUFFERS, fDisplayParams.fMSAASampleCount ? 1 : 0, + EGL_SAMPLES, fDisplayParams.fMSAASampleCount, EGL_NONE }; @@ -133,7 +131,6 @@ sk_sp GLWindowContext_android::onInitializeContext() { eglGetConfigAttrib(fDisplay, surfaceConfig, EGL_STENCIL_SIZE, &fStencilBits); eglGetConfigAttrib(fDisplay, surfaceConfig, EGL_SAMPLES, &fSampleCount); - fSampleCount = SkTMax(fSampleCount, 1); return GrGLMakeNativeInterface(); } diff --git a/tools/sk_app/ios/GLWindowContext_ios.cpp b/tools/sk_app/ios/GLWindowContext_ios.cpp index 2a57b33e30..f4c0d6b3c0 100644 --- a/tools/sk_app/ios/GLWindowContext_ios.cpp +++ b/tools/sk_app/ios/GLWindowContext_ios.cpp @@ -67,7 +67,6 @@ sk_sp GLWindowContext_ios::onInitializeContext() { SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &fStencilBits); SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &fSampleCount); - fSampleCount = SkTMax(fSampleCount, 1); SDL_GL_GetDrawableSize(fWindow, &fWidth, &fHeight); glViewport(0, 0, fWidth, fHeight); diff --git a/tools/sk_app/ios/RasterWindowContext_ios.cpp b/tools/sk_app/ios/RasterWindowContext_ios.cpp index 53d7c1a372..cae5774c28 100644 --- a/tools/sk_app/ios/RasterWindowContext_ios.cpp +++ b/tools/sk_app/ios/RasterWindowContext_ios.cpp @@ -79,7 +79,6 @@ sk_sp RasterWindowContext_ios::onInitializeContext() { SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &fStencilBits); SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &fSampleCount); - fSampleCount = SkTMax(fSampleCount, 1); SDL_GL_GetDrawableSize(fWindow, &fWidth, &fHeight); glViewport(0, 0, fWidth, fHeight); diff --git a/tools/sk_app/ios/Window_ios.cpp b/tools/sk_app/ios/Window_ios.cpp index ac0ad0caa0..c1bdeae5fc 100644 --- a/tools/sk_app/ios/Window_ios.cpp +++ b/tools/sk_app/ios/Window_ios.cpp @@ -49,7 +49,7 @@ bool Window_ios::initWindow() { SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); - if (fRequestedDisplayParams.fMSAASampleCount > 1) { + if (fRequestedDisplayParams.fMSAASampleCount > 0) { SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fRequestedDisplayParams.fMSAASampleCount); } else { diff --git a/tools/sk_app/ios/Window_ios.h b/tools/sk_app/ios/Window_ios.h index a0fed90697..667fa74e82 100644 --- a/tools/sk_app/ios/Window_ios.h +++ b/tools/sk_app/ios/Window_ios.h @@ -18,7 +18,11 @@ namespace sk_app { class Window_ios : public Window { public: - Window_ios() : INHERITED(), fWindow(nullptr), fWindowID(0), fMSAASampleCount(1) {} + Window_ios() + : INHERITED() + , fWindow(nullptr) + , fWindowID(0) + , fMSAASampleCount(0) {} ~Window_ios() override { this->closeWindow(); } bool initWindow(); diff --git a/tools/sk_app/mac/GLWindowContext_mac.cpp b/tools/sk_app/mac/GLWindowContext_mac.cpp index 67fb853fee..005fc07df4 100644 --- a/tools/sk_app/mac/GLWindowContext_mac.cpp +++ b/tools/sk_app/mac/GLWindowContext_mac.cpp @@ -67,7 +67,6 @@ sk_sp GLWindowContext_mac::onInitializeContext() { SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &fStencilBits); SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &fSampleCount); - fSampleCount = SkTMax(fSampleCount, 1); SDL_GetWindowSize(fWindow, &fWidth, &fHeight); glViewport(0, 0, fWidth, fHeight); diff --git a/tools/sk_app/mac/RasterWindowContext_mac.cpp b/tools/sk_app/mac/RasterWindowContext_mac.cpp index fbe9837911..67022af7fe 100644 --- a/tools/sk_app/mac/RasterWindowContext_mac.cpp +++ b/tools/sk_app/mac/RasterWindowContext_mac.cpp @@ -79,7 +79,6 @@ sk_sp RasterWindowContext_mac::onInitializeContext() { SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &fStencilBits); SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &fSampleCount); - fSampleCount = SkTMax(fSampleCount, 1); SDL_GetWindowSize(fWindow, &fWidth, &fHeight); glViewport(0, 0, fWidth, fHeight); diff --git a/tools/sk_app/mac/Window_mac.cpp b/tools/sk_app/mac/Window_mac.cpp index f2620518a2..8de5b10450 100644 --- a/tools/sk_app/mac/Window_mac.cpp +++ b/tools/sk_app/mac/Window_mac.cpp @@ -49,7 +49,7 @@ bool Window_mac::initWindow() { SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); - if (fRequestedDisplayParams.fMSAASampleCount > 1) { + if (fRequestedDisplayParams.fMSAASampleCount > 0) { SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fRequestedDisplayParams.fMSAASampleCount); } else { diff --git a/tools/sk_app/mac/Window_mac.h b/tools/sk_app/mac/Window_mac.h index 35cba095fa..aa5c8df696 100644 --- a/tools/sk_app/mac/Window_mac.h +++ b/tools/sk_app/mac/Window_mac.h @@ -18,7 +18,11 @@ namespace sk_app { class Window_mac : public Window { public: - Window_mac() : INHERITED(), fWindow(nullptr), fWindowID(0), fMSAASampleCount(1) {} + Window_mac() + : INHERITED() + , fWindow(nullptr) + , fWindowID(0) + , fMSAASampleCount(0) {} ~Window_mac() override { this->closeWindow(); } bool initWindow(); diff --git a/tools/sk_app/unix/GLWindowContext_unix.cpp b/tools/sk_app/unix/GLWindowContext_unix.cpp index 3a3a4b16d4..25ec95cdd6 100644 --- a/tools/sk_app/unix/GLWindowContext_unix.cpp +++ b/tools/sk_app/unix/GLWindowContext_unix.cpp @@ -99,7 +99,6 @@ sk_sp GLWindowContext_xlib::onInitializeContext() { glXGetConfig(fDisplay, fVisualInfo, GLX_STENCIL_SIZE, &fStencilBits); glXGetConfig(fDisplay, fVisualInfo, GLX_SAMPLES_ARB, &fSampleCount); - fSampleCount = SkTMax(fSampleCount, 1); XWindow root; int x, y; diff --git a/tools/sk_app/unix/Window_unix.cpp b/tools/sk_app/unix/Window_unix.cpp index 745b4dd3fb..f5ca5ee073 100644 --- a/tools/sk_app/unix/Window_unix.cpp +++ b/tools/sk_app/unix/Window_unix.cpp @@ -72,7 +72,7 @@ bool Window_unix::initWindow(Display* display) { None }; SkASSERT(nullptr == fVisualInfo); - if (fRequestedDisplayParams.fMSAASampleCount > 1) { + if (fRequestedDisplayParams.fMSAASampleCount > 0) { static const GLint kChooseFBConifgAttCnt = SK_ARRAY_COUNT(kChooseFBConfigAtt); GLint msaaChooseFBConfigAtt[kChooseFBConifgAttCnt + 4]; memcpy(msaaChooseFBConfigAtt, kChooseFBConfigAtt, sizeof(kChooseFBConfigAtt)); diff --git a/tools/sk_app/unix/Window_unix.h b/tools/sk_app/unix/Window_unix.h index 62a2795098..b59f502eb9 100644 --- a/tools/sk_app/unix/Window_unix.h +++ b/tools/sk_app/unix/Window_unix.h @@ -20,14 +20,13 @@ namespace sk_app { class Window_unix : public Window { public: - Window_unix() - : Window() - , fDisplay(nullptr) - , fWindow(0) - , fGC(nullptr) - , fFBConfig(nullptr) - , fVisualInfo(nullptr) - , fMSAASampleCount(1) {} + Window_unix() : Window() + , fDisplay(nullptr) + , fWindow(0) + , fGC(nullptr) + , fFBConfig(nullptr) + , fVisualInfo(nullptr) + , fMSAASampleCount(0) {} ~Window_unix() override { this->closeWindow(); } bool initWindow(Display* display); diff --git a/tools/sk_app/win/ANGLEWindowContext_win.cpp b/tools/sk_app/win/ANGLEWindowContext_win.cpp index 452b462ba9..649528d6cd 100644 --- a/tools/sk_app/win/ANGLEWindowContext_win.cpp +++ b/tools/sk_app/win/ANGLEWindowContext_win.cpp @@ -76,8 +76,7 @@ sk_sp ANGLEGLWindowContext_win::onInitializeContext() { } EGLint numConfigs; fSampleCount = this->getDisplayParams().fMSAASampleCount; - const int sampleBuffers = fSampleCount > 1 ? 1 : 0; - const int eglSampleCnt = fSampleCount > 1 ? fSampleCount : 0; + const int sampleBuffers = fSampleCount > 0 ? 1 : 0; const EGLint configAttribs[] = {EGL_RENDERABLE_TYPE, // We currently only support ES3. EGL_OPENGL_ES3_BIT, @@ -92,7 +91,7 @@ sk_sp ANGLEGLWindowContext_win::onInitializeContext() { EGL_SAMPLE_BUFFERS, sampleBuffers, EGL_SAMPLES, - eglSampleCnt, + fSampleCount, EGL_NONE}; EGLConfig surfaceConfig; diff --git a/tools/sk_app/win/GLWindowContext_win.cpp b/tools/sk_app/win/GLWindowContext_win.cpp index 1c583cb1ed..7e43d2b544 100644 --- a/tools/sk_app/win/GLWindowContext_win.cpp +++ b/tools/sk_app/win/GLWindowContext_win.cpp @@ -96,9 +96,8 @@ sk_sp GLWindowContext_win::onInitializeContext() { 1, &kSampleCountAttr, &fSampleCount); - fSampleCount = SkTMax(fSampleCount, 1); } else { - fSampleCount = 1; + fSampleCount = 0; } RECT rect; diff --git a/tools/skpbench/skpbench.cpp b/tools/skpbench/skpbench.cpp index 6b89bc27ff..fcab2d3af8 100644 --- a/tools/skpbench/skpbench.cpp +++ b/tools/skpbench/skpbench.cpp @@ -292,8 +292,7 @@ int main(int argc, char** argv) { GrPixelConfig grPixConfig = SkImageInfo2GrPixelConfig(config->getColorType(), config->getColorSpace(), *ctx->caps()); - int supportedSampleCount = - ctx->caps()->getRenderTargetSampleCount(config->getSamples(), grPixConfig); + int supportedSampleCount = ctx->caps()->getSampleCount(config->getSamples(), grPixConfig); if (supportedSampleCount != config->getSamples()) { exitf(ExitErr::kUnavailable, "sample count %i not supported by platform", config->getSamples()); diff --git a/tools/viewer/Viewer.cpp b/tools/viewer/Viewer.cpp index 35b0e146f9..198f9baab6 100644 --- a/tools/viewer/Viewer.cpp +++ b/tools/viewer/Viewer.cpp @@ -78,7 +78,7 @@ static DEFINE_string(jsons, "jsons", "Directory to read (Bodymovin) jsons from." static DEFINE_string2(backend, b, "sw", "Backend to use. Allowed values are " BACKENDS_STR "."); -static DEFINE_int32(msaa, 1, "Number of subpixel samples. 0 for no HW antialiasing."); +static DEFINE_int32(msaa, 0, "Number of subpixel samples. 0 for no HW antialiasing."); DECLARE_int32(threads) @@ -501,7 +501,7 @@ void Viewer::updateTitle() { if (!fWindow) { return; } - if (fWindow->sampleCount() < 1) { + if (fWindow->sampleCount() < 0) { return; // Surface hasn't been created yet. } @@ -561,8 +561,7 @@ void Viewer::updateTitle() { title.append(" ["); title.append(kBackendTypeStrings[fBackendType]); - int msaa = fWindow->sampleCount(); - if (msaa > 1) { + if (int msaa = fWindow->sampleCount()) { title.appendf(" MSAA: %i", msaa); } title.append("]"); @@ -995,7 +994,7 @@ void Viewer::drawImGui() { if (ctx) { int sampleCount = fWindow->sampleCount(); ImGui::Text("MSAA: "); ImGui::SameLine(); - ImGui::RadioButton("1", &sampleCount, 1); ImGui::SameLine(); + ImGui::RadioButton("0", &sampleCount, 0); ImGui::SameLine(); ImGui::RadioButton("4", &sampleCount, 4); ImGui::SameLine(); ImGui::RadioButton("8", &sampleCount, 8); ImGui::SameLine(); ImGui::RadioButton("16", &sampleCount, 16); @@ -1019,7 +1018,7 @@ void Viewer::drawImGui() { if (!ctx) { ImGui::RadioButton("Software", true); - } else if (fWindow->sampleCount() > 1) { + } else if (fWindow->sampleCount()) { prButton(GpuPathRenderers::kDefault); prButton(GpuPathRenderers::kAll); if (ctx->caps()->shaderCaps()->pathRenderingSupport()) { @@ -1199,7 +1198,7 @@ void Viewer::updateUIState() { if (!fWindow) { return; } - if (fWindow->sampleCount() < 1) { + if (fWindow->sampleCount() < 0) { return; // Surface hasn't been created yet. } @@ -1245,7 +1244,7 @@ void Viewer::updateUIState() { const GrContext* ctx = fWindow->getGrContext(); if (!ctx) { prState[kOptions].append("Software"); - } else if (fWindow->sampleCount() > 1) { + } else if (fWindow->sampleCount()) { prState[kOptions].append(gPathRendererNames[GpuPathRenderers::kDefault]); prState[kOptions].append(gPathRendererNames[GpuPathRenderers::kAll]); if (ctx->caps()->shaderCaps()->pathRenderingSupport()) { -- cgit v1.2.3