GrGLUtil.h 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312
  1. /*
  2. * Copyright 2012 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 GrGLUtil_DEFINED
  8. #define GrGLUtil_DEFINED
  9. #include "include/gpu/gl/GrGLInterface.h"
  10. #include "include/private/GrTypesPriv.h"
  11. #include "src/gpu/GrDataUtils.h"
  12. #include "src/gpu/GrStencilSettings.h"
  13. #include "src/gpu/gl/GrGLDefines.h"
  14. class SkMatrix;
  15. ////////////////////////////////////////////////////////////////////////////////
  16. typedef uint32_t GrGLVersion;
  17. typedef uint32_t GrGLSLVersion;
  18. typedef uint64_t GrGLDriverVersion;
  19. #define GR_GL_VER(major, minor) ((static_cast<uint32_t>(major) << 16) | \
  20. static_cast<uint32_t>(minor))
  21. #define GR_GLSL_VER(major, minor) ((static_cast<uint32_t>(major) << 16) | \
  22. static_cast<uint32_t>(minor))
  23. #define GR_GL_DRIVER_VER(major, minor, point) ((static_cast<uint64_t>(major) << 32) | \
  24. (static_cast<uint64_t>(minor) << 16) | \
  25. static_cast<uint64_t>(point))
  26. #define GR_GL_INVALID_VER GR_GL_VER(0, 0)
  27. #define GR_GLSL_INVALID_VER GR_GLSL_VER(0, 0)
  28. #define GR_GL_DRIVER_UNKNOWN_VER GR_GL_DRIVER_VER(0, 0, 0)
  29. /**
  30. * The Vendor and Renderer enum values are lazily updated as required.
  31. */
  32. enum GrGLVendor {
  33. kARM_GrGLVendor,
  34. kGoogle_GrGLVendor,
  35. kImagination_GrGLVendor,
  36. kIntel_GrGLVendor,
  37. kQualcomm_GrGLVendor,
  38. kNVIDIA_GrGLVendor,
  39. kATI_GrGLVendor,
  40. kOther_GrGLVendor
  41. };
  42. enum GrGLRenderer {
  43. kTegra_PreK1_GrGLRenderer, // Legacy Tegra architecture (pre-K1).
  44. kTegra_GrGLRenderer, // Tegra with the same architecture as NVIDIA desktop GPUs (K1+).
  45. kPowerVR54x_GrGLRenderer,
  46. kPowerVRRogue_GrGLRenderer,
  47. kAdreno3xx_GrGLRenderer,
  48. kAdreno430_GrGLRenderer,
  49. kAdreno4xx_other_GrGLRenderer,
  50. kAdreno5xx_GrGLRenderer,
  51. kOSMesa_GrGLRenderer,
  52. kGoogleSwiftShader_GrGLRenderer,
  53. /** Intel GPU families, ordered by generation **/
  54. // 6th gen
  55. kIntelSandyBridge_GrGLRenderer,
  56. // 7th gen
  57. kIntelIvyBridge_GrGLRenderer,
  58. kIntelValleyView_GrGLRenderer, // aka BayTrail
  59. kIntelHaswell_GrGLRenderer,
  60. // 8th gen
  61. kIntelCherryView_GrGLRenderer, // aka Braswell
  62. kIntelBroadwell_GrGLRenderer,
  63. // 9th gen
  64. kIntelApolloLake_GrGLRenderer,
  65. kIntelSkyLake_GrGLRenderer,
  66. kIntelGeminiLake_GrGLRenderer,
  67. kIntelKabyLake_GrGLRenderer,
  68. kIntelCoffeeLake_GrGLRenderer,
  69. // 11th gen
  70. kIntelIceLake_GrGLRenderer,
  71. kGalliumLLVM_GrGLRenderer,
  72. kMali4xx_GrGLRenderer,
  73. /** T-6xx, T-7xx, or T-8xx */
  74. kMaliT_GrGLRenderer,
  75. kANGLE_GrGLRenderer,
  76. kAMDRadeonHD7xxx_GrGLRenderer, // AMD Radeon HD 7000 Series
  77. kAMDRadeonR9M4xx_GrGLRenderer, // AMD Radeon R9 M400 Series
  78. kOther_GrGLRenderer
  79. };
  80. enum GrGLDriver {
  81. kMesa_GrGLDriver,
  82. kChromium_GrGLDriver,
  83. kNVIDIA_GrGLDriver,
  84. kIntel_GrGLDriver,
  85. kANGLE_GrGLDriver,
  86. kSwiftShader_GrGLDriver,
  87. kQualcomm_GrGLDriver,
  88. kUnknown_GrGLDriver
  89. };
  90. enum class GrGLANGLEBackend {
  91. kUnknown,
  92. kD3D9,
  93. kD3D11,
  94. kOpenGL
  95. };
  96. enum class GrGLANGLEVendor {
  97. kUnknown,
  98. kIntel
  99. };
  100. enum class GrGLANGLERenderer {
  101. kUnknown,
  102. kSandyBridge,
  103. kIvyBridge,
  104. kSkylake
  105. };
  106. ////////////////////////////////////////////////////////////////////////////////
  107. /**
  108. * Some drivers want the var-int arg to be zero-initialized on input.
  109. */
  110. #define GR_GL_INIT_ZERO 0
  111. #define GR_GL_GetIntegerv(gl, e, p) \
  112. do { \
  113. *(p) = GR_GL_INIT_ZERO; \
  114. GR_GL_CALL(gl, GetIntegerv(e, p)); \
  115. } while (0)
  116. #define GR_GL_GetFramebufferAttachmentParameteriv(gl, t, a, pname, p) \
  117. do { \
  118. *(p) = GR_GL_INIT_ZERO; \
  119. GR_GL_CALL(gl, GetFramebufferAttachmentParameteriv(t, a, pname, p)); \
  120. } while (0)
  121. #define GR_GL_GetInternalformativ(gl, t, f, n, s, p) \
  122. do { \
  123. *(p) = GR_GL_INIT_ZERO; \
  124. GR_GL_CALL(gl, GetInternalformativ(t, f, n, s, p)); \
  125. } while (0)
  126. #define GR_GL_GetNamedFramebufferAttachmentParameteriv(gl, fb, a, pname, p) \
  127. do { \
  128. *(p) = GR_GL_INIT_ZERO; \
  129. GR_GL_CALL(gl, GetNamedFramebufferAttachmentParameteriv(fb, a, pname, p)); \
  130. } while (0)
  131. #define GR_GL_GetRenderbufferParameteriv(gl, t, pname, p) \
  132. do { \
  133. *(p) = GR_GL_INIT_ZERO; \
  134. GR_GL_CALL(gl, GetRenderbufferParameteriv(t, pname, p)); \
  135. } while (0)
  136. #define GR_GL_GetTexLevelParameteriv(gl, t, l, pname, p) \
  137. do { \
  138. *(p) = GR_GL_INIT_ZERO; \
  139. GR_GL_CALL(gl, GetTexLevelParameteriv(t, l, pname, p)); \
  140. } while (0)
  141. #define GR_GL_GetShaderPrecisionFormat(gl, st, pt, range, precision) \
  142. do { \
  143. (range)[0] = GR_GL_INIT_ZERO; \
  144. (range)[1] = GR_GL_INIT_ZERO; \
  145. (*precision) = GR_GL_INIT_ZERO; \
  146. GR_GL_CALL(gl, GetShaderPrecisionFormat(st, pt, range, precision)); \
  147. } while (0)
  148. ////////////////////////////////////////////////////////////////////////////////
  149. /**
  150. * Helpers for glGetString()
  151. */
  152. // these variants assume caller already has a string from glGetString()
  153. GrGLVersion GrGLGetVersionFromString(const char* versionString);
  154. GrGLStandard GrGLGetStandardInUseFromString(const char* versionString);
  155. GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString);
  156. GrGLVendor GrGLGetVendorFromString(const char* vendorString);
  157. GrGLRenderer GrGLGetRendererFromStrings(const char* rendererString, const GrGLExtensions&);
  158. void GrGLGetANGLEInfoFromString(const char* rendererString, GrGLANGLEBackend*,
  159. GrGLANGLEVendor*, GrGLANGLERenderer*);
  160. void GrGLGetDriverInfo(GrGLStandard standard,
  161. GrGLVendor vendor,
  162. const char* rendererString,
  163. const char* versionString,
  164. GrGLDriver* outDriver,
  165. GrGLDriverVersion* outVersion);
  166. // these variants call glGetString()
  167. GrGLVersion GrGLGetVersion(const GrGLInterface*);
  168. GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface*);
  169. GrGLVendor GrGLGetVendor(const GrGLInterface*);
  170. GrGLRenderer GrGLGetRenderer(const GrGLInterface*);
  171. /**
  172. * Helpers for glGetError()
  173. */
  174. void GrGLCheckErr(const GrGLInterface* gl,
  175. const char* location,
  176. const char* call);
  177. void GrGLClearErr(const GrGLInterface* gl);
  178. ////////////////////////////////////////////////////////////////////////////////
  179. /**
  180. * Macros for using GrGLInterface to make GL calls
  181. */
  182. // internal macro to conditionally call glGetError based on compile-time and
  183. // run-time flags.
  184. #define GR_GL_CHECK_ERROR_IMPL(IFACE, X)
  185. // internal macro to conditionally log the gl call using SkDebugf based on
  186. // compile-time and run-time flags.
  187. #define GR_GL_LOG_CALLS_IMPL(X)
  188. // makes a GL call on the interface and does any error checking and logging
  189. #define GR_GL_CALL(IFACE, X) \
  190. do { \
  191. GR_GL_CALL_NOERRCHECK(IFACE, X); \
  192. GR_GL_CHECK_ERROR_IMPL(IFACE, X); \
  193. } while (false)
  194. // Variant of above that always skips the error check. This is useful when
  195. // the caller wants to do its own glGetError() call and examine the error value.
  196. #define GR_GL_CALL_NOERRCHECK(IFACE, X) \
  197. do { \
  198. (IFACE)->fFunctions.f##X; \
  199. GR_GL_LOG_CALLS_IMPL(X); \
  200. } while (false)
  201. // same as GR_GL_CALL but stores the return value of the gl call in RET
  202. #define GR_GL_CALL_RET(IFACE, RET, X) \
  203. do { \
  204. GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X); \
  205. GR_GL_CHECK_ERROR_IMPL(IFACE, X); \
  206. } while (false)
  207. // same as GR_GL_CALL_RET but always skips the error check.
  208. #define GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X) \
  209. do { \
  210. (RET) = (IFACE)->fFunctions.f##X; \
  211. GR_GL_LOG_CALLS_IMPL(X); \
  212. } while (false)
  213. // call glGetError without doing a redundant error check or logging.
  214. #define GR_GL_GET_ERROR(IFACE) (IFACE)->fFunctions.fGetError()
  215. static constexpr GrGLFormat GrGLFormatFromGLEnum(GrGLenum glFormat) {
  216. switch (glFormat) {
  217. case GR_GL_RGBA8: return GrGLFormat::kRGBA8;
  218. case GR_GL_R8: return GrGLFormat::kR8;
  219. case GR_GL_ALPHA8: return GrGLFormat::kALPHA8;
  220. case GR_GL_LUMINANCE8: return GrGLFormat::kLUMINANCE8;
  221. case GR_GL_BGRA8: return GrGLFormat::kBGRA8;
  222. case GR_GL_RGB565: return GrGLFormat::kRGB565;
  223. case GR_GL_RGBA16F: return GrGLFormat::kRGBA16F;
  224. case GR_GL_LUMINANCE16F: return GrGLFormat::kLUMINANCE16F;
  225. case GR_GL_R16F: return GrGLFormat::kR16F;
  226. case GR_GL_RGB8: return GrGLFormat::kRGB8;
  227. case GR_GL_RG8: return GrGLFormat::kRG8;
  228. case GR_GL_RGB10_A2: return GrGLFormat::kRGB10_A2;
  229. case GR_GL_RGBA4: return GrGLFormat::kRGBA4;
  230. case GR_GL_RGBA32F: return GrGLFormat::kRGBA32F;
  231. case GR_GL_SRGB8_ALPHA8: return GrGLFormat::kSRGB8_ALPHA8;
  232. case GR_GL_COMPRESSED_RGB8_ETC2: return GrGLFormat::kCOMPRESSED_RGB8_ETC2;
  233. case GR_GL_COMPRESSED_ETC1_RGB8: return GrGLFormat::kCOMPRESSED_ETC1_RGB8;
  234. case GR_GL_R16: return GrGLFormat::kR16;
  235. case GR_GL_RG16: return GrGLFormat::kRG16;
  236. case GR_GL_RGBA16: return GrGLFormat::kRGBA16;
  237. case GR_GL_RG16F: return GrGLFormat::kRG16F;
  238. default: return GrGLFormat::kUnknown;
  239. }
  240. }
  241. static inline GrGLFormat GrGLBackendFormatToGLFormat(const GrBackendFormat& format) {
  242. if (const GrGLenum* glFormat = format.getGLFormat()) {
  243. return GrGLFormatFromGLEnum(*glFormat);
  244. }
  245. return GrGLFormat::kUnknown;
  246. }
  247. GrGLenum GrToGLStencilFunc(GrStencilTest test);
  248. /**
  249. * Returns true if the format is compressed.
  250. */
  251. bool GrGLFormatIsCompressed(GrGLFormat);
  252. /**
  253. * Maps a GrGLFormat into the CompressionType enum if appropriate.
  254. */
  255. bool GrGLFormatToCompressionType(GrGLFormat, SkImage::CompressionType*);
  256. size_t GrGLBytesPerFormat(GrGLFormat);
  257. #endif