SurfaceParameters Class Reference

Public Member Functions
	SurfaceParameters (GrRecordingContext *rContext)
int	sampleCount () const
void	setColorType (SkColorType ct)
SkColorType	colorType () const
void	setColorSpace (sk_sp< SkColorSpace > cs)
void	disableTextureability ()
void	setShouldCreateMipMaps (skgpu::Mipmapped shouldCreateMipMaps)
void	setVkRTInputAttachmentSupport (bool inputSupport)
void	setForVulkanSecondaryCommandBuffer (bool forVkSCB)
bool	modify (int i)
GrSurfaceCharacterization	createCharacterization (GrDirectContext *dContext) const
sk_sp< GrDeferredDisplayList >	createDDL (GrDirectContext *dContext) const
sk_sp< SkSurface >	make (GrDirectContext *dContext) const

Static Public Attributes
static const int	kNumParams = 12
static const int	kFBO0Count = 9
static const int	kVkSCBCount = 11

Detailed Description

Definition at line 119 of file DeferredDisplayListTest.cpp.

Constructor & Destructor Documentation

SurfaceParameters()

SurfaceParameters::SurfaceParameters ( GrRecordingContext *  rContext )

inline

Definition at line 125 of file DeferredDisplayListTest.cpp.

            : fBackend(rContext->backend())
            , fCanBeProtected(false)
            , fWidth(64)
            , fHeight(64)
            , fOrigin(kTopLeft_GrSurfaceOrigin)
            , fColorType(kRGBA_8888_SkColorType)
            , fColorSpace(SkColorSpace::MakeSRGB())
            , fSampleCount(1)
            , fSurfaceProps(0x0, kUnknown_SkPixelGeometry)
            , fShouldCreateMipMaps(skgpu::Mipmapped::kYes)
            , fUsesGLFBO0(false)
            , fIsTextureable(true)
            , fIsProtected(skgpu::Protected::kNo)
            , fVkRTSupportsInputAttachment(false)
            , fForVulkanSecondaryCommandBuffer(false) {
        const GrCaps* caps = rContext->priv().caps();
 
        if (rContext->backend() == GrBackendApi::kOpenGL ||
            rContext->backend() == GrBackendApi::kVulkan) {
            fCanBeProtected = caps->supportsProtectedContent();
            if (fCanBeProtected) {
                fIsProtected = skgpu::Protected::kYes;
            }
        }
 
        if (!caps->mipmapSupport()) {
            fShouldCreateMipMaps = skgpu::Mipmapped::kNo;
        }
    }

Member Function Documentation

colorType()

SkColorType SurfaceParameters::colorType ( ) const

inline

Definition at line 159 of file DeferredDisplayListTest.cpp.

{ return fColorType; }

createCharacterization()

GrSurfaceCharacterization SurfaceParameters::createCharacterization ( GrDirectContext *  dContext ) const

inline

Definition at line 244 of file DeferredDisplayListTest.cpp.

                                                                                      {
        size_t maxResourceBytes = dContext->getResourceCacheLimit();
 
        if (!dContext->colorTypeSupportedAsSurface(fColorType)) {
            return GrSurfaceCharacterization();
        }
 
        // Note that Ganesh doesn't make use of the SkImageInfo's alphaType
        SkImageInfo ii = SkImageInfo::Make(fWidth, fHeight, fColorType,
                                           kPremul_SkAlphaType, fColorSpace);
 
        GrBackendFormat backendFormat = dContext->defaultBackendFormat(fColorType,
                                                                       GrRenderable::kYes);
        if (!backendFormat.isValid()) {
            return GrSurfaceCharacterization();
        }
 
        GrSurfaceCharacterization c = dContext->threadSafeProxy()->createCharacterization(
                                                maxResourceBytes, ii, backendFormat, fSampleCount,
                                                fOrigin, fSurfaceProps, fShouldCreateMipMaps,
                                                fUsesGLFBO0, fIsTextureable, fIsProtected,
                                                fVkRTSupportsInputAttachment,
                                                fForVulkanSecondaryCommandBuffer);
        return c;
    }

createDDL()

sk_sp< GrDeferredDisplayList > SurfaceParameters::createDDL ( GrDirectContext *  dContext ) const

inline

Definition at line 271 of file DeferredDisplayListTest.cpp.

                                                                            {
        GrSurfaceCharacterization c = this->createCharacterization(dContext);
        SkAssertResult(c.isValid());
 
        GrDeferredDisplayListRecorder r(c);
        SkCanvas* canvas = r.getCanvas();
        if (!canvas) {
            return nullptr;
        }
 
        canvas->drawRect(SkRect::MakeXYWH(10, 10, 10, 10), SkPaint());
        return r.detach();
    }

disableTextureability()

void SurfaceParameters::disableTextureability ( )

inline

Definition at line 161 of file DeferredDisplayListTest.cpp.

                                 {
        fIsTextureable = false;
        fShouldCreateMipMaps = skgpu::Mipmapped::kNo;
    }

make()

sk_sp< SkSurface > SurfaceParameters::make ( GrDirectContext *  dContext ) const

inline

Definition at line 286 of file DeferredDisplayListTest.cpp.

                                                           {
        const GrSurfaceCharacterization c = this->createCharacterization(dContext);
 
#ifdef SK_GL
        if (fUsesGLFBO0) {
            if (GrBackendApi::kOpenGL != dContext->backend()) {
                return nullptr;
            }
 
            GrGLFramebufferInfo fboInfo;
            fboInfo.fFBOID = 0;
            fboInfo.fFormat = GR_GL_RGBA8;
            fboInfo.fProtected = fIsProtected;
            static constexpr int kStencilBits = 8;
            GrBackendRenderTarget backendRT =
                    GrBackendRenderTargets::MakeGL(fWidth, fHeight, 1, kStencilBits, fboInfo);
 
            if (!backendRT.isValid()) {
                return nullptr;
            }
 
            sk_sp<SkSurface> result = SkSurfaces::WrapBackendRenderTarget(
                    dContext, backendRT, fOrigin, fColorType, fColorSpace, &fSurfaceProps);
            SkASSERT(result->isCompatible(c));
            return result;
        }
#endif
 
        // We can't make SkSurfaces for vulkan secondary command buffers.
        if (fForVulkanSecondaryCommandBuffer) {
            return nullptr;
        }
 
        sk_sp<SkSurface> surface;
        if (fIsTextureable) {
            surface = sk_gpu_test::MakeBackendTextureSurface(dContext,
                                                             {fWidth, fHeight},
                                                             fOrigin,
                                                             fSampleCount,
                                                             fColorType,
                                                             fColorSpace,
                                                             fShouldCreateMipMaps,
                                                             fIsProtected,
                                                             &fSurfaceProps);
        } else {
            // Create a surface w/ the current parameters but make it non-textureable
            SkASSERT(fShouldCreateMipMaps == skgpu::Mipmapped::kNo);
            surface = sk_gpu_test::MakeBackendRenderTargetSurface(dContext,
                                                                  {fWidth, fHeight},
                                                                  fOrigin,
                                                                  fSampleCount,
                                                                  fColorType,
                                                                  fColorSpace,
                                                                  fIsProtected,
                                                                  &fSurfaceProps);
        }
 
        if (!surface) {
            SkASSERT(!c.isValid());
            return nullptr;
        }
 
        GrBackendTexture texture = SkSurfaces::GetBackendTexture(
                surface.get(), SkSurfaces::BackendHandleAccess::kFlushRead);
        if (texture.isValid()) {
            SkASSERT(is_compatible(c, texture));
        }
 
        SkASSERT(c.isValid());
        SkASSERT(surface->isCompatible(c));
        return surface;
    }

modify()

bool SurfaceParameters::modify ( int  i )

inline

Definition at line 177 of file DeferredDisplayListTest.cpp.

                       {
        bool changed = false;
        auto set = [&changed](auto& var, auto value) {
            if (var != value) {
                changed = true;
            }
            var = value;
        };
        switch (i) {
        case 0:
            set(fWidth, 63);
            break;
        case 1:
            set(fHeight, 63);
            break;
        case 2:
            set(fOrigin, kBottomLeft_GrSurfaceOrigin);
            break;
        case 3:
            set(fColorType, kRGBA_F16_SkColorType);
            break;
        case 4:
            // This just needs to be a colorSpace different from that returned by MakeSRGB().
            // In this case we just change the gamut.
            set(fColorSpace, SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
                                                   SkNamedGamut::kAdobeRGB));
            break;
        case 5:
            set(fSampleCount, 4);
            break;
        case 6:
            set(fSurfaceProps, SkSurfaceProps(0x0, kRGB_H_SkPixelGeometry));
            break;
        case 7:
            set(fSurfaceProps, SkSurfaceProps(SkSurfaceProps::kUseDeviceIndependentFonts_Flag,
                                              kUnknown_SkPixelGeometry));
            break;
        case 8:
            set(fShouldCreateMipMaps, skgpu::Mipmapped::kNo);
            break;
        case 9:
            if (GrBackendApi::kOpenGL == fBackend) {
                set(fUsesGLFBO0, true);
                set(fShouldCreateMipMaps,
                    skgpu::Mipmapped::kNo);  // needs to changed in tandem w/ textureability
                set(fIsTextureable, false);
            }
            break;
        case 10:
            set(fShouldCreateMipMaps,
                skgpu::Mipmapped::kNo);  // needs to changed in tandem w/ textureability
            set(fIsTextureable, false);
            break;
        case 11:
            if (GrBackendApi::kVulkan == fBackend) {
                set(fForVulkanSecondaryCommandBuffer, true);
                set(fUsesGLFBO0, false);
                set(fShouldCreateMipMaps,
                    skgpu::Mipmapped::kNo);  // needs to changed in tandem w/ textureability
                set(fIsTextureable, false);
                set(fVkRTSupportsInputAttachment, false);
            }
            break;
        }
        return changed;
    }

sampleCount()

int SurfaceParameters::sampleCount ( ) const

inline

Definition at line 156 of file DeferredDisplayListTest.cpp.

{ return fSampleCount; }

setColorSpace()

void SurfaceParameters::setColorSpace ( sk_sp< SkColorSpace >  cs )

inline

Definition at line 160 of file DeferredDisplayListTest.cpp.

{ fColorSpace = std::move(cs); }

setColorType()

void SurfaceParameters::setColorType ( SkColorType  ct )

inline

Definition at line 158 of file DeferredDisplayListTest.cpp.

{ fColorType = ct; }

setForVulkanSecondaryCommandBuffer()

void SurfaceParameters::setForVulkanSecondaryCommandBuffer ( bool  forVkSCB )

inline

Definition at line 171 of file DeferredDisplayListTest.cpp.

                                                           {
        fForVulkanSecondaryCommandBuffer = forVkSCB;
    }

setShouldCreateMipMaps()

void SurfaceParameters::setShouldCreateMipMaps ( skgpu::Mipmapped  shouldCreateMipMaps )

inline

Definition at line 165 of file DeferredDisplayListTest.cpp.

                                                                    {
        fShouldCreateMipMaps = shouldCreateMipMaps;
    }

setVkRTInputAttachmentSupport()

void SurfaceParameters::setVkRTInputAttachmentSupport ( bool  inputSupport )

inline

Definition at line 168 of file DeferredDisplayListTest.cpp.

                                                          {
        fVkRTSupportsInputAttachment = inputSupport;
    }

Member Data Documentation

kFBO0Count

const int SurfaceParameters::kFBO0Count = 9

static

Definition at line 122 of file DeferredDisplayListTest.cpp.

kNumParams

const int SurfaceParameters::kNumParams = 12

static

Definition at line 121 of file DeferredDisplayListTest.cpp.

kVkSCBCount

const int SurfaceParameters::kVkSCBCount = 11

static

Definition at line 123 of file DeferredDisplayListTest.cpp.

---

The documentation for this class was generated from the following file:

• third_party/skia/tests/DeferredDisplayListTest.cpp