1 /* 2 * Copyright 2023 Google LLC 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef GrSurfaceCharacterization_DEFINED 9 #define GrSurfaceCharacterization_DEFINED 10 11 #include "include/core/SkColorSpace.h" // IWYU pragma: keep 12 #include "include/core/SkColorType.h" 13 #include "include/core/SkImageInfo.h" 14 #include "include/core/SkRefCnt.h" 15 #include "include/core/SkSize.h" 16 #include "include/core/SkSurfaceProps.h" 17 #include "include/core/SkTypes.h" 18 #include "include/gpu/GpuTypes.h" 19 #include "include/gpu/ganesh/GrBackendSurface.h" 20 #include "include/gpu/ganesh/GrContextThreadSafeProxy.h" 21 #include "include/gpu/ganesh/GrTypes.h" 22 #include "include/private/base/SkDebug.h" 23 24 #include <cstddef> 25 #include <utility> 26 27 /** \class GrSurfaceCharacterization 28 A surface characterization contains all the information Ganesh requires to makes its internal 29 rendering decisions. When passed into a GrDeferredDisplayListRecorder it will copy the 30 data and pass it on to the GrDeferredDisplayList if/when it is created. Note that both of 31 those objects (the Recorder and the DisplayList) will take a ref on the 32 GrContextThreadSafeProxy and SkColorSpace objects. 33 */ 34 class SK_API GrSurfaceCharacterization { 35 public: 36 enum class Textureable : bool { kNo = false, kYes = true }; 37 enum class UsesGLFBO0 : bool { kNo = false, kYes = true }; 38 // This flag indicates that the backing VkImage for this Vulkan surface will have the 39 // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set. This bit allows skia to handle advanced blends 40 // more optimally in a shader by being able to directly read the dst values. 41 enum class VkRTSupportsInputAttachment : bool { kNo = false, kYes = true }; 42 // This flag indicates if the surface is wrapping a raw Vulkan secondary command buffer. 43 enum class VulkanSecondaryCBCompatible : bool { kNo = false, kYes = true }; 44 GrSurfaceCharacterization()45 GrSurfaceCharacterization() 46 : fCacheMaxResourceBytes(0) 47 , fOrigin(kBottomLeft_GrSurfaceOrigin) 48 , fSampleCnt(0) 49 , fIsTextureable(Textureable::kYes) 50 , fIsMipmapped(skgpu::Mipmapped::kYes) 51 , fUsesGLFBO0(UsesGLFBO0::kNo) 52 , fVulkanSecondaryCBCompatible(VulkanSecondaryCBCompatible::kNo) 53 , fIsProtected(skgpu::Protected::kNo) 54 , fSurfaceProps() {} 55 56 GrSurfaceCharacterization(GrSurfaceCharacterization&&) = default; 57 GrSurfaceCharacterization& operator=(GrSurfaceCharacterization&&) = default; 58 59 GrSurfaceCharacterization(const GrSurfaceCharacterization&) = default; 60 GrSurfaceCharacterization& operator=(const GrSurfaceCharacterization& other) = default; 61 bool operator==(const GrSurfaceCharacterization& other) const; 62 bool operator!=(const GrSurfaceCharacterization& other) const { 63 return !(*this == other); 64 } 65 66 /* 67 * Return a new surface characterization with the only difference being a different width 68 * and height 69 */ 70 GrSurfaceCharacterization createResized(int width, int height) const; 71 72 /* 73 * Return a new surface characterization with only a replaced color space 74 */ 75 GrSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const; 76 77 /* 78 * Return a new surface characterization with the backend format replaced. A colorType 79 * must also be supplied to indicate the interpretation of the new format. 80 */ 81 GrSurfaceCharacterization createBackendFormat(SkColorType colorType, 82 const GrBackendFormat& backendFormat) const; 83 84 /* 85 * Return a new surface characterization with just a different use of FBO0 (in GL) 86 */ 87 GrSurfaceCharacterization createFBO0(bool usesGLFBO0) const; 88 contextInfo()89 GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); } refContextInfo()90 sk_sp<GrContextThreadSafeProxy> refContextInfo() const { return fContextInfo; } cacheMaxResourceBytes()91 size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; } 92 isValid()93 bool isValid() const { return kUnknown_SkColorType != fImageInfo.colorType(); } 94 imageInfo()95 const SkImageInfo& imageInfo() const { return fImageInfo; } backendFormat()96 const GrBackendFormat& backendFormat() const { return fBackendFormat; } origin()97 GrSurfaceOrigin origin() const { return fOrigin; } dimensions()98 SkISize dimensions() const { return fImageInfo.dimensions(); } width()99 int width() const { return fImageInfo.width(); } height()100 int height() const { return fImageInfo.height(); } colorType()101 SkColorType colorType() const { return fImageInfo.colorType(); } sampleCount()102 int sampleCount() const { return fSampleCnt; } isTextureable()103 bool isTextureable() const { return Textureable::kYes == fIsTextureable; } isMipMapped()104 bool isMipMapped() const { return skgpu::Mipmapped::kYes == fIsMipmapped; } usesGLFBO0()105 bool usesGLFBO0() const { return UsesGLFBO0::kYes == fUsesGLFBO0; } vkRTSupportsInputAttachment()106 bool vkRTSupportsInputAttachment() const { 107 return VkRTSupportsInputAttachment::kYes == fVkRTSupportsInputAttachment; 108 } vulkanSecondaryCBCompatible()109 bool vulkanSecondaryCBCompatible() const { 110 return VulkanSecondaryCBCompatible::kYes == fVulkanSecondaryCBCompatible; 111 } isProtected()112 skgpu::Protected isProtected() const { return fIsProtected; } colorSpace()113 SkColorSpace* colorSpace() const { return fImageInfo.colorSpace(); } refColorSpace()114 sk_sp<SkColorSpace> refColorSpace() const { return fImageInfo.refColorSpace(); } surfaceProps()115 const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; } 116 117 private: 118 friend class SkSurface_Ganesh; // for 'set' & 'config' 119 friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config' 120 friend class GrContextThreadSafeProxy; // for private ctor 121 friend class GrVkContextThreadSafeProxy; // for private ctor 122 friend class GrDeferredDisplayListRecorder; // for 'config' 123 friend class SkSurface; // for 'config' 124 125 SkDEBUGCODE(void validate() const;) 126 GrSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,size_t cacheMaxResourceBytes,const SkImageInfo & ii,const GrBackendFormat & backendFormat,GrSurfaceOrigin origin,int sampleCnt,Textureable isTextureable,skgpu::Mipmapped isMipmapped,UsesGLFBO0 usesGLFBO0,VkRTSupportsInputAttachment vkRTSupportsInputAttachment,VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,skgpu::Protected isProtected,const SkSurfaceProps & surfaceProps)127 GrSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo, 128 size_t cacheMaxResourceBytes, 129 const SkImageInfo& ii, 130 const GrBackendFormat& backendFormat, 131 GrSurfaceOrigin origin, 132 int sampleCnt, 133 Textureable isTextureable, 134 skgpu::Mipmapped isMipmapped, 135 UsesGLFBO0 usesGLFBO0, 136 VkRTSupportsInputAttachment vkRTSupportsInputAttachment, 137 VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible, 138 skgpu::Protected isProtected, 139 const SkSurfaceProps& surfaceProps) 140 : fContextInfo(std::move(contextInfo)) 141 , fCacheMaxResourceBytes(cacheMaxResourceBytes) 142 , fImageInfo(ii) 143 , fBackendFormat(std::move(backendFormat)) 144 , fOrigin(origin) 145 , fSampleCnt(sampleCnt) 146 , fIsTextureable(isTextureable) 147 , fIsMipmapped(isMipmapped) 148 , fUsesGLFBO0(usesGLFBO0) 149 , fVkRTSupportsInputAttachment(vkRTSupportsInputAttachment) 150 , fVulkanSecondaryCBCompatible(vulkanSecondaryCBCompatible) 151 , fIsProtected(isProtected) 152 , fSurfaceProps(surfaceProps) { 153 if (fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) { 154 // Dynamic MSAA is not currently supported with DDL. 155 *this = {}; 156 } 157 SkDEBUGCODE(this->validate()); 158 } 159 set(sk_sp<GrContextThreadSafeProxy> contextInfo,size_t cacheMaxResourceBytes,const SkImageInfo & ii,const GrBackendFormat & backendFormat,GrSurfaceOrigin origin,int sampleCnt,Textureable isTextureable,skgpu::Mipmapped isMipmapped,UsesGLFBO0 usesGLFBO0,VkRTSupportsInputAttachment vkRTSupportsInputAttachment,VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,skgpu::Protected isProtected,const SkSurfaceProps & surfaceProps)160 void set(sk_sp<GrContextThreadSafeProxy> contextInfo, 161 size_t cacheMaxResourceBytes, 162 const SkImageInfo& ii, 163 const GrBackendFormat& backendFormat, 164 GrSurfaceOrigin origin, 165 int sampleCnt, 166 Textureable isTextureable, 167 skgpu::Mipmapped isMipmapped, 168 UsesGLFBO0 usesGLFBO0, 169 VkRTSupportsInputAttachment vkRTSupportsInputAttachment, 170 VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible, 171 skgpu::Protected isProtected, 172 const SkSurfaceProps& surfaceProps) { 173 if (surfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) { 174 // Dynamic MSAA is not currently supported with DDL. 175 *this = {}; 176 } else { 177 fContextInfo = std::move(contextInfo); 178 fCacheMaxResourceBytes = cacheMaxResourceBytes; 179 180 fImageInfo = ii; 181 fBackendFormat = std::move(backendFormat); 182 fOrigin = origin; 183 fSampleCnt = sampleCnt; 184 fIsTextureable = isTextureable; 185 fIsMipmapped = isMipmapped; 186 fUsesGLFBO0 = usesGLFBO0; 187 fVkRTSupportsInputAttachment = vkRTSupportsInputAttachment; 188 fVulkanSecondaryCBCompatible = vulkanSecondaryCBCompatible; 189 fIsProtected = isProtected; 190 fSurfaceProps = surfaceProps; 191 } 192 SkDEBUGCODE(this->validate()); 193 } 194 195 sk_sp<GrContextThreadSafeProxy> fContextInfo; 196 size_t fCacheMaxResourceBytes; 197 198 SkImageInfo fImageInfo; 199 GrBackendFormat fBackendFormat; 200 GrSurfaceOrigin fOrigin; 201 int fSampleCnt; 202 Textureable fIsTextureable; 203 skgpu::Mipmapped fIsMipmapped; 204 UsesGLFBO0 fUsesGLFBO0; 205 VkRTSupportsInputAttachment fVkRTSupportsInputAttachment; 206 VulkanSecondaryCBCompatible fVulkanSecondaryCBCompatible; 207 skgpu::Protected fIsProtected; 208 SkSurfaceProps fSurfaceProps; 209 }; 210 211 #endif 212