include/gpu/GrTypesPriv.h

   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
   8 #ifndef GrTypesPriv_DEFINED
   9 #define GrTypesPriv_DEFINED
  10
  11 #include <chrono>
  12 #include "GrTypes.h"
  13 #include "SkRefCnt.h"
  14
  15 // The old libstdc++ uses the draft name "monotonic_clock" rather than "steady_clock". This might
  16 // not actually be monotonic, depending on how libstdc++ was built. However, this is only currently
  17 // used for idle resource purging so it shouldn't cause a correctness problem.
  18 #if defined(__GLIBCXX__) && (__GLIBCXX__ < 20130000)
  19 using GrStdSteadyClock = std::chrono::monotonic_clock;
  20 #else
  21 using GrStdSteadyClock = std::chrono::steady_clock;
  22 #endif
  23
  24 /** This enum indicates the type of antialiasing to be performed. */
  25 enum class GrAAType : unsigned {
  26     /** No antialiasing */
  27     kNone,
  28     /** Use fragment shader code to compute a fractional pixel coverage. */
  29     kCoverage,
  30     /** Use normal MSAA. */
  31     kMSAA,
  32     /**
  33      * Use "mixed samples" MSAA such that the stencil buffer is multisampled but the color buffer is
  34      * not.
  35      */
  36     kMixedSamples
  37 };
  38
  39 static inline bool GrAATypeIsHW(GrAAType type) {
  40     switch (type) {
  41         case GrAAType::kNone:
  42             return false;
  43         case GrAAType::kCoverage:
  44             return false;
  45         case GrAAType::kMSAA:
  46             return true;
  47         case GrAAType::kMixedSamples:
  48             return true;
  49     }
  50     SkFAIL("Unknown AA Type");
  51     return false;
  52 }
  53
  54 /**
  55  * Types of shader-language-specific boxed variables we can create. (Currently only GrGLShaderVars,
  56  * but should be applicable to other shader languages.)
  57  */
  58 enum GrSLType {
  59     kVoid_GrSLType,
  60     kBool_GrSLType,
  61     kInt_GrSLType,
  62     kUint_GrSLType,
  63     kFloat_GrSLType,
  64     kVec2f_GrSLType,
  65     kVec3f_GrSLType,
  66     kVec4f_GrSLType,
  67     kVec2i_GrSLType,
  68     kVec3i_GrSLType,
  69     kVec4i_GrSLType,
  70     kMat22f_GrSLType,
  71     kMat33f_GrSLType,
  72     kMat44f_GrSLType,
  73     kTexture2DSampler_GrSLType,
  74     kITexture2DSampler_GrSLType,
  75     kTextureExternalSampler_GrSLType,
  76     kTexture2DRectSampler_GrSLType,
  77     kBufferSampler_GrSLType,
  78     kTexture2D_GrSLType,
  79     kSampler_GrSLType,
  80     kImageStorage2D_GrSLType,
  81     kIImageStorage2D_GrSLType,
  82 };
  83
  84 enum GrShaderType {
  85     kVertex_GrShaderType,
  86     kGeometry_GrShaderType,
  87     kFragment_GrShaderType,
  88
  89     kLastkFragment_GrShaderType = kFragment_GrShaderType
  90 };
  91 static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1;
  92
  93 enum GrShaderFlags {
  94     kNone_GrShaderFlags = 0,
  95     kVertex_GrShaderFlag = 1 << kVertex_GrShaderType,
  96     kGeometry_GrShaderFlag = 1 << kGeometry_GrShaderType,
  97     kFragment_GrShaderFlag = 1 << kFragment_GrShaderType
  98 };
  99 GR_MAKE_BITFIELD_OPS(GrShaderFlags);
 100
 101 enum class GrDrawFace {
 102     kInvalid = -1,
 103
 104     kBoth,
 105     kCCW,
 106     kCW,
 107 };
 108
 109 /**
 110  * Precisions of shader language variables. Not all shading languages support precisions or actually
 111  * vary the internal precision based on the qualifiers. These currently only apply to float types (
 112  * including float vectors and matrices).
 113  */
 114 enum GrSLPrecision {
 115     kLow_GrSLPrecision,
 116     kMedium_GrSLPrecision,
 117     kHigh_GrSLPrecision,
 118
 119     // Default precision is medium. This is because on OpenGL ES 2 highp support is not
 120     // guaranteed. On (non-ES) OpenGL the specifiers have no effect on precision.
 121     kDefault_GrSLPrecision = kMedium_GrSLPrecision,
 122
 123     kLast_GrSLPrecision = kHigh_GrSLPrecision
 124 };
 125
 126 static const int kGrSLPrecisionCount = kLast_GrSLPrecision + 1;
 127
 128 /** Is the shading language type float (including vectors/matrices)? */
 129 static inline bool GrSLTypeIsFloatType(GrSLType type) {
 130     switch (type) {
 131         case kFloat_GrSLType:
 132         case kVec2f_GrSLType:
 133         case kVec3f_GrSLType:
 134         case kVec4f_GrSLType:
 135         case kMat22f_GrSLType:
 136         case kMat33f_GrSLType:
 137         case kMat44f_GrSLType:
 138             return true;
 139
 140         case kVoid_GrSLType:
 141         case kTexture2DSampler_GrSLType:
 142         case kITexture2DSampler_GrSLType:
 143         case kTextureExternalSampler_GrSLType:
 144         case kTexture2DRectSampler_GrSLType:
 145         case kBufferSampler_GrSLType:
 146         case kBool_GrSLType:
 147         case kInt_GrSLType:
 148         case kUint_GrSLType:
 149         case kVec2i_GrSLType:
 150         case kVec3i_GrSLType:
 151         case kVec4i_GrSLType:
 152         case kTexture2D_GrSLType:
 153         case kSampler_GrSLType:
 154         case kImageStorage2D_GrSLType:
 155         case kIImageStorage2D_GrSLType:
 156             return false;
 157     }
 158     SkFAIL("Unexpected type");
 159     return false;
 160 }
 161
 162 static inline bool GrSLTypeIs2DCombinedSamplerType(GrSLType type) {
 163     switch (type) {
 164         case kTexture2DSampler_GrSLType:
 165         case kITexture2DSampler_GrSLType:
 166         case kTextureExternalSampler_GrSLType:
 167         case kTexture2DRectSampler_GrSLType:
 168             return true;
 169
 170         case kVoid_GrSLType:
 171         case kFloat_GrSLType:
 172         case kVec2f_GrSLType:
 173         case kVec3f_GrSLType:
 174         case kVec4f_GrSLType:
 175         case kVec2i_GrSLType:
 176         case kVec3i_GrSLType:
 177         case kVec4i_GrSLType:
 178         case kMat22f_GrSLType:
 179         case kMat33f_GrSLType:
 180         case kMat44f_GrSLType:
 181         case kBufferSampler_GrSLType:
 182         case kInt_GrSLType:
 183         case kUint_GrSLType:
 184         case kBool_GrSLType:
 185         case kTexture2D_GrSLType:
 186         case kSampler_GrSLType:
 187         case kImageStorage2D_GrSLType:
 188         case kIImageStorage2D_GrSLType:
 189             return false;
 190     }
 191     SkFAIL("Unexpected type");
 192     return false;
 193 }
 194
 195 static inline bool GrSLTypeIsCombinedSamplerType(GrSLType type) {
 196     switch (type) {
 197         case kTexture2DSampler_GrSLType:
 198         case kITexture2DSampler_GrSLType:
 199         case kTextureExternalSampler_GrSLType:
 200         case kTexture2DRectSampler_GrSLType:
 201         case kBufferSampler_GrSLType:
 202             return true;
 203
 204         case kVoid_GrSLType:
 205         case kFloat_GrSLType:
 206         case kVec2f_GrSLType:
 207         case kVec3f_GrSLType:
 208         case kVec4f_GrSLType:
 209         case kVec2i_GrSLType:
 210         case kVec3i_GrSLType:
 211         case kVec4i_GrSLType:
 212         case kMat22f_GrSLType:
 213         case kMat33f_GrSLType:
 214         case kMat44f_GrSLType:
 215         case kInt_GrSLType:
 216         case kUint_GrSLType:
 217         case kBool_GrSLType:
 218         case kTexture2D_GrSLType:
 219         case kSampler_GrSLType:
 220         case kImageStorage2D_GrSLType:
 221         case kIImageStorage2D_GrSLType:
 222             return false;
 223     }
 224     SkFAIL("Unexpected type");
 225     return false;
 226 }
 227
 228 static inline bool GrSLTypeIsImageStorage(GrSLType type) {
 229     switch (type) {
 230         case kImageStorage2D_GrSLType:
 231         case kIImageStorage2D_GrSLType:
 232             return true;
 233
 234         case kVoid_GrSLType:
 235         case kFloat_GrSLType:
 236         case kVec2f_GrSLType:
 237         case kVec3f_GrSLType:
 238         case kVec4f_GrSLType:
 239         case kVec2i_GrSLType:
 240         case kVec3i_GrSLType:
 241         case kVec4i_GrSLType:
 242         case kMat22f_GrSLType:
 243         case kMat33f_GrSLType:
 244         case kMat44f_GrSLType:
 245         case kInt_GrSLType:
 246         case kUint_GrSLType:
 247         case kBool_GrSLType:
 248         case kTexture2D_GrSLType:
 249         case kSampler_GrSLType:
 250         case kTexture2DSampler_GrSLType:
 251         case kITexture2DSampler_GrSLType:
 252         case kTextureExternalSampler_GrSLType:
 253         case kTexture2DRectSampler_GrSLType:
 254         case kBufferSampler_GrSLType:
 255             return false;
 256     }
 257     SkFAIL("Unexpected type");
 258     return false;
 259 }
 260
 261 static inline bool GrSLTypeAcceptsPrecision(GrSLType type) {
 262     switch (type) {
 263         case kInt_GrSLType:
 264         case kUint_GrSLType:
 265         case kFloat_GrSLType:
 266         case kVec2f_GrSLType:
 267         case kVec3f_GrSLType:
 268         case kVec4f_GrSLType:
 269         case kVec2i_GrSLType:
 270         case kVec3i_GrSLType:
 271         case kVec4i_GrSLType:
 272         case kMat22f_GrSLType:
 273         case kMat33f_GrSLType:
 274         case kMat44f_GrSLType:
 275         case kTexture2DSampler_GrSLType:
 276         case kITexture2DSampler_GrSLType:
 277         case kTextureExternalSampler_GrSLType:
 278         case kTexture2DRectSampler_GrSLType:
 279         case kBufferSampler_GrSLType:
 280         case kTexture2D_GrSLType:
 281         case kSampler_GrSLType:
 282         case kImageStorage2D_GrSLType:
 283         case kIImageStorage2D_GrSLType:
 284             return true;
 285
 286         case kVoid_GrSLType:
 287         case kBool_GrSLType:
 288             return false;
 289     }
 290     SkFAIL("Unexpected type");
 291     return false;
 292 }
 293
 294 //////////////////////////////////////////////////////////////////////////////
 295
 296 /**
 297  * Types used to describe format of vertices in arrays.
 298   */
 299 enum GrVertexAttribType {
 300     kFloat_GrVertexAttribType = 0,
 301     kVec2f_GrVertexAttribType,
 302     kVec3f_GrVertexAttribType,
 303     kVec4f_GrVertexAttribType,
 304
 305     kVec2i_GrVertexAttribType,   // vector of 2 32-bit ints
 306     kVec3i_GrVertexAttribType,   // vector of 3 32-bit ints
 307     kVec4i_GrVertexAttribType,   // vector of 4 32-bit ints
 308
 309     kUByte_GrVertexAttribType,   // unsigned byte, e.g. coverage
 310     kVec4ub_GrVertexAttribType,  // vector of 4 unsigned bytes, e.g. colors
 311
 312     kVec2us_GrVertexAttribType,   // vector of 2 shorts, e.g. texture coordinates
 313
 314     kInt_GrVertexAttribType,
 315     kUint_GrVertexAttribType,
 316
 317     kLast_GrVertexAttribType = kUint_GrVertexAttribType
 318 };
 319 static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1;
 320
 321
 322 /**
 323  * Returns the size of the attrib type in bytes.
 324  */
 325 static inline size_t GrVertexAttribTypeSize(GrVertexAttribType type) {
 326     switch (type) {
 327         case kFloat_GrVertexAttribType:
 328             return sizeof(float);
 329         case kVec2f_GrVertexAttribType:
 330             return 2*sizeof(float);
 331         case kVec3f_GrVertexAttribType:
 332             return 3*sizeof(float);
 333         case kVec4f_GrVertexAttribType:
 334             return 4*sizeof(float);
 335         case kVec2i_GrVertexAttribType:
 336             return 2*sizeof(int32_t);
 337         case kVec3i_GrVertexAttribType:
 338             return 3*sizeof(int32_t);
 339         case kVec4i_GrVertexAttribType:
 340             return 4*sizeof(int32_t);
 341         case kUByte_GrVertexAttribType:
 342             return 1*sizeof(char);
 343         case kVec4ub_GrVertexAttribType:
 344             return 4*sizeof(char);
 345         case kVec2us_GrVertexAttribType:
 346             return 2*sizeof(int16_t);
 347         case kInt_GrVertexAttribType:
 348             return sizeof(int32_t);
 349         case kUint_GrVertexAttribType:
 350             return sizeof(uint32_t);
 351     }
 352     SkFAIL("Unexpected attribute type");
 353     return 0;
 354 }
 355
 356 /**
 357  * Is the attrib type integral?
 358  */
 359 static inline bool GrVertexAttribTypeIsIntType(GrVertexAttribType type) {
 360     switch (type) {
 361         case kFloat_GrVertexAttribType:
 362             return false;
 363         case kVec2f_GrVertexAttribType:
 364             return false;
 365         case kVec3f_GrVertexAttribType:
 366             return false;
 367         case kVec4f_GrVertexAttribType:
 368             return false;
 369         case kVec2i_GrVertexAttribType:
 370             return true;
 371         case kVec3i_GrVertexAttribType:
 372             return true;
 373         case kVec4i_GrVertexAttribType:
 374             return true;
 375         case kUByte_GrVertexAttribType:
 376             return false;
 377         case kVec4ub_GrVertexAttribType:
 378             return false;
 379         case kVec2us_GrVertexAttribType:
 380             return false;
 381         case kInt_GrVertexAttribType:
 382             return true;
 383         case kUint_GrVertexAttribType:
 384             return true;
 385     }
 386     SkFAIL("Unexpected attribute type");
 387     return false;
 388 }
 389
 390 /**
 391  * converts a GrVertexAttribType to a GrSLType
 392  */
 393 static inline GrSLType GrVertexAttribTypeToSLType(GrVertexAttribType type) {
 394     switch (type) {
 395         case kUByte_GrVertexAttribType:
 396         case kFloat_GrVertexAttribType:
 397             return kFloat_GrSLType;
 398         case kVec2us_GrVertexAttribType:
 399         case kVec2f_GrVertexAttribType:
 400             return kVec2f_GrSLType;
 401         case kVec3f_GrVertexAttribType:
 402             return kVec3f_GrSLType;
 403         case kVec4ub_GrVertexAttribType:
 404         case kVec4f_GrVertexAttribType:
 405             return kVec4f_GrSLType;
 406         case kVec2i_GrVertexAttribType:
 407             return kVec2i_GrSLType;
 408         case kVec3i_GrVertexAttribType:
 409             return kVec3i_GrSLType;
 410         case kVec4i_GrVertexAttribType:
 411             return kVec4i_GrSLType;
 412         case kInt_GrVertexAttribType:
 413             return kInt_GrSLType;
 414         case kUint_GrVertexAttribType:
 415             return kUint_GrSLType;
 416     }
 417     SkFAIL("Unsupported type conversion");
 418     return kVoid_GrSLType;
 419 }
 420
 421 //////////////////////////////////////////////////////////////////////////////
 422
 423 enum class GrImageStorageFormat {
 424     kRGBA8,
 425     kRGBA8i,
 426     kRGBA16f,
 427     kRGBA32f,
 428 };
 429
 430 /**
 431  * Describes types of caching and compiler optimizations allowed for certain variable types
 432  * (currently only image storages).
 433  **/
 434 enum class GrSLMemoryModel {
 435     /** No special restrctions on memory accesses or compiler optimizations */
 436     kNone,
 437     /** Cache coherent across shader invocations */
 438     kCoherent,
 439     /**
 440      * Disallows compiler from eliding loads or stores that appear redundant in a single
 441      * invocation. Implies coherent.
 442      */
 443     kVolatile
 444 };
 445
 446 /**
 447  * If kYes then the memory backing the varialble is only accessed via the variable. This is
 448  * currently only used with image storages.
 449  */
 450 enum class GrSLRestrict {
 451     kYes,
 452     kNo,
 453 };
 454
 455 //////////////////////////////////////////////////////////////////////////////
 456
 457 /**
 458 * We have coverage effects that clip rendering to the edge of some geometric primitive.
 459 * This enum specifies how that clipping is performed. Not all factories that take a
 460 * GrProcessorEdgeType will succeed with all values and it is up to the caller to check for
 461 * a NULL return.
 462 */
 463 enum GrPrimitiveEdgeType {
 464     kFillBW_GrProcessorEdgeType,
 465     kFillAA_GrProcessorEdgeType,
 466     kInverseFillBW_GrProcessorEdgeType,
 467     kInverseFillAA_GrProcessorEdgeType,
 468     kHairlineAA_GrProcessorEdgeType,
 469
 470     kLast_GrProcessorEdgeType = kHairlineAA_GrProcessorEdgeType
 471 };
 472
 473 static const int kGrProcessorEdgeTypeCnt = kLast_GrProcessorEdgeType + 1;
 474
 475 static inline bool GrProcessorEdgeTypeIsFill(const GrPrimitiveEdgeType edgeType) {
 476     return (kFillAA_GrProcessorEdgeType == edgeType || kFillBW_GrProcessorEdgeType == edgeType);
 477 }
 478
 479 static inline bool GrProcessorEdgeTypeIsInverseFill(const GrPrimitiveEdgeType edgeType) {
 480     return (kInverseFillAA_GrProcessorEdgeType == edgeType ||
 481             kInverseFillBW_GrProcessorEdgeType == edgeType);
 482 }
 483
 484 static inline bool GrProcessorEdgeTypeIsAA(const GrPrimitiveEdgeType edgeType) {
 485     return (kFillBW_GrProcessorEdgeType != edgeType && kInverseFillBW_GrProcessorEdgeType != edgeType);
 486 }
 487
 488 static inline GrPrimitiveEdgeType GrInvertProcessorEdgeType(const GrPrimitiveEdgeType edgeType) {
 489     switch (edgeType) {
 490         case kFillBW_GrProcessorEdgeType:
 491             return kInverseFillBW_GrProcessorEdgeType;
 492         case kFillAA_GrProcessorEdgeType:
 493             return kInverseFillAA_GrProcessorEdgeType;
 494         case kInverseFillBW_GrProcessorEdgeType:
 495             return kFillBW_GrProcessorEdgeType;
 496         case kInverseFillAA_GrProcessorEdgeType:
 497             return kFillAA_GrProcessorEdgeType;
 498         case kHairlineAA_GrProcessorEdgeType:
 499             SkFAIL("Hairline fill isn't invertible.");
 500     }
 501     return kFillAA_GrProcessorEdgeType; // suppress warning.
 502 }
 503
 504 /**
 505  * Indicates the type of pending IO operations that can be recorded for gpu resources.
 506  */
 507 enum GrIOType {
 508     kRead_GrIOType,
 509     kWrite_GrIOType,
 510     kRW_GrIOType
 511 };
 512
 513 /**
 514 * Indicates the type of data that a GPU buffer will be used for.
 515 */
 516 enum GrBufferType {
 517     kVertex_GrBufferType,
 518     kIndex_GrBufferType,
 519     kTexel_GrBufferType,
 520     kDrawIndirect_GrBufferType,
 521     kXferCpuToGpu_GrBufferType,
 522     kXferGpuToCpu_GrBufferType,
 523
 524     kLast_GrBufferType = kXferGpuToCpu_GrBufferType
 525 };
 526 static const int kGrBufferTypeCount = kLast_GrBufferType + 1;
 527
 528 static inline bool GrBufferTypeIsVertexOrIndex(GrBufferType type) {
 529     SkASSERT(type >= 0 && type < kGrBufferTypeCount);
 530     return type <= kIndex_GrBufferType;
 531
 532     GR_STATIC_ASSERT(0 == kVertex_GrBufferType);
 533     GR_STATIC_ASSERT(1 == kIndex_GrBufferType);
 534 }
 535
 536 /**
 537 * Provides a performance hint regarding the frequency at which a data store will be accessed.
 538 */
 539 enum GrAccessPattern {
 540     /** Data store will be respecified repeatedly and used many times. */
 541     kDynamic_GrAccessPattern,
 542     /** Data store will be specified once and used many times. (Thus disqualified from caching.) */
 543     kStatic_GrAccessPattern,
 544     /** Data store will be specified once and used at most a few times. (Also can't be cached.) */
 545     kStream_GrAccessPattern,
 546
 547     kLast_GrAccessPattern = kStream_GrAccessPattern
 548 };
 549
 550
 551 #ifdef SK_DEBUG
 552 // Takes a pointer to a GrCaps, and will suppress prints if required
 553 #define GrCapsDebugf(caps, ...)         \
 554     if (!(caps)->suppressPrints()) {    \
 555         SkDebugf(__VA_ARGS__);          \
 556     }
 557 #else
 558 #define GrCapsDebugf(caps, ...)
 559 #endif
 560
 561 /**
 562  * Specifies if the holder owns the backend, OpenGL or Vulkan, object.
 563  */
 564 enum class GrBackendObjectOwnership : bool {
 565     /** Holder does not destroy the backend object. */
 566     kBorrowed = false,
 567     /** Holder destroys the backend object. */
 568     kOwned = true
 569 };
 570
 571 template <typename T> T * const * sk_sp_address_as_pointer_address(sk_sp<T> const * sp) {
 572     static_assert(sizeof(T*) == sizeof(sk_sp<T>), "sk_sp not expected size.");
 573     return reinterpret_cast<T * const *>(sp);
 574 }
 575
 576 /*
 577  * Object for CPU-GPU synchronization
 578  */
 579 typedef uint64_t GrFence;
 580
 581 #endif