GrTypesPriv.h 53 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534
  1. /*
  2. * Copyright 2013 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. #ifndef GrTypesPriv_DEFINED
  8. #define GrTypesPriv_DEFINED
  9. #include <chrono>
  10. #include "include/core/SkCanvas.h"
  11. #include "include/core/SkImage.h"
  12. #include "include/core/SkImageInfo.h"
  13. #include "include/core/SkPath.h"
  14. #include "include/core/SkRefCnt.h"
  15. #include "include/gpu/GrTypes.h"
  16. #include "include/private/GrSharedEnums.h"
  17. #include "include/private/SkImageInfoPriv.h"
  18. #include "include/private/SkWeakRefCnt.h"
  19. class GrBackendFormat;
  20. class GrCaps;
  21. // The old libstdc++ uses the draft name "monotonic_clock" rather than "steady_clock". This might
  22. // not actually be monotonic, depending on how libstdc++ was built. However, this is only currently
  23. // used for idle resource purging so it shouldn't cause a correctness problem.
  24. #if defined(__GLIBCXX__) && (__GLIBCXX__ < 20130000)
  25. using GrStdSteadyClock = std::chrono::monotonic_clock;
  26. #else
  27. using GrStdSteadyClock = std::chrono::steady_clock;
  28. #endif
  29. /**
  30. * Pixel configurations. This type conflates texture formats, CPU pixel formats, and
  31. * premultipliedness. We are moving away from it towards SkColorType and backend API (GL, Vulkan)
  32. * texture formats in the public API. Right now this mostly refers to texture formats as we're
  33. * migrating.
  34. */
  35. enum GrPixelConfig {
  36. kUnknown_GrPixelConfig,
  37. kAlpha_8_GrPixelConfig,
  38. kAlpha_8_as_Alpha_GrPixelConfig,
  39. kAlpha_8_as_Red_GrPixelConfig,
  40. kGray_8_GrPixelConfig,
  41. kGray_8_as_Lum_GrPixelConfig,
  42. kGray_8_as_Red_GrPixelConfig,
  43. kRGB_565_GrPixelConfig,
  44. kRGBA_4444_GrPixelConfig,
  45. kRGBA_8888_GrPixelConfig,
  46. kRGB_888_GrPixelConfig,
  47. kRGB_888X_GrPixelConfig,
  48. kRG_88_GrPixelConfig,
  49. kBGRA_8888_GrPixelConfig,
  50. kSRGBA_8888_GrPixelConfig,
  51. kRGBA_1010102_GrPixelConfig,
  52. kRGBA_float_GrPixelConfig,
  53. kAlpha_half_GrPixelConfig,
  54. kAlpha_half_as_Lum_GrPixelConfig,
  55. kAlpha_half_as_Red_GrPixelConfig,
  56. kRGBA_half_GrPixelConfig,
  57. kRGBA_half_Clamped_GrPixelConfig,
  58. kRGB_ETC1_GrPixelConfig,
  59. kR_16_GrPixelConfig,
  60. kRG_1616_GrPixelConfig,
  61. // Experimental (for Y416 and mutant P016/P010)
  62. kRGBA_16161616_GrPixelConfig,
  63. kRG_half_GrPixelConfig,
  64. kLast_GrPixelConfig = kRG_half_GrPixelConfig
  65. };
  66. static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1;
  67. // Aliases for pixel configs that match skia's byte order.
  68. #ifndef SK_CPU_LENDIAN
  69. #error "Skia gpu currently assumes little endian"
  70. #endif
  71. #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
  72. static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig;
  73. #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
  74. static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig;
  75. #else
  76. #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format."
  77. #endif
  78. /**
  79. * Geometric primitives used for drawing.
  80. */
  81. enum class GrPrimitiveType {
  82. kTriangles,
  83. kTriangleStrip,
  84. kPoints,
  85. kLines, // 1 pix wide only
  86. kLineStrip, // 1 pix wide only
  87. kLinesAdjacency // requires geometry shader support.
  88. };
  89. static constexpr int kNumGrPrimitiveTypes = (int)GrPrimitiveType::kLinesAdjacency + 1;
  90. static constexpr bool GrIsPrimTypeLines(GrPrimitiveType type) {
  91. return GrPrimitiveType::kLines == type ||
  92. GrPrimitiveType::kLineStrip == type ||
  93. GrPrimitiveType::kLinesAdjacency == type;
  94. }
  95. static constexpr bool GrIsPrimTypeTris(GrPrimitiveType type) {
  96. return GrPrimitiveType::kTriangles == type || GrPrimitiveType::kTriangleStrip == type;
  97. }
  98. static constexpr bool GrPrimTypeRequiresGeometryShaderSupport(GrPrimitiveType type) {
  99. return GrPrimitiveType::kLinesAdjacency == type;
  100. }
  101. enum class GrPrimitiveRestart : bool {
  102. kNo = false,
  103. kYes = true
  104. };
  105. /**
  106. * Formats for masks, used by the font cache. Important that these are 0-based.
  107. */
  108. enum GrMaskFormat {
  109. kA8_GrMaskFormat, //!< 1-byte per pixel
  110. kA565_GrMaskFormat, //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage
  111. kARGB_GrMaskFormat, //!< 4-bytes per pixel, color format
  112. kLast_GrMaskFormat = kARGB_GrMaskFormat
  113. };
  114. static const int kMaskFormatCount = kLast_GrMaskFormat + 1;
  115. /**
  116. * Return the number of bytes-per-pixel for the specified mask format.
  117. */
  118. static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
  119. SkASSERT(format < kMaskFormatCount);
  120. // kA8 (0) -> 1
  121. // kA565 (1) -> 2
  122. // kARGB (2) -> 4
  123. static const int sBytesPerPixel[] = {1, 2, 4};
  124. static_assert(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, "array_size_mismatch");
  125. static_assert(kA8_GrMaskFormat == 0, "enum_order_dependency");
  126. static_assert(kA565_GrMaskFormat == 1, "enum_order_dependency");
  127. static_assert(kARGB_GrMaskFormat == 2, "enum_order_dependency");
  128. return sBytesPerPixel[(int)format];
  129. }
  130. /**
  131. * Describes a surface to be created.
  132. */
  133. struct GrSurfaceDesc {
  134. GrSurfaceDesc() : fWidth(0), fHeight(0), fConfig(kUnknown_GrPixelConfig) {}
  135. int fWidth; //!< Width of the texture
  136. int fHeight; //!< Height of the texture
  137. /**
  138. * Format of source data of the texture. Not guaranteed to be the same as
  139. * internal format used by 3D API.
  140. */
  141. GrPixelConfig fConfig;
  142. };
  143. /** Ownership rules for external GPU resources imported into Skia. */
  144. enum GrWrapOwnership {
  145. /** Skia will assume the client will keep the resource alive and Skia will not free it. */
  146. kBorrow_GrWrapOwnership,
  147. /** Skia will assume ownership of the resource and free it. */
  148. kAdopt_GrWrapOwnership,
  149. };
  150. enum class GrWrapCacheable : bool {
  151. /**
  152. * The wrapped resource will be removed from the cache as soon as it becomes purgeable. It may
  153. * still be assigned and found by a unique key, but the presence of the key will not be used to
  154. * keep the resource alive when it has no references.
  155. */
  156. kNo = false,
  157. /**
  158. * The wrapped resource is allowed to remain in the GrResourceCache when it has no references
  159. * but has a unique key. Such resources should only be given unique keys when it is known that
  160. * the key will eventually be removed from the resource or invalidated via the message bus.
  161. */
  162. kYes = true
  163. };
  164. enum class GrBudgetedType : uint8_t {
  165. /** The resource is budgeted and is subject to purging under budget pressure. */
  166. kBudgeted,
  167. /**
  168. * The resource is unbudgeted and is purged as soon as it has no refs regardless of whether
  169. * it has a unique or scratch key.
  170. */
  171. kUnbudgetedUncacheable,
  172. /**
  173. * The resource is unbudgeted and is allowed to remain in the cache with no refs if it
  174. * has a unique key. Scratch keys are ignored.
  175. */
  176. kUnbudgetedCacheable,
  177. };
  178. /**
  179. * Clips are composed from these objects.
  180. */
  181. enum GrClipType {
  182. kRect_ClipType,
  183. kPath_ClipType
  184. };
  185. enum class GrScissorTest : bool {
  186. kDisabled = false,
  187. kEnabled = true
  188. };
  189. struct GrMipLevel {
  190. const void* fPixels = nullptr;
  191. size_t fRowBytes = 0;
  192. };
  193. /**
  194. * This enum is used to specify the load operation to be used when an opList/GrGpuCommandBuffer
  195. * begins execution.
  196. */
  197. enum class GrLoadOp {
  198. kLoad,
  199. kClear,
  200. kDiscard,
  201. };
  202. /**
  203. * This enum is used to specify the store operation to be used when an opList/GrGpuCommandBuffer
  204. * ends execution.
  205. */
  206. enum class GrStoreOp {
  207. kStore,
  208. kDiscard,
  209. };
  210. /**
  211. * Used to control antialiasing in draw calls.
  212. */
  213. enum class GrAA : bool {
  214. kNo = false,
  215. kYes = true
  216. };
  217. enum class GrFillRule : bool {
  218. kNonzero,
  219. kEvenOdd
  220. };
  221. inline GrFillRule GrFillRuleForSkPath(const SkPath& path) {
  222. switch (path.getFillType()) {
  223. case SkPath::kWinding_FillType:
  224. case SkPath::kInverseWinding_FillType:
  225. return GrFillRule::kNonzero;
  226. case SkPath::kEvenOdd_FillType:
  227. case SkPath::kInverseEvenOdd_FillType:
  228. return GrFillRule::kEvenOdd;
  229. }
  230. SkUNREACHABLE;
  231. }
  232. /** This enum indicates the type of antialiasing to be performed. */
  233. enum class GrAAType : unsigned {
  234. /** No antialiasing */
  235. kNone,
  236. /** Use fragment shader code or mixed samples to blend with a fractional pixel coverage. */
  237. kCoverage,
  238. /** Use normal MSAA. */
  239. kMSAA
  240. };
  241. static constexpr bool GrAATypeIsHW(GrAAType type) {
  242. switch (type) {
  243. case GrAAType::kNone:
  244. return false;
  245. case GrAAType::kCoverage:
  246. return false;
  247. case GrAAType::kMSAA:
  248. return true;
  249. }
  250. SkUNREACHABLE;
  251. }
  252. /**
  253. * Some pixel configs are inherently clamped to [0,1], some are allowed to go outside that range,
  254. * and some are FP but manually clamped in the XP.
  255. */
  256. enum class GrClampType {
  257. kAuto, // Normalized, fixed-point configs
  258. kManual, // Clamped FP configs
  259. kNone, // Normal (unclamped) FP configs
  260. };
  261. /**
  262. * A number of rectangle/quadrilateral drawing APIs can control anti-aliasing on a per edge basis.
  263. * These masks specify which edges are AA'ed. The intent for this is to support tiling with seamless
  264. * boundaries, where the inner edges are non-AA and the outer edges are AA. Regular draws (where AA
  265. * is specified by GrAA) is almost equivalent to kNone or kAll, with the exception of how MSAA is
  266. * handled.
  267. *
  268. * When tiling and there is MSAA, mixed edge rectangles are processed with MSAA, so in order for the
  269. * tiled edges to remain seamless, inner tiles with kNone must also be processed with MSAA. In
  270. * regular drawing, however, kNone should disable MSAA (if it's supported) to match the expected
  271. * appearance.
  272. *
  273. * Therefore, APIs that use per-edge AA flags also take a GrAA value so that they can differentiate
  274. * between the regular and tiling use case behaviors. Tiling operations should always pass
  275. * GrAA::kYes while regular options should pass GrAA based on the SkPaint's anti-alias state.
  276. */
  277. enum class GrQuadAAFlags {
  278. kLeft = SkCanvas::kLeft_QuadAAFlag,
  279. kTop = SkCanvas::kTop_QuadAAFlag,
  280. kRight = SkCanvas::kRight_QuadAAFlag,
  281. kBottom = SkCanvas::kBottom_QuadAAFlag,
  282. kNone = SkCanvas::kNone_QuadAAFlags,
  283. kAll = SkCanvas::kAll_QuadAAFlags
  284. };
  285. GR_MAKE_BITFIELD_CLASS_OPS(GrQuadAAFlags)
  286. static inline GrQuadAAFlags SkToGrQuadAAFlags(unsigned flags) {
  287. return static_cast<GrQuadAAFlags>(flags);
  288. }
  289. /**
  290. * Types of shader-language-specific boxed variables we can create.
  291. */
  292. enum GrSLType {
  293. kVoid_GrSLType,
  294. kBool_GrSLType,
  295. kByte_GrSLType,
  296. kByte2_GrSLType,
  297. kByte3_GrSLType,
  298. kByte4_GrSLType,
  299. kUByte_GrSLType,
  300. kUByte2_GrSLType,
  301. kUByte3_GrSLType,
  302. kUByte4_GrSLType,
  303. kShort_GrSLType,
  304. kShort2_GrSLType,
  305. kShort3_GrSLType,
  306. kShort4_GrSLType,
  307. kUShort_GrSLType,
  308. kUShort2_GrSLType,
  309. kUShort3_GrSLType,
  310. kUShort4_GrSLType,
  311. kFloat_GrSLType,
  312. kFloat2_GrSLType,
  313. kFloat3_GrSLType,
  314. kFloat4_GrSLType,
  315. kFloat2x2_GrSLType,
  316. kFloat3x3_GrSLType,
  317. kFloat4x4_GrSLType,
  318. kHalf_GrSLType,
  319. kHalf2_GrSLType,
  320. kHalf3_GrSLType,
  321. kHalf4_GrSLType,
  322. kHalf2x2_GrSLType,
  323. kHalf3x3_GrSLType,
  324. kHalf4x4_GrSLType,
  325. kInt_GrSLType,
  326. kInt2_GrSLType,
  327. kInt3_GrSLType,
  328. kInt4_GrSLType,
  329. kUint_GrSLType,
  330. kUint2_GrSLType,
  331. kTexture2DSampler_GrSLType,
  332. kTextureExternalSampler_GrSLType,
  333. kTexture2DRectSampler_GrSLType,
  334. kLast_GrSLType = kTexture2DRectSampler_GrSLType
  335. };
  336. static const int kGrSLTypeCount = kLast_GrSLType + 1;
  337. /**
  338. * The type of texture. Backends other than GL currently only use the 2D value but the type must
  339. * still be known at the API-neutral layer as it used to determine whether MIP maps, renderability,
  340. * and sampling parameters are legal for proxies that will be instantiated with wrapped textures.
  341. */
  342. enum class GrTextureType {
  343. kNone,
  344. k2D,
  345. /* Rectangle uses unnormalized texture coordinates. */
  346. kRectangle,
  347. kExternal
  348. };
  349. enum GrShaderType {
  350. kVertex_GrShaderType,
  351. kGeometry_GrShaderType,
  352. kFragment_GrShaderType,
  353. kLastkFragment_GrShaderType = kFragment_GrShaderType
  354. };
  355. static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1;
  356. enum GrShaderFlags {
  357. kNone_GrShaderFlags = 0,
  358. kVertex_GrShaderFlag = 1 << kVertex_GrShaderType,
  359. kGeometry_GrShaderFlag = 1 << kGeometry_GrShaderType,
  360. kFragment_GrShaderFlag = 1 << kFragment_GrShaderType
  361. };
  362. GR_MAKE_BITFIELD_OPS(GrShaderFlags)
  363. /**
  364. * Precisions of shader language variables. Not all shading languages support precisions or actually
  365. * vary the internal precision based on the qualifiers. These currently only apply to float types (
  366. * including float vectors and matrices).
  367. */
  368. enum GrSLPrecision : int {
  369. kLow_GrSLPrecision,
  370. kMedium_GrSLPrecision,
  371. kHigh_GrSLPrecision,
  372. // Default precision is a special tag that means "whatever the default for the program/type
  373. // combination is". In other words, it maps to the empty string in shader code. There are some
  374. // scenarios where kDefault is not allowed (as the default precision for a program, or for
  375. // varyings, for example).
  376. kDefault_GrSLPrecision,
  377. // We only consider the "real" precisions here
  378. kLast_GrSLPrecision = kHigh_GrSLPrecision,
  379. };
  380. static const int kGrSLPrecisionCount = kLast_GrSLPrecision + 1;
  381. /** Is the shading language type float (including vectors/matrices)? */
  382. static constexpr bool GrSLTypeIsFloatType(GrSLType type) {
  383. switch (type) {
  384. case kFloat_GrSLType:
  385. case kFloat2_GrSLType:
  386. case kFloat3_GrSLType:
  387. case kFloat4_GrSLType:
  388. case kFloat2x2_GrSLType:
  389. case kFloat3x3_GrSLType:
  390. case kFloat4x4_GrSLType:
  391. case kHalf_GrSLType:
  392. case kHalf2_GrSLType:
  393. case kHalf3_GrSLType:
  394. case kHalf4_GrSLType:
  395. case kHalf2x2_GrSLType:
  396. case kHalf3x3_GrSLType:
  397. case kHalf4x4_GrSLType:
  398. return true;
  399. case kVoid_GrSLType:
  400. case kTexture2DSampler_GrSLType:
  401. case kTextureExternalSampler_GrSLType:
  402. case kTexture2DRectSampler_GrSLType:
  403. case kBool_GrSLType:
  404. case kByte_GrSLType:
  405. case kByte2_GrSLType:
  406. case kByte3_GrSLType:
  407. case kByte4_GrSLType:
  408. case kUByte_GrSLType:
  409. case kUByte2_GrSLType:
  410. case kUByte3_GrSLType:
  411. case kUByte4_GrSLType:
  412. case kShort_GrSLType:
  413. case kShort2_GrSLType:
  414. case kShort3_GrSLType:
  415. case kShort4_GrSLType:
  416. case kUShort_GrSLType:
  417. case kUShort2_GrSLType:
  418. case kUShort3_GrSLType:
  419. case kUShort4_GrSLType:
  420. case kInt_GrSLType:
  421. case kInt2_GrSLType:
  422. case kInt3_GrSLType:
  423. case kInt4_GrSLType:
  424. case kUint_GrSLType:
  425. case kUint2_GrSLType:
  426. return false;
  427. }
  428. SkUNREACHABLE;
  429. }
  430. /** If the type represents a single value or vector return the vector length, else -1. */
  431. static constexpr int GrSLTypeVecLength(GrSLType type) {
  432. switch (type) {
  433. case kFloat_GrSLType:
  434. case kHalf_GrSLType:
  435. case kBool_GrSLType:
  436. case kByte_GrSLType:
  437. case kUByte_GrSLType:
  438. case kShort_GrSLType:
  439. case kUShort_GrSLType:
  440. case kInt_GrSLType:
  441. case kUint_GrSLType:
  442. return 1;
  443. case kFloat2_GrSLType:
  444. case kHalf2_GrSLType:
  445. case kByte2_GrSLType:
  446. case kUByte2_GrSLType:
  447. case kShort2_GrSLType:
  448. case kUShort2_GrSLType:
  449. case kInt2_GrSLType:
  450. case kUint2_GrSLType:
  451. return 2;
  452. case kFloat3_GrSLType:
  453. case kHalf3_GrSLType:
  454. case kByte3_GrSLType:
  455. case kUByte3_GrSLType:
  456. case kShort3_GrSLType:
  457. case kUShort3_GrSLType:
  458. case kInt3_GrSLType:
  459. return 3;
  460. case kFloat4_GrSLType:
  461. case kHalf4_GrSLType:
  462. case kByte4_GrSLType:
  463. case kUByte4_GrSLType:
  464. case kShort4_GrSLType:
  465. case kUShort4_GrSLType:
  466. case kInt4_GrSLType:
  467. return 4;
  468. case kFloat2x2_GrSLType:
  469. case kFloat3x3_GrSLType:
  470. case kFloat4x4_GrSLType:
  471. case kHalf2x2_GrSLType:
  472. case kHalf3x3_GrSLType:
  473. case kHalf4x4_GrSLType:
  474. case kVoid_GrSLType:
  475. case kTexture2DSampler_GrSLType:
  476. case kTextureExternalSampler_GrSLType:
  477. case kTexture2DRectSampler_GrSLType:
  478. return -1;
  479. }
  480. SkUNREACHABLE;
  481. }
  482. static inline GrSLType GrSLCombinedSamplerTypeForTextureType(GrTextureType type) {
  483. switch (type) {
  484. case GrTextureType::k2D:
  485. return kTexture2DSampler_GrSLType;
  486. case GrTextureType::kRectangle:
  487. return kTexture2DRectSampler_GrSLType;
  488. case GrTextureType::kExternal:
  489. return kTextureExternalSampler_GrSLType;
  490. default:
  491. SK_ABORT("Unexpected texture type");
  492. return kTexture2DSampler_GrSLType;
  493. }
  494. }
  495. /** Rectangle and external textures only support the clamp wrap mode and do not support
  496. * MIP maps.
  497. */
  498. static inline bool GrTextureTypeHasRestrictedSampling(GrTextureType type) {
  499. switch (type) {
  500. case GrTextureType::k2D:
  501. return false;
  502. case GrTextureType::kRectangle:
  503. return true;
  504. case GrTextureType::kExternal:
  505. return true;
  506. default:
  507. SK_ABORT("Unexpected texture type");
  508. return false;
  509. }
  510. }
  511. static constexpr bool GrSLTypeIsCombinedSamplerType(GrSLType type) {
  512. switch (type) {
  513. case kTexture2DSampler_GrSLType:
  514. case kTextureExternalSampler_GrSLType:
  515. case kTexture2DRectSampler_GrSLType:
  516. return true;
  517. case kVoid_GrSLType:
  518. case kFloat_GrSLType:
  519. case kFloat2_GrSLType:
  520. case kFloat3_GrSLType:
  521. case kFloat4_GrSLType:
  522. case kFloat2x2_GrSLType:
  523. case kFloat3x3_GrSLType:
  524. case kFloat4x4_GrSLType:
  525. case kHalf_GrSLType:
  526. case kHalf2_GrSLType:
  527. case kHalf3_GrSLType:
  528. case kHalf4_GrSLType:
  529. case kHalf2x2_GrSLType:
  530. case kHalf3x3_GrSLType:
  531. case kHalf4x4_GrSLType:
  532. case kInt_GrSLType:
  533. case kInt2_GrSLType:
  534. case kInt3_GrSLType:
  535. case kInt4_GrSLType:
  536. case kUint_GrSLType:
  537. case kUint2_GrSLType:
  538. case kBool_GrSLType:
  539. case kByte_GrSLType:
  540. case kByte2_GrSLType:
  541. case kByte3_GrSLType:
  542. case kByte4_GrSLType:
  543. case kUByte_GrSLType:
  544. case kUByte2_GrSLType:
  545. case kUByte3_GrSLType:
  546. case kUByte4_GrSLType:
  547. case kShort_GrSLType:
  548. case kShort2_GrSLType:
  549. case kShort3_GrSLType:
  550. case kShort4_GrSLType:
  551. case kUShort_GrSLType:
  552. case kUShort2_GrSLType:
  553. case kUShort3_GrSLType:
  554. case kUShort4_GrSLType:
  555. return false;
  556. }
  557. SkUNREACHABLE;
  558. }
  559. //////////////////////////////////////////////////////////////////////////////
  560. /**
  561. * Types used to describe format of vertices in arrays.
  562. */
  563. enum GrVertexAttribType {
  564. kFloat_GrVertexAttribType = 0,
  565. kFloat2_GrVertexAttribType,
  566. kFloat3_GrVertexAttribType,
  567. kFloat4_GrVertexAttribType,
  568. kHalf_GrVertexAttribType,
  569. kHalf2_GrVertexAttribType,
  570. kHalf3_GrVertexAttribType,
  571. kHalf4_GrVertexAttribType,
  572. kInt2_GrVertexAttribType, // vector of 2 32-bit ints
  573. kInt3_GrVertexAttribType, // vector of 3 32-bit ints
  574. kInt4_GrVertexAttribType, // vector of 4 32-bit ints
  575. kByte_GrVertexAttribType, // signed byte
  576. kByte2_GrVertexAttribType, // vector of 2 8-bit signed bytes
  577. kByte3_GrVertexAttribType, // vector of 3 8-bit signed bytes
  578. kByte4_GrVertexAttribType, // vector of 4 8-bit signed bytes
  579. kUByte_GrVertexAttribType, // unsigned byte
  580. kUByte2_GrVertexAttribType, // vector of 2 8-bit unsigned bytes
  581. kUByte3_GrVertexAttribType, // vector of 3 8-bit unsigned bytes
  582. kUByte4_GrVertexAttribType, // vector of 4 8-bit unsigned bytes
  583. kUByte_norm_GrVertexAttribType, // unsigned byte, e.g. coverage, 0 -> 0.0f, 255 -> 1.0f.
  584. kUByte4_norm_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors, 0 -> 0.0f,
  585. // 255 -> 1.0f.
  586. kShort2_GrVertexAttribType, // vector of 2 16-bit shorts.
  587. kShort4_GrVertexAttribType, // vector of 4 16-bit shorts.
  588. kUShort2_GrVertexAttribType, // vector of 2 unsigned shorts. 0 -> 0, 65535 -> 65535.
  589. kUShort2_norm_GrVertexAttribType, // vector of 2 unsigned shorts. 0 -> 0.0f, 65535 -> 1.0f.
  590. kInt_GrVertexAttribType,
  591. kUint_GrVertexAttribType,
  592. kUShort_norm_GrVertexAttribType,
  593. // Experimental (for Y416)
  594. kUShort4_norm_GrVertexAttribType, // vector of 4 unsigned shorts. 0 -> 0.0f, 65535 -> 1.0f.
  595. kLast_GrVertexAttribType = kUShort4_norm_GrVertexAttribType
  596. };
  597. static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1;
  598. //////////////////////////////////////////////////////////////////////////////
  599. static const int kGrClipEdgeTypeCnt = (int) GrClipEdgeType::kLast + 1;
  600. static constexpr bool GrProcessorEdgeTypeIsFill(const GrClipEdgeType edgeType) {
  601. return (GrClipEdgeType::kFillAA == edgeType || GrClipEdgeType::kFillBW == edgeType);
  602. }
  603. static constexpr bool GrProcessorEdgeTypeIsInverseFill(const GrClipEdgeType edgeType) {
  604. return (GrClipEdgeType::kInverseFillAA == edgeType ||
  605. GrClipEdgeType::kInverseFillBW == edgeType);
  606. }
  607. static constexpr bool GrProcessorEdgeTypeIsAA(const GrClipEdgeType edgeType) {
  608. return (GrClipEdgeType::kFillBW != edgeType &&
  609. GrClipEdgeType::kInverseFillBW != edgeType);
  610. }
  611. static inline GrClipEdgeType GrInvertProcessorEdgeType(const GrClipEdgeType edgeType) {
  612. switch (edgeType) {
  613. case GrClipEdgeType::kFillBW:
  614. return GrClipEdgeType::kInverseFillBW;
  615. case GrClipEdgeType::kFillAA:
  616. return GrClipEdgeType::kInverseFillAA;
  617. case GrClipEdgeType::kInverseFillBW:
  618. return GrClipEdgeType::kFillBW;
  619. case GrClipEdgeType::kInverseFillAA:
  620. return GrClipEdgeType::kFillAA;
  621. case GrClipEdgeType::kHairlineAA:
  622. SK_ABORT("Hairline fill isn't invertible.");
  623. }
  624. return GrClipEdgeType::kFillAA; // suppress warning.
  625. }
  626. /**
  627. * Indicates the type of pending IO operations that can be recorded for gpu resources.
  628. */
  629. enum GrIOType {
  630. kRead_GrIOType,
  631. kWrite_GrIOType,
  632. kRW_GrIOType
  633. };
  634. /**
  635. * Indicates the type of data that a GPU buffer will be used for.
  636. */
  637. enum class GrGpuBufferType {
  638. kVertex,
  639. kIndex,
  640. kXferCpuToGpu,
  641. kXferGpuToCpu,
  642. };
  643. static const int kGrGpuBufferTypeCount = static_cast<int>(GrGpuBufferType::kXferGpuToCpu) + 1;
  644. /**
  645. * Provides a performance hint regarding the frequency at which a data store will be accessed.
  646. */
  647. enum GrAccessPattern {
  648. /** Data store will be respecified repeatedly and used many times. */
  649. kDynamic_GrAccessPattern,
  650. /** Data store will be specified once and used many times. (Thus disqualified from caching.) */
  651. kStatic_GrAccessPattern,
  652. /** Data store will be specified once and used at most a few times. (Also can't be cached.) */
  653. kStream_GrAccessPattern,
  654. kLast_GrAccessPattern = kStream_GrAccessPattern
  655. };
  656. // Flags shared between the GrSurface & GrSurfaceProxy class hierarchies
  657. enum class GrInternalSurfaceFlags {
  658. kNone = 0,
  659. // Surface-level
  660. // Texture-level
  661. // Means the pixels in the texture are read-only. Cannot also be a GrRenderTarget[Proxy].
  662. kReadOnly = 1 << 0,
  663. kTextureMask = kReadOnly,
  664. // RT-level
  665. // This flag is for use with GL only. It tells us that the internal render target wraps FBO 0.
  666. kGLRTFBOIDIs0 = 1 << 2,
  667. kRenderTargetMask = kGLRTFBOIDIs0,
  668. };
  669. GR_MAKE_BITFIELD_CLASS_OPS(GrInternalSurfaceFlags)
  670. #ifdef SK_DEBUG
  671. // Takes a pointer to a GrCaps, and will suppress prints if required
  672. #define GrCapsDebugf(caps, ...) if (!(caps)->suppressPrints()) SkDebugf(__VA_ARGS__)
  673. #else
  674. #define GrCapsDebugf(caps, ...) do {} while (0)
  675. #endif
  676. /**
  677. * Specifies if the holder owns the backend, OpenGL or Vulkan, object.
  678. */
  679. enum class GrBackendObjectOwnership : bool {
  680. /** Holder does not destroy the backend object. */
  681. kBorrowed = false,
  682. /** Holder destroys the backend object. */
  683. kOwned = true
  684. };
  685. template <typename T>
  686. T* const* unique_ptr_address_as_pointer_address(std::unique_ptr<T> const* up) {
  687. static_assert(sizeof(T*) == sizeof(std::unique_ptr<T>), "unique_ptr not expected size.");
  688. return reinterpret_cast<T* const*>(up);
  689. }
  690. /*
  691. * Object for CPU-GPU synchronization
  692. */
  693. typedef uint64_t GrFence;
  694. /**
  695. * Used to include or exclude specific GPU path renderers for testing purposes.
  696. */
  697. enum class GpuPathRenderers {
  698. kNone = 0, // Always use software masks and/or GrDefaultPathRenderer.
  699. kDashLine = 1 << 0,
  700. kStencilAndCover = 1 << 1,
  701. kCoverageCounting = 1 << 2,
  702. kAAHairline = 1 << 3,
  703. kAAConvex = 1 << 4,
  704. kAALinearizing = 1 << 5,
  705. kSmall = 1 << 6,
  706. kTessellating = 1 << 7,
  707. kAll = (kTessellating | (kTessellating - 1)),
  708. kDefault = kAll & ~kCoverageCounting
  709. };
  710. /**
  711. * Used to describe the current state of Mips on a GrTexture
  712. */
  713. enum class GrMipMapsStatus {
  714. kNotAllocated, // Mips have not been allocated
  715. kDirty, // Mips are allocated but the full mip tree does not have valid data
  716. kValid, // All levels fully allocated and have valid data in them
  717. };
  718. GR_MAKE_BITFIELD_CLASS_OPS(GpuPathRenderers)
  719. /**
  720. * Describes whether pixel data encoding should be converted to/from linear/sRGB encoding.
  721. */
  722. enum class GrSRGBConversion {
  723. kNone,
  724. kSRGBToLinear,
  725. kLinearToSRGB,
  726. };
  727. /**
  728. * Utility functions for GrPixelConfig
  729. */
  730. static constexpr bool GrPixelConfigIsSRGB(GrPixelConfig config) {
  731. switch (config) {
  732. case kSRGBA_8888_GrPixelConfig:
  733. return true;
  734. case kUnknown_GrPixelConfig:
  735. case kAlpha_8_GrPixelConfig:
  736. case kAlpha_8_as_Alpha_GrPixelConfig:
  737. case kAlpha_8_as_Red_GrPixelConfig:
  738. case kGray_8_GrPixelConfig:
  739. case kGray_8_as_Lum_GrPixelConfig:
  740. case kGray_8_as_Red_GrPixelConfig:
  741. case kRGB_565_GrPixelConfig:
  742. case kRGBA_4444_GrPixelConfig:
  743. case kRGB_888_GrPixelConfig:
  744. case kRGB_888X_GrPixelConfig:
  745. case kRG_88_GrPixelConfig:
  746. case kRGBA_8888_GrPixelConfig:
  747. case kBGRA_8888_GrPixelConfig:
  748. case kRGBA_1010102_GrPixelConfig:
  749. case kRGBA_float_GrPixelConfig:
  750. case kAlpha_half_GrPixelConfig:
  751. case kAlpha_half_as_Lum_GrPixelConfig:
  752. case kAlpha_half_as_Red_GrPixelConfig:
  753. case kRGBA_half_GrPixelConfig:
  754. case kRGBA_half_Clamped_GrPixelConfig:
  755. case kRGB_ETC1_GrPixelConfig:
  756. case kR_16_GrPixelConfig:
  757. case kRG_1616_GrPixelConfig:
  758. // Experimental (for Y416 and mutant P016/P010)
  759. case kRGBA_16161616_GrPixelConfig:
  760. case kRG_half_GrPixelConfig:
  761. return false;
  762. }
  763. SkUNREACHABLE;
  764. }
  765. static constexpr GrPixelConfig GrCompressionTypePixelConfig(SkImage::CompressionType compression) {
  766. switch (compression) {
  767. case SkImage::kETC1_CompressionType: return kRGB_ETC1_GrPixelConfig;
  768. }
  769. SkUNREACHABLE;
  770. }
  771. static constexpr size_t GrBytesPerPixel(GrPixelConfig config) {
  772. switch (config) {
  773. case kAlpha_8_GrPixelConfig:
  774. case kAlpha_8_as_Alpha_GrPixelConfig:
  775. case kAlpha_8_as_Red_GrPixelConfig:
  776. case kGray_8_GrPixelConfig:
  777. case kGray_8_as_Lum_GrPixelConfig:
  778. case kGray_8_as_Red_GrPixelConfig:
  779. return 1;
  780. case kRGB_565_GrPixelConfig:
  781. case kRGBA_4444_GrPixelConfig:
  782. case kRG_88_GrPixelConfig:
  783. case kAlpha_half_GrPixelConfig:
  784. case kAlpha_half_as_Lum_GrPixelConfig:
  785. case kAlpha_half_as_Red_GrPixelConfig:
  786. case kR_16_GrPixelConfig:
  787. return 2;
  788. case kRGBA_8888_GrPixelConfig:
  789. case kRGB_888_GrPixelConfig: // Assuming GPUs store this 4-byte aligned.
  790. case kRGB_888X_GrPixelConfig:
  791. case kBGRA_8888_GrPixelConfig:
  792. case kSRGBA_8888_GrPixelConfig:
  793. case kRGBA_1010102_GrPixelConfig:
  794. case kRG_1616_GrPixelConfig:
  795. return 4;
  796. case kRGBA_half_GrPixelConfig:
  797. case kRGBA_half_Clamped_GrPixelConfig:
  798. return 8;
  799. case kRGBA_float_GrPixelConfig:
  800. return 16;
  801. case kUnknown_GrPixelConfig:
  802. case kRGB_ETC1_GrPixelConfig:
  803. return 0;
  804. // Experimental (for Y416 and mutant P016/P010)
  805. case kRGBA_16161616_GrPixelConfig:
  806. return 8;
  807. case kRG_half_GrPixelConfig:
  808. return 4;
  809. }
  810. SkUNREACHABLE;
  811. }
  812. static constexpr bool GrPixelConfigIsOpaque(GrPixelConfig config) {
  813. switch (config) {
  814. case kRGB_565_GrPixelConfig:
  815. case kRGB_888_GrPixelConfig:
  816. case kRGB_888X_GrPixelConfig:
  817. case kRG_88_GrPixelConfig:
  818. case kGray_8_GrPixelConfig:
  819. case kGray_8_as_Lum_GrPixelConfig:
  820. case kGray_8_as_Red_GrPixelConfig:
  821. case kRGB_ETC1_GrPixelConfig:
  822. case kR_16_GrPixelConfig:
  823. case kRG_1616_GrPixelConfig:
  824. case kRG_half_GrPixelConfig: // Experimental (for mutant P016/P010)
  825. return true;
  826. case kAlpha_8_GrPixelConfig:
  827. case kAlpha_8_as_Alpha_GrPixelConfig:
  828. case kAlpha_8_as_Red_GrPixelConfig:
  829. case kRGBA_4444_GrPixelConfig:
  830. case kAlpha_half_GrPixelConfig:
  831. case kAlpha_half_as_Lum_GrPixelConfig:
  832. case kAlpha_half_as_Red_GrPixelConfig:
  833. case kRGBA_8888_GrPixelConfig:
  834. case kBGRA_8888_GrPixelConfig:
  835. case kSRGBA_8888_GrPixelConfig:
  836. case kRGBA_1010102_GrPixelConfig:
  837. case kRGBA_half_GrPixelConfig:
  838. case kRGBA_half_Clamped_GrPixelConfig:
  839. case kRGBA_float_GrPixelConfig:
  840. case kRGBA_16161616_GrPixelConfig: // Experimental (for Y416)
  841. case kUnknown_GrPixelConfig:
  842. return false;
  843. }
  844. SkUNREACHABLE;
  845. }
  846. static constexpr bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) {
  847. switch (config) {
  848. case kAlpha_8_GrPixelConfig:
  849. case kAlpha_8_as_Alpha_GrPixelConfig:
  850. case kAlpha_8_as_Red_GrPixelConfig:
  851. case kAlpha_half_GrPixelConfig:
  852. case kAlpha_half_as_Lum_GrPixelConfig:
  853. case kAlpha_half_as_Red_GrPixelConfig:
  854. return true;
  855. case kUnknown_GrPixelConfig:
  856. case kGray_8_GrPixelConfig:
  857. case kGray_8_as_Lum_GrPixelConfig:
  858. case kGray_8_as_Red_GrPixelConfig:
  859. case kRGB_565_GrPixelConfig:
  860. case kRGBA_4444_GrPixelConfig:
  861. case kRGBA_8888_GrPixelConfig:
  862. case kRGB_888_GrPixelConfig:
  863. case kRGB_888X_GrPixelConfig:
  864. case kRG_88_GrPixelConfig:
  865. case kBGRA_8888_GrPixelConfig:
  866. case kSRGBA_8888_GrPixelConfig:
  867. case kRGBA_1010102_GrPixelConfig:
  868. case kRGBA_float_GrPixelConfig:
  869. case kRGBA_half_GrPixelConfig:
  870. case kRGBA_half_Clamped_GrPixelConfig:
  871. case kRGB_ETC1_GrPixelConfig:
  872. case kR_16_GrPixelConfig:
  873. case kRG_1616_GrPixelConfig:
  874. // Experimental (for Y416 and mutant P016/P010)
  875. case kRGBA_16161616_GrPixelConfig:
  876. case kRG_half_GrPixelConfig:
  877. return false;
  878. }
  879. SkUNREACHABLE;
  880. }
  881. static constexpr bool GrPixelConfigIsFloatingPoint(GrPixelConfig config) {
  882. switch (config) {
  883. case kUnknown_GrPixelConfig:
  884. case kAlpha_8_GrPixelConfig:
  885. case kAlpha_8_as_Alpha_GrPixelConfig:
  886. case kAlpha_8_as_Red_GrPixelConfig:
  887. case kGray_8_GrPixelConfig:
  888. case kGray_8_as_Lum_GrPixelConfig:
  889. case kGray_8_as_Red_GrPixelConfig:
  890. case kRGB_565_GrPixelConfig:
  891. case kRGBA_4444_GrPixelConfig:
  892. case kRGB_888_GrPixelConfig:
  893. case kRGB_888X_GrPixelConfig:
  894. case kRG_88_GrPixelConfig:
  895. case kRGBA_8888_GrPixelConfig:
  896. case kBGRA_8888_GrPixelConfig:
  897. case kSRGBA_8888_GrPixelConfig:
  898. case kRGBA_1010102_GrPixelConfig:
  899. case kRGB_ETC1_GrPixelConfig:
  900. case kR_16_GrPixelConfig:
  901. case kRG_1616_GrPixelConfig:
  902. case kRGBA_16161616_GrPixelConfig: // Experimental (for Y416)
  903. return false;
  904. case kRGBA_float_GrPixelConfig:
  905. case kAlpha_half_GrPixelConfig:
  906. case kAlpha_half_as_Lum_GrPixelConfig:
  907. case kAlpha_half_as_Red_GrPixelConfig:
  908. case kRGBA_half_GrPixelConfig:
  909. case kRGBA_half_Clamped_GrPixelConfig:
  910. case kRG_half_GrPixelConfig: // Experimental (for mutant P016/P010)
  911. return true;
  912. }
  913. SkUNREACHABLE;
  914. }
  915. static constexpr GrClampType GrPixelConfigClampType(GrPixelConfig config) {
  916. if (!GrPixelConfigIsFloatingPoint(config)) {
  917. return GrClampType::kAuto;
  918. }
  919. return kRGBA_half_Clamped_GrPixelConfig == config ? GrClampType::kManual : GrClampType::kNone;
  920. }
  921. /**
  922. * Returns true if the pixel config is a GPU-specific compressed format
  923. * representation.
  924. */
  925. static constexpr bool GrPixelConfigIsCompressed(GrPixelConfig config) {
  926. switch (config) {
  927. case kRGB_ETC1_GrPixelConfig:
  928. return true;
  929. default:
  930. return false;
  931. }
  932. SkUNREACHABLE;
  933. }
  934. /**
  935. * If the pixel config is compressed, return an equivalent uncompressed format.
  936. */
  937. static constexpr GrPixelConfig GrMakePixelConfigUncompressed(GrPixelConfig config) {
  938. switch (config) {
  939. case kRGB_ETC1_GrPixelConfig:
  940. return kRGBA_8888_GrPixelConfig;
  941. default:
  942. return config;
  943. }
  944. SkUNREACHABLE;
  945. }
  946. /**
  947. * Returns the data size for the given compressed pixel config
  948. */
  949. static inline size_t GrCompressedFormatDataSize(GrPixelConfig config,
  950. int width, int height) {
  951. SkASSERT(GrPixelConfigIsCompressed(config));
  952. switch (config) {
  953. case kRGB_ETC1_GrPixelConfig:
  954. SkASSERT((width & 3) == 0);
  955. SkASSERT((height & 3) == 0);
  956. return (width >> 2) * (height >> 2) * 8;
  957. default:
  958. SK_ABORT("Unknown compressed pixel config");
  959. return 4 * width * height;
  960. }
  961. SK_ABORT("Invalid pixel config");
  962. return 4 * width * height;
  963. }
  964. /**
  965. * Precision qualifier that should be used with a sampler.
  966. */
  967. static constexpr GrSLPrecision GrSLSamplerPrecision(GrPixelConfig config) {
  968. switch (config) {
  969. case kUnknown_GrPixelConfig:
  970. case kAlpha_8_GrPixelConfig:
  971. case kAlpha_8_as_Alpha_GrPixelConfig:
  972. case kAlpha_8_as_Red_GrPixelConfig:
  973. case kGray_8_GrPixelConfig:
  974. case kGray_8_as_Lum_GrPixelConfig:
  975. case kGray_8_as_Red_GrPixelConfig:
  976. case kRGB_565_GrPixelConfig:
  977. case kRGBA_4444_GrPixelConfig:
  978. case kRGBA_8888_GrPixelConfig:
  979. case kRGB_888_GrPixelConfig:
  980. case kRGB_888X_GrPixelConfig:
  981. case kRG_88_GrPixelConfig:
  982. case kBGRA_8888_GrPixelConfig:
  983. case kSRGBA_8888_GrPixelConfig:
  984. case kRGB_ETC1_GrPixelConfig:
  985. return kLow_GrSLPrecision;
  986. case kRGBA_float_GrPixelConfig:
  987. return kHigh_GrSLPrecision;
  988. case kAlpha_half_GrPixelConfig:
  989. case kAlpha_half_as_Lum_GrPixelConfig:
  990. case kAlpha_half_as_Red_GrPixelConfig:
  991. case kRGBA_half_GrPixelConfig:
  992. case kRGBA_half_Clamped_GrPixelConfig:
  993. case kRGBA_1010102_GrPixelConfig:
  994. case kR_16_GrPixelConfig:
  995. case kRG_1616_GrPixelConfig:
  996. // Experimental (for Y416 and mutant P016/P010)
  997. case kRGBA_16161616_GrPixelConfig:
  998. case kRG_half_GrPixelConfig:
  999. return kMedium_GrSLPrecision;
  1000. }
  1001. SkUNREACHABLE;
  1002. }
  1003. /**
  1004. * Like SkColorType this describes a layout of pixel data in CPU memory. It specifies the channels,
  1005. * their type, and width. This exists so that the GPU backend can have private types that have no
  1006. * analog in the public facing SkColorType enum and omit types not implemented in the GPU backend.
  1007. * It does not refer to a texture format and the mapping to texture formats may be many-to-many.
  1008. * It does not specify the sRGB encoding of the stored values. The components are listed in order of
  1009. * where they appear in memory. In other words the first component listed is in the low bits and
  1010. * the last component in the high bits.
  1011. */
  1012. enum class GrColorType {
  1013. kUnknown,
  1014. kAlpha_8,
  1015. kBGR_565,
  1016. kABGR_4444, // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed.
  1017. kRGBA_8888,
  1018. kRGBA_8888_SRGB,
  1019. kRGB_888x,
  1020. kRG_88,
  1021. kBGRA_8888,
  1022. kRGBA_1010102,
  1023. kGray_8,
  1024. kAlpha_F16,
  1025. kRGBA_F16,
  1026. kRGBA_F16_Clamped,
  1027. kRGBA_F32,
  1028. kR_16, // Not in SkColorType
  1029. kRG_1616, // Not in SkColorType
  1030. // Experimental (for Y416 and mutant P016/P010)
  1031. kRGBA_16161616, // Not in SkColorType
  1032. kRG_F16, // Not in SkColorType
  1033. kLast = kRG_F16
  1034. };
  1035. static const int kGrColorTypeCnt = static_cast<int>(GrColorType::kLast) + 1;
  1036. static constexpr SkColorType GrColorTypeToSkColorType(GrColorType ct) {
  1037. switch (ct) {
  1038. case GrColorType::kUnknown: return kUnknown_SkColorType;
  1039. case GrColorType::kAlpha_8: return kAlpha_8_SkColorType;
  1040. case GrColorType::kBGR_565: return kRGB_565_SkColorType;
  1041. case GrColorType::kABGR_4444: return kARGB_4444_SkColorType;
  1042. case GrColorType::kRGBA_8888: return kRGBA_8888_SkColorType;
  1043. // Once we a kRGBA_8888_SRGB_SkColorType we should return that here.
  1044. case GrColorType::kRGBA_8888_SRGB: return kRGBA_8888_SkColorType;
  1045. case GrColorType::kRGB_888x: return kRGB_888x_SkColorType;
  1046. case GrColorType::kRG_88: return kUnknown_SkColorType;
  1047. case GrColorType::kBGRA_8888: return kBGRA_8888_SkColorType;
  1048. case GrColorType::kRGBA_1010102: return kRGBA_1010102_SkColorType;
  1049. case GrColorType::kGray_8: return kGray_8_SkColorType;
  1050. case GrColorType::kAlpha_F16: return kUnknown_SkColorType;
  1051. case GrColorType::kRGBA_F16: return kRGBA_F16_SkColorType;
  1052. case GrColorType::kRGBA_F16_Clamped: return kRGBA_F16Norm_SkColorType;
  1053. case GrColorType::kRGBA_F32: return kRGBA_F32_SkColorType;
  1054. case GrColorType::kR_16: return kUnknown_SkColorType;
  1055. case GrColorType::kRG_1616: return kUnknown_SkColorType;
  1056. // Experimental (for Y416 and mutant P016/P010)
  1057. case GrColorType::kRGBA_16161616: return kUnknown_SkColorType;
  1058. case GrColorType::kRG_F16: return kUnknown_SkColorType;
  1059. }
  1060. SkUNREACHABLE;
  1061. }
  1062. static constexpr GrColorType SkColorTypeToGrColorType(SkColorType ct) {
  1063. switch (ct) {
  1064. case kUnknown_SkColorType: return GrColorType::kUnknown;
  1065. case kAlpha_8_SkColorType: return GrColorType::kAlpha_8;
  1066. case kRGB_565_SkColorType: return GrColorType::kBGR_565;
  1067. case kARGB_4444_SkColorType: return GrColorType::kABGR_4444;
  1068. case kRGBA_8888_SkColorType: return GrColorType::kRGBA_8888;
  1069. case kRGB_888x_SkColorType: return GrColorType::kRGB_888x;
  1070. case kBGRA_8888_SkColorType: return GrColorType::kBGRA_8888;
  1071. case kGray_8_SkColorType: return GrColorType::kGray_8;
  1072. case kRGBA_F16Norm_SkColorType: return GrColorType::kRGBA_F16_Clamped;
  1073. case kRGBA_F16_SkColorType: return GrColorType::kRGBA_F16;
  1074. case kRGBA_1010102_SkColorType: return GrColorType::kRGBA_1010102;
  1075. case kRGB_101010x_SkColorType: return GrColorType::kUnknown;
  1076. case kRGBA_F32_SkColorType: return GrColorType::kRGBA_F32;
  1077. }
  1078. SkUNREACHABLE;
  1079. }
  1080. // This is a temporary means of mapping an SkColorType and format to a
  1081. // GrColorType::kRGBA_8888_SRGB. Once we have an SRGB SkColorType this can go away.
  1082. GrColorType SkColorTypeAndFormatToGrColorType(const GrCaps* caps,
  1083. SkColorType skCT,
  1084. const GrBackendFormat& format);
  1085. static constexpr uint32_t GrColorTypeComponentFlags(GrColorType ct) {
  1086. switch (ct) {
  1087. case GrColorType::kUnknown: return 0;
  1088. case GrColorType::kAlpha_8: return kAlpha_SkColorTypeComponentFlag;
  1089. case GrColorType::kBGR_565: return kRGB_SkColorTypeComponentFlags;
  1090. case GrColorType::kABGR_4444: return kRGBA_SkColorTypeComponentFlags;
  1091. case GrColorType::kRGBA_8888: return kRGBA_SkColorTypeComponentFlags;
  1092. case GrColorType::kRGBA_8888_SRGB: return kRGBA_SkColorTypeComponentFlags;
  1093. case GrColorType::kRGB_888x: return kRGB_SkColorTypeComponentFlags;
  1094. case GrColorType::kRG_88: return kRed_SkColorTypeComponentFlag |
  1095. kGreen_SkColorTypeComponentFlag;
  1096. case GrColorType::kBGRA_8888: return kRGBA_SkColorTypeComponentFlags;
  1097. case GrColorType::kRGBA_1010102: return kRGBA_SkColorTypeComponentFlags;
  1098. case GrColorType::kGray_8: return kGray_SkColorTypeComponentFlag;
  1099. case GrColorType::kAlpha_F16: return kAlpha_SkColorTypeComponentFlag;
  1100. case GrColorType::kRGBA_F16: return kRGBA_SkColorTypeComponentFlags;
  1101. case GrColorType::kRGBA_F16_Clamped: return kRGBA_SkColorTypeComponentFlags;
  1102. case GrColorType::kRGBA_F32: return kRGBA_SkColorTypeComponentFlags;
  1103. case GrColorType::kR_16: return kRed_SkColorTypeComponentFlag;
  1104. case GrColorType::kRG_1616: return kRed_SkColorTypeComponentFlag |
  1105. kGreen_SkColorTypeComponentFlag;
  1106. // Experimental (for Y416 and mutant P016/P010)
  1107. case GrColorType::kRGBA_16161616: return kRGBA_SkColorTypeComponentFlags;
  1108. case GrColorType::kRG_F16: return kRed_SkColorTypeComponentFlag |
  1109. kGreen_SkColorTypeComponentFlag;
  1110. }
  1111. SkUNREACHABLE;
  1112. }
  1113. /**
  1114. * Describes the encoding of channel data in a GrColorType.
  1115. */
  1116. enum class GrColorTypeEncoding {
  1117. kUnorm,
  1118. kSRGBUnorm,
  1119. // kSnorm,
  1120. kFloat,
  1121. // kSint
  1122. // kUint
  1123. };
  1124. /**
  1125. * Describes a GrColorType by how many bits are used for each color component and how they are
  1126. * encoded. Currently all the non-zero channels share a single GrColorTypeEncoding. This could be
  1127. * expanded to store separate encodings and to indicate which bits belong to which components.
  1128. */
  1129. struct GrColorTypeDesc {
  1130. public:
  1131. static constexpr GrColorTypeDesc MakeRGBA(int rgba, GrColorTypeEncoding e) {
  1132. return {rgba, rgba, rgba, rgba, 0, e};
  1133. }
  1134. static constexpr GrColorTypeDesc MakeRGBA(int rgb, int a, GrColorTypeEncoding e) {
  1135. return {rgb, rgb, rgb, a, 0, e};
  1136. }
  1137. static constexpr GrColorTypeDesc MakeRGB(int rgb, GrColorTypeEncoding e) {
  1138. return {rgb, rgb, rgb, 0, 0, e};
  1139. }
  1140. static constexpr GrColorTypeDesc MakeRGB(int r, int g, int b, GrColorTypeEncoding e) {
  1141. return {r, g, b, 0, 0, e};
  1142. }
  1143. static constexpr GrColorTypeDesc MakeAlpha(int a, GrColorTypeEncoding e) {
  1144. return {0, 0, 0, a, 0, e};
  1145. }
  1146. static constexpr GrColorTypeDesc MakeR(int r, GrColorTypeEncoding e) {
  1147. return {r, 0, 0, 0, 0, e};
  1148. }
  1149. static constexpr GrColorTypeDesc MakeRG(int rg, GrColorTypeEncoding e) {
  1150. return {rg, rg, 0, 0, 0, e};
  1151. }
  1152. static constexpr GrColorTypeDesc MakeGray(int grayBits, GrColorTypeEncoding e) {
  1153. return {0, 0, 0, 0, grayBits, e};
  1154. }
  1155. static constexpr GrColorTypeDesc MakeInvalid() { return {}; }
  1156. constexpr int r() const { return fRBits; }
  1157. constexpr int g() const { return fGBits; }
  1158. constexpr int b() const { return fBBits; }
  1159. constexpr int a() const { return fABits; }
  1160. constexpr int gray() const { return fGrayBits; }
  1161. constexpr GrColorTypeEncoding encoding() const { return fEncoding; }
  1162. private:
  1163. int fRBits = 0;
  1164. int fGBits = 0;
  1165. int fBBits = 0;
  1166. int fABits = 0;
  1167. int fGrayBits = 0;
  1168. GrColorTypeEncoding fEncoding = GrColorTypeEncoding::kUnorm;
  1169. constexpr GrColorTypeDesc() = default;
  1170. constexpr GrColorTypeDesc(int r, int g, int b, int a, int gray, GrColorTypeEncoding encoding)
  1171. : fRBits(r), fGBits(g), fBBits(b), fABits(a), fGrayBits(gray), fEncoding(encoding) {
  1172. SkASSERT(r >= 0 && g >= 0 && b >= 0 && a >= 0 && gray >= 0);
  1173. SkASSERT(!gray || (!r && !g && !b));
  1174. SkASSERT(r || g || b || a || gray);
  1175. }
  1176. };
  1177. static constexpr GrColorTypeDesc GrGetColorTypeDesc(GrColorType ct) {
  1178. switch (ct) {
  1179. case GrColorType::kUnknown:
  1180. return GrColorTypeDesc::MakeInvalid();
  1181. case GrColorType::kAlpha_8:
  1182. return GrColorTypeDesc::MakeAlpha(8, GrColorTypeEncoding::kUnorm);
  1183. case GrColorType::kBGR_565:
  1184. return GrColorTypeDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
  1185. case GrColorType::kABGR_4444:
  1186. return GrColorTypeDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
  1187. case GrColorType::kRGBA_8888:
  1188. return GrColorTypeDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
  1189. case GrColorType::kRGBA_8888_SRGB:
  1190. return GrColorTypeDesc::MakeRGBA(8, GrColorTypeEncoding::kSRGBUnorm);
  1191. case GrColorType::kRGB_888x:
  1192. return GrColorTypeDesc::MakeRGB(8, GrColorTypeEncoding::kUnorm);
  1193. case GrColorType::kRG_88:
  1194. return GrColorTypeDesc::MakeRG(8, GrColorTypeEncoding::kUnorm);
  1195. case GrColorType::kBGRA_8888:
  1196. return GrColorTypeDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
  1197. case GrColorType::kRGBA_1010102:
  1198. return GrColorTypeDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
  1199. case GrColorType::kGray_8:
  1200. return GrColorTypeDesc::MakeGray(8, GrColorTypeEncoding::kUnorm);
  1201. case GrColorType::kAlpha_F16:
  1202. return GrColorTypeDesc::MakeAlpha(16, GrColorTypeEncoding::kFloat);
  1203. case GrColorType::kRGBA_F16:
  1204. return GrColorTypeDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
  1205. case GrColorType::kRGBA_F16_Clamped:
  1206. return GrColorTypeDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
  1207. case GrColorType::kRGBA_F32:
  1208. return GrColorTypeDesc::MakeRGBA(32, GrColorTypeEncoding::kFloat);
  1209. case GrColorType::kR_16:
  1210. return GrColorTypeDesc::MakeR(16, GrColorTypeEncoding::kUnorm);
  1211. case GrColorType::kRG_1616:
  1212. return GrColorTypeDesc::MakeRG(16, GrColorTypeEncoding::kUnorm);
  1213. case GrColorType::kRGBA_16161616:
  1214. return GrColorTypeDesc::MakeRGBA(16, GrColorTypeEncoding::kUnorm);
  1215. case GrColorType::kRG_F16:
  1216. return GrColorTypeDesc::MakeRG(16, GrColorTypeEncoding::kFloat);
  1217. }
  1218. SkUNREACHABLE;
  1219. }
  1220. static constexpr GrClampType GrColorTypeClampType(GrColorType colorType) {
  1221. if (GrGetColorTypeDesc(colorType).encoding() == GrColorTypeEncoding::kUnorm ||
  1222. GrGetColorTypeDesc(colorType).encoding() == GrColorTypeEncoding::kSRGBUnorm) {
  1223. return GrClampType::kAuto;
  1224. }
  1225. return GrColorType::kRGBA_F16_Clamped == colorType ? GrClampType::kManual : GrClampType::kNone;
  1226. }
  1227. // Consider a color type "wider" than n if it has more than n bits for any its representable
  1228. // channels.
  1229. static constexpr bool GrColorTypeIsWiderThan(GrColorType colorType, int n) {
  1230. SkASSERT(n > 0);
  1231. auto desc = GrGetColorTypeDesc(colorType);
  1232. return (desc.r() && desc.r() > n )||
  1233. (desc.g() && desc.g() > n) ||
  1234. (desc.b() && desc.b() > n) ||
  1235. (desc.a() && desc.a() > n) ||
  1236. (desc.gray() && desc.gray() > n);
  1237. }
  1238. static constexpr bool GrColorTypeIsAlphaOnly(GrColorType ct) {
  1239. return kAlpha_SkColorTypeComponentFlag == GrColorTypeComponentFlags(ct);
  1240. }
  1241. static constexpr bool GrColorTypeHasAlpha(GrColorType ct) {
  1242. return kAlpha_SkColorTypeComponentFlag & GrColorTypeComponentFlags(ct);
  1243. }
  1244. static constexpr int GrColorTypeBytesPerPixel(GrColorType ct) {
  1245. switch (ct) {
  1246. case GrColorType::kUnknown: return 0;
  1247. case GrColorType::kAlpha_8: return 1;
  1248. case GrColorType::kBGR_565: return 2;
  1249. case GrColorType::kABGR_4444: return 2;
  1250. case GrColorType::kRGBA_8888: return 4;
  1251. case GrColorType::kRGBA_8888_SRGB: return 4;
  1252. case GrColorType::kRGB_888x: return 4;
  1253. case GrColorType::kRG_88: return 2;
  1254. case GrColorType::kBGRA_8888: return 4;
  1255. case GrColorType::kRGBA_1010102: return 4;
  1256. case GrColorType::kGray_8: return 1;
  1257. case GrColorType::kAlpha_F16: return 2;
  1258. case GrColorType::kRGBA_F16: return 8;
  1259. case GrColorType::kRGBA_F16_Clamped: return 8;
  1260. case GrColorType::kRGBA_F32: return 16;
  1261. case GrColorType::kR_16: return 2;
  1262. case GrColorType::kRG_1616: return 4;
  1263. // Experimental (for Y416 and mutant P016/P010)
  1264. case GrColorType::kRGBA_16161616: return 8;
  1265. case GrColorType::kRG_F16: return 4;
  1266. }
  1267. SkUNREACHABLE;
  1268. }
  1269. // We may need a roughly equivalent color type for a compressed texture. This should be the logical
  1270. // format for decompressing the data into.
  1271. static constexpr GrColorType GrCompressionTypeClosestColorType(
  1272. SkImage::CompressionType type) {
  1273. switch (type) {
  1274. case SkImage::CompressionType::kETC1_CompressionType: return GrColorType::kRGB_888x;
  1275. }
  1276. SkUNREACHABLE;
  1277. }
  1278. static constexpr GrColorType GrPixelConfigToColorType(GrPixelConfig config) {
  1279. switch (config) {
  1280. case kUnknown_GrPixelConfig:
  1281. return GrColorType::kUnknown;
  1282. case kAlpha_8_GrPixelConfig:
  1283. return GrColorType::kAlpha_8;
  1284. case kGray_8_GrPixelConfig:
  1285. return GrColorType::kGray_8;
  1286. case kRGB_565_GrPixelConfig:
  1287. return GrColorType::kBGR_565;
  1288. case kRGBA_4444_GrPixelConfig:
  1289. return GrColorType::kABGR_4444;
  1290. case kRGBA_8888_GrPixelConfig:
  1291. return GrColorType::kRGBA_8888;
  1292. case kRGB_888_GrPixelConfig:
  1293. return GrColorType::kRGB_888x;
  1294. case kRGB_888X_GrPixelConfig:
  1295. return GrColorType::kRGB_888x;
  1296. case kRG_88_GrPixelConfig:
  1297. return GrColorType::kRG_88;
  1298. case kBGRA_8888_GrPixelConfig:
  1299. return GrColorType::kBGRA_8888;
  1300. case kSRGBA_8888_GrPixelConfig:
  1301. return GrColorType::kRGBA_8888_SRGB;
  1302. case kRGBA_1010102_GrPixelConfig:
  1303. return GrColorType::kRGBA_1010102;
  1304. case kRGBA_float_GrPixelConfig:
  1305. return GrColorType::kRGBA_F32;
  1306. case kAlpha_half_GrPixelConfig:
  1307. return GrColorType::kAlpha_F16;
  1308. case kRGBA_half_GrPixelConfig:
  1309. return GrColorType::kRGBA_F16;
  1310. case kRGBA_half_Clamped_GrPixelConfig:
  1311. return GrColorType::kRGBA_F16_Clamped;
  1312. case kRGB_ETC1_GrPixelConfig:
  1313. return GrCompressionTypeClosestColorType(SkImage::kETC1_CompressionType);
  1314. case kAlpha_8_as_Alpha_GrPixelConfig:
  1315. return GrColorType::kAlpha_8;
  1316. case kAlpha_8_as_Red_GrPixelConfig:
  1317. return GrColorType::kAlpha_8;
  1318. case kAlpha_half_as_Lum_GrPixelConfig: // fall through
  1319. case kAlpha_half_as_Red_GrPixelConfig:
  1320. return GrColorType::kAlpha_F16;
  1321. case kGray_8_as_Lum_GrPixelConfig:
  1322. return GrColorType::kGray_8;
  1323. case kGray_8_as_Red_GrPixelConfig:
  1324. return GrColorType::kGray_8;
  1325. case kR_16_GrPixelConfig:
  1326. return GrColorType::kR_16;
  1327. case kRG_1616_GrPixelConfig:
  1328. return GrColorType::kRG_1616;
  1329. // Experimental (for Y416 and mutant P016/P010)
  1330. case kRGBA_16161616_GrPixelConfig:
  1331. return GrColorType::kRGBA_16161616;
  1332. case kRG_half_GrPixelConfig:
  1333. return GrColorType::kRG_F16;
  1334. }
  1335. SkUNREACHABLE;
  1336. }
  1337. static constexpr GrPixelConfig GrColorTypeToPixelConfig(GrColorType colorType) {
  1338. switch (colorType) {
  1339. case GrColorType::kUnknown: return kUnknown_GrPixelConfig;
  1340. case GrColorType::kAlpha_8: return kAlpha_8_GrPixelConfig;
  1341. case GrColorType::kGray_8: return kGray_8_GrPixelConfig;
  1342. case GrColorType::kBGR_565: return kRGB_565_GrPixelConfig;
  1343. case GrColorType::kABGR_4444: return kRGBA_4444_GrPixelConfig;
  1344. case GrColorType::kRGBA_8888: return kRGBA_8888_GrPixelConfig;
  1345. case GrColorType::kRGBA_8888_SRGB: return kSRGBA_8888_GrPixelConfig;
  1346. case GrColorType::kRGB_888x: return kRGB_888_GrPixelConfig;
  1347. case GrColorType::kRG_88: return kRG_88_GrPixelConfig;
  1348. case GrColorType::kBGRA_8888: return kBGRA_8888_GrPixelConfig;
  1349. case GrColorType::kRGBA_1010102: return kRGBA_1010102_GrPixelConfig;
  1350. case GrColorType::kRGBA_F32: return kRGBA_float_GrPixelConfig;
  1351. case GrColorType::kAlpha_F16: return kAlpha_half_GrPixelConfig;
  1352. case GrColorType::kRGBA_F16: return kRGBA_half_GrPixelConfig;
  1353. case GrColorType::kRGBA_F16_Clamped: return kRGBA_half_Clamped_GrPixelConfig;
  1354. case GrColorType::kR_16: return kR_16_GrPixelConfig;
  1355. case GrColorType::kRG_1616: return kRG_1616_GrPixelConfig;
  1356. // Experimental (for Y416 and mutant P016/P010)
  1357. case GrColorType::kRGBA_16161616: return kRGBA_16161616_GrPixelConfig;
  1358. case GrColorType::kRG_F16: return kRG_half_GrPixelConfig;
  1359. }
  1360. SkUNREACHABLE;
  1361. }
  1362. /**
  1363. * Ref-counted object that calls a callback from its destructor.
  1364. */
  1365. class GrRefCntedCallback : public SkRefCnt {
  1366. public:
  1367. using Context = void*;
  1368. using Callback = void (*)(Context);
  1369. GrRefCntedCallback(Callback proc, Context ctx) : fReleaseProc(proc), fReleaseCtx(ctx) {
  1370. SkASSERT(proc);
  1371. }
  1372. ~GrRefCntedCallback() override { fReleaseProc ? fReleaseProc(fReleaseCtx) : void(); }
  1373. Context context() const { return fReleaseCtx; }
  1374. private:
  1375. Callback fReleaseProc;
  1376. Context fReleaseCtx;
  1377. };
  1378. #endif