1 /* 2 * Copyright 2017 Google Inc. 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 SkSurfaceCharacterization_DEFINED 9 #define SkSurfaceCharacterization_DEFINED 10 11 #include "GrTypes.h" 12 13 #include "SkColorSpace.h" 14 #include "SkRefCnt.h" 15 #include "SkSurfaceProps.h" 16 17 class SkColorSpace; 18 19 // This define can be used to swap between the default (raster) DDL implementation and the 20 // gpu implementation. 21 #define SK_RASTER_RECORDER_IMPLEMENTATION 1 22 23 #if SK_SUPPORT_GPU 24 #include "GrContext.h" 25 26 /** \class SkSurfaceCharacterization 27 A surface characterization contains all the information Ganesh requires to makes its internal 28 rendering decisions. When passed into a SkDeferredDisplayListRecorder it will copy the 29 data and pass it on to the SkDeferredDisplayList if/when it is created. Note that both of 30 those objects (the Recorder and the DisplayList) will take a ref on the 31 GrContextThreadSafeProxy and SkColorSpace objects. 32 */ 33 class SkSurfaceCharacterization { 34 public: 35 enum class Textureable : bool { kNo = false, kYes = true }; 36 enum class MipMapped : bool { kNo = false, kYes = true }; 37 SkSurfaceCharacterization()38 SkSurfaceCharacterization() 39 : fCacheMaxResourceBytes(0) 40 , fOrigin(kBottomLeft_GrSurfaceOrigin) 41 , fWidth(0) 42 , fHeight(0) 43 , fConfig(kUnknown_GrPixelConfig) 44 , fFSAAType(GrFSAAType::kNone) 45 , fStencilCnt(0) 46 , fIsTextureable(Textureable::kYes) 47 , fIsMipMapped(MipMapped::kYes) 48 , fSurfaceProps(0, kUnknown_SkPixelGeometry) { 49 } 50 51 SkSurfaceCharacterization(SkSurfaceCharacterization&&) = default; 52 SkSurfaceCharacterization& operator=(SkSurfaceCharacterization&&) = default; 53 54 SkSurfaceCharacterization(const SkSurfaceCharacterization&) = default; 55 SkSurfaceCharacterization& operator=(const SkSurfaceCharacterization& other) = default; 56 contextInfo()57 GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); } refContextInfo()58 sk_sp<GrContextThreadSafeProxy> refContextInfo() const { return fContextInfo; } cacheMaxResourceBytes()59 size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; } 60 isValid()61 bool isValid() const { return kUnknown_GrPixelConfig != fConfig; } 62 origin()63 GrSurfaceOrigin origin() const { return fOrigin; } width()64 int width() const { return fWidth; } height()65 int height() const { return fHeight; } config()66 GrPixelConfig config() const { return fConfig; } fsaaType()67 GrFSAAType fsaaType() const { return fFSAAType; } stencilCount()68 int stencilCount() const { return fStencilCnt; } isTextureable()69 bool isTextureable() const { return Textureable::kYes == fIsTextureable; } isMipMapped()70 bool isMipMapped() const { return MipMapped::kYes == fIsMipMapped; } colorSpace()71 SkColorSpace* colorSpace() const { return fColorSpace.get(); } refColorSpace()72 sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; } surfaceProps()73 const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; } 74 75 private: 76 friend class SkSurface_Gpu; // for 'set' 77 friend class GrContextThreadSafeProxy; // for private ctor 78 SkSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,size_t cacheMaxResourceBytes,GrSurfaceOrigin origin,int width,int height,GrPixelConfig config,GrFSAAType FSAAType,int stencilCnt,Textureable isTextureable,MipMapped isMipMapped,sk_sp<SkColorSpace> colorSpace,const SkSurfaceProps & surfaceProps)79 SkSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo, 80 size_t cacheMaxResourceBytes, 81 GrSurfaceOrigin origin, int width, int height, 82 GrPixelConfig config, GrFSAAType FSAAType, int stencilCnt, 83 Textureable isTextureable, MipMapped isMipMapped, 84 sk_sp<SkColorSpace> colorSpace, 85 const SkSurfaceProps& surfaceProps) 86 : fContextInfo(std::move(contextInfo)) 87 , fCacheMaxResourceBytes(cacheMaxResourceBytes) 88 , fOrigin(origin) 89 , fWidth(width) 90 , fHeight(height) 91 , fConfig(config) 92 , fFSAAType(FSAAType) 93 , fStencilCnt(stencilCnt) 94 , fIsTextureable(isTextureable) 95 , fIsMipMapped(isMipMapped) 96 , fColorSpace(std::move(colorSpace)) 97 , fSurfaceProps(surfaceProps) { 98 } 99 set(sk_sp<GrContextThreadSafeProxy> contextInfo,size_t cacheMaxResourceBytes,GrSurfaceOrigin origin,int width,int height,GrPixelConfig config,GrFSAAType fsaaType,int stencilCnt,Textureable isTextureable,MipMapped isMipMapped,sk_sp<SkColorSpace> colorSpace,const SkSurfaceProps & surfaceProps)100 void set(sk_sp<GrContextThreadSafeProxy> contextInfo, 101 size_t cacheMaxResourceBytes, 102 GrSurfaceOrigin origin, 103 int width, int height, 104 GrPixelConfig config, 105 GrFSAAType fsaaType, 106 int stencilCnt, 107 Textureable isTextureable, 108 MipMapped isMipMapped, 109 sk_sp<SkColorSpace> colorSpace, 110 const SkSurfaceProps& surfaceProps) { 111 SkASSERT(MipMapped::kNo == isMipMapped || Textureable::kYes == isTextureable); 112 113 fContextInfo = contextInfo; 114 fCacheMaxResourceBytes = cacheMaxResourceBytes; 115 116 fOrigin = origin; 117 fWidth = width; 118 fHeight = height; 119 fConfig = config; 120 fFSAAType = fsaaType; 121 fStencilCnt = stencilCnt; 122 fIsTextureable = isTextureable; 123 fIsMipMapped = isMipMapped; 124 fColorSpace = std::move(colorSpace); 125 fSurfaceProps = surfaceProps; 126 } 127 128 sk_sp<GrContextThreadSafeProxy> fContextInfo; 129 size_t fCacheMaxResourceBytes; 130 131 GrSurfaceOrigin fOrigin; 132 int fWidth; 133 int fHeight; 134 GrPixelConfig fConfig; 135 GrFSAAType fFSAAType; 136 int fStencilCnt; 137 Textureable fIsTextureable; 138 MipMapped fIsMipMapped; 139 sk_sp<SkColorSpace> fColorSpace; 140 SkSurfaceProps fSurfaceProps; 141 }; 142 143 #else// !SK_SUPPORT_GPU 144 145 class SkSurfaceCharacterization { 146 public: SkSurfaceCharacterization()147 SkSurfaceCharacterization() 148 : fWidth(0) 149 , fHeight(0) 150 , fSurfaceProps(0, kUnknown_SkPixelGeometry) { 151 } 152 isValid()153 bool isValid() const { return false; } 154 width()155 int width() const { return fWidth; } height()156 int height() const { return fHeight; } colorSpace()157 SkColorSpace* colorSpace() const { return fColorSpace.get(); } refColorSpace()158 sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; } surfaceProps()159 const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; } 160 161 private: 162 int fWidth; 163 int fHeight; 164 sk_sp<SkColorSpace> fColorSpace; 165 SkSurfaceProps fSurfaceProps; 166 }; 167 168 #endif 169 170 #endif 171