ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 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 | */ |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 7 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 8 | #ifndef SKSL_UTIL |
| 9 | #define SKSL_UTIL |
| 10 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 11 | #include <cstdarg> |
| 12 | #include <memory> |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 13 | #include "stdlib.h" |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 14 | #include "string.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 15 | #include "src/sksl/SkSLDefines.h" |
| 16 | #include "src/sksl/SkSLLexer.h" |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 17 | |
Ethan Nicholas | 842d31b | 2019-01-22 10:59:11 -0500 | [diff] [blame] | 18 | #ifndef SKSL_STANDALONE |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 19 | #include "include/core/SkTypes.h" |
Ethan Nicholas | 842d31b | 2019-01-22 10:59:11 -0500 | [diff] [blame] | 20 | #if SK_SUPPORT_GPU |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 21 | #include "include/gpu/GrContextOptions.h" |
| 22 | #include "src/gpu/GrShaderCaps.h" |
Ethan Nicholas | 842d31b | 2019-01-22 10:59:11 -0500 | [diff] [blame] | 23 | #endif // SK_SUPPORT_GPU |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 24 | #endif // SKSL_STANDALONE |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 25 | |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 26 | class GrShaderCaps; |
| 27 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 28 | namespace SkSL { |
| 29 | |
Ethan Nicholas | 842d31b | 2019-01-22 10:59:11 -0500 | [diff] [blame] | 30 | class OutputStream; |
| 31 | class StringStream; |
| 32 | |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 33 | #if defined(SKSL_STANDALONE) || !SK_SUPPORT_GPU |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 34 | |
| 35 | // we're being compiled standalone, so we don't have access to caps... |
| 36 | enum GrGLSLGeneration { |
| 37 | k110_GrGLSLGeneration, |
| 38 | k130_GrGLSLGeneration, |
| 39 | k140_GrGLSLGeneration, |
| 40 | k150_GrGLSLGeneration, |
| 41 | k330_GrGLSLGeneration, |
| 42 | k400_GrGLSLGeneration, |
| 43 | k420_GrGLSLGeneration, |
| 44 | k310es_GrGLSLGeneration, |
| 45 | k320es_GrGLSLGeneration, |
| 46 | }; |
| 47 | |
| 48 | #define SKSL_CAPS_CLASS StandaloneShaderCaps |
| 49 | class StandaloneShaderCaps { |
| 50 | public: |
| 51 | GrGLSLGeneration generation() const { |
| 52 | return k400_GrGLSLGeneration; |
| 53 | } |
| 54 | |
Michael Ludwig | 24d438b | 2018-09-12 15:22:50 -0400 | [diff] [blame] | 55 | bool atan2ImplementedAsAtanYOverX() const { |
| 56 | return false; |
| 57 | } |
| 58 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 59 | bool canUseMinAndAbsTogether() const { |
| 60 | return true; |
| 61 | } |
| 62 | |
| 63 | bool mustForceNegatedAtanParamToFloat() const { |
| 64 | return false; |
| 65 | } |
| 66 | |
| 67 | bool shaderDerivativeSupport() const { |
| 68 | return true; |
| 69 | } |
| 70 | |
| 71 | bool usesPrecisionModifiers() const { |
| 72 | return true; |
| 73 | } |
| 74 | |
| 75 | bool mustDeclareFragmentShaderOutput() const { |
| 76 | return true; |
| 77 | } |
| 78 | |
| 79 | bool fbFetchSupport() const { |
| 80 | return true; |
| 81 | } |
| 82 | |
| 83 | bool fbFetchNeedsCustomOutput() const { |
| 84 | return false; |
| 85 | } |
| 86 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 87 | bool flatInterpolationSupport() const { |
| 88 | return true; |
| 89 | } |
| 90 | |
| 91 | bool noperspectiveInterpolationSupport() const { |
| 92 | return true; |
| 93 | } |
| 94 | |
Robert Phillips | 7f86192 | 2018-01-30 13:13:42 +0000 | [diff] [blame] | 95 | bool multisampleInterpolationSupport() const { |
| 96 | return true; |
| 97 | } |
| 98 | |
Chris Dalton | d31b5e7 | 2019-02-26 18:02:16 -0700 | [diff] [blame] | 99 | bool sampleVariablesSupport() const { |
| 100 | return true; |
| 101 | } |
| 102 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 103 | bool externalTextureSupport() const { |
| 104 | return true; |
| 105 | } |
| 106 | |
Michael Ludwig | 4f94ef6 | 2018-09-12 15:22:16 -0400 | [diff] [blame] | 107 | bool mustDoOpBetweenFloorAndAbs() const { |
| 108 | return false; |
| 109 | } |
| 110 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 111 | bool mustEnableAdvBlendEqs() const { |
| 112 | return false; |
| 113 | } |
| 114 | |
| 115 | bool mustEnableSpecificAdvBlendEqs() const { |
| 116 | return false; |
| 117 | } |
| 118 | |
| 119 | bool canUseAnyFunctionInShader() const { |
| 120 | return false; |
| 121 | } |
| 122 | |
Chris Dalton | 47c8ed3 | 2017-11-15 18:27:09 -0700 | [diff] [blame] | 123 | bool floatIs32Bits() const { |
| 124 | return true; |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 125 | } |
| 126 | |
Ethan Nicholas | 07990de | 2017-07-18 09:47:43 -0400 | [diff] [blame] | 127 | bool integerSupport() const { |
| 128 | return false; |
| 129 | } |
| 130 | |
Chris Dalton | 07ee63d | 2018-11-16 11:02:34 -0500 | [diff] [blame] | 131 | bool builtinFMASupport() const { |
| 132 | return true; |
| 133 | } |
| 134 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 135 | const char* shaderDerivativeExtensionString() const { |
| 136 | return nullptr; |
| 137 | } |
| 138 | |
| 139 | const char* fragCoordConventionsExtensionString() const { |
| 140 | return nullptr; |
| 141 | } |
| 142 | |
Chris Dalton | 8fd7955 | 2018-01-11 00:46:14 -0500 | [diff] [blame] | 143 | const char* geometryShaderExtensionString() const { |
| 144 | return nullptr; |
| 145 | } |
| 146 | |
Chris Dalton | 567d6f4 | 2017-10-06 13:13:32 -0600 | [diff] [blame] | 147 | const char* gsInvocationsExtensionString() const { |
| 148 | return nullptr; |
| 149 | } |
| 150 | |
Brian Osman | 4b2f915 | 2018-04-17 11:19:57 -0400 | [diff] [blame] | 151 | const char* externalTextureExtensionString() const { |
| 152 | return nullptr; |
| 153 | } |
| 154 | |
Brian Osman | 061020e | 2018-04-17 14:22:15 -0400 | [diff] [blame] | 155 | const char* secondExternalTextureExtensionString() const { |
| 156 | return nullptr; |
| 157 | } |
| 158 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 159 | const char* versionDeclString() const { |
| 160 | return ""; |
| 161 | } |
Ethan Nicholas | 7da6dfa | 2017-06-21 11:25:18 -0400 | [diff] [blame] | 162 | |
Chris Dalton | 567d6f4 | 2017-10-06 13:13:32 -0600 | [diff] [blame] | 163 | bool gsInvocationsSupport() const { |
| 164 | return true; |
Ethan Nicholas | 7da6dfa | 2017-06-21 11:25:18 -0400 | [diff] [blame] | 165 | } |
Ethan Nicholas | 1af6d68 | 2017-08-08 16:42:13 -0400 | [diff] [blame] | 166 | |
| 167 | bool canUseFractForNegativeValues() const { |
| 168 | return true; |
| 169 | } |
Brian Osman | cd3261a | 2018-01-16 13:52:29 +0000 | [diff] [blame] | 170 | |
| 171 | bool canUseFragCoord() const { |
| 172 | return true; |
| 173 | } |
Chris Dalton | 85fcfc5 | 2018-03-14 11:15:27 -0600 | [diff] [blame] | 174 | |
| 175 | bool incompleteShortIntPrecision() const { |
| 176 | return false; |
| 177 | } |
Ethan Nicholas | 43f6d45 | 2018-04-13 16:53:07 -0400 | [diff] [blame] | 178 | |
Adrienne Walker | ee8295c | 2018-08-21 10:56:30 -0700 | [diff] [blame] | 179 | bool addAndTrueToLoopCondition() const { |
| 180 | return false; |
| 181 | } |
| 182 | |
Adrienne Walker | c02165f | 2018-08-21 11:08:11 -0700 | [diff] [blame] | 183 | bool unfoldShortCircuitAsTernary() const { |
| 184 | return false; |
| 185 | } |
| 186 | |
Adrienne Walker | 92b161f | 2018-08-22 10:41:52 -0700 | [diff] [blame] | 187 | bool emulateAbsIntFunction() const { |
| 188 | return false; |
| 189 | } |
| 190 | |
Adrienne Walker | 8b23ca6 | 2018-08-22 10:45:41 -0700 | [diff] [blame] | 191 | bool rewriteDoWhileLoops() const { |
| 192 | return false; |
| 193 | } |
| 194 | |
Adrienne Walker | 2f4c09b | 2018-08-22 16:04:57 -0700 | [diff] [blame] | 195 | bool removePowWithConstantExponent() const { |
| 196 | return false; |
| 197 | } |
| 198 | |
Ethan Nicholas | 43f6d45 | 2018-04-13 16:53:07 -0400 | [diff] [blame] | 199 | const char* fbFetchColorName() const { |
| 200 | return nullptr; |
| 201 | } |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 202 | }; |
| 203 | |
| 204 | extern StandaloneShaderCaps standaloneCaps; |
| 205 | |
| 206 | #else |
| 207 | |
| 208 | #define SKSL_CAPS_CLASS GrShaderCaps |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 209 | // Various sets of caps for use in tests |
Brian Salomon | f1dd677 | 2016-11-29 15:27:52 -0500 | [diff] [blame] | 210 | class ShaderCapsFactory { |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 211 | public: |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 212 | static sk_sp<GrShaderCaps> Default() { |
| 213 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 214 | result->fVersionDeclString = "#version 400"; |
| 215 | result->fShaderDerivativeSupport = true; |
| 216 | return result; |
| 217 | } |
| 218 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 219 | static sk_sp<GrShaderCaps> Version450Core() { |
| 220 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 221 | result->fVersionDeclString = "#version 450 core"; |
| 222 | return result; |
| 223 | } |
| 224 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 225 | static sk_sp<GrShaderCaps> Version110() { |
| 226 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 227 | result->fVersionDeclString = "#version 110"; |
| 228 | result->fGLSLGeneration = GrGLSLGeneration::k110_GrGLSLGeneration; |
| 229 | return result; |
| 230 | } |
| 231 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 232 | static sk_sp<GrShaderCaps> UsesPrecisionModifiers() { |
| 233 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 234 | result->fVersionDeclString = "#version 400"; |
| 235 | result->fUsesPrecisionModifiers = true; |
| 236 | return result; |
| 237 | } |
| 238 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 239 | static sk_sp<GrShaderCaps> CannotUseMinAndAbsTogether() { |
| 240 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 241 | result->fVersionDeclString = "#version 400"; |
| 242 | result->fCanUseMinAndAbsTogether = false; |
| 243 | return result; |
| 244 | } |
| 245 | |
Florin Malita | 3b30c4f | 2017-08-08 15:47:35 -0400 | [diff] [blame] | 246 | static sk_sp<GrShaderCaps> CannotUseFractForNegativeValues() { |
| 247 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 248 | result->fVersionDeclString = "#version 400"; |
| 249 | result->fCanUseFractForNegativeValues = false; |
| 250 | return result; |
| 251 | } |
| 252 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 253 | static sk_sp<GrShaderCaps> MustForceNegatedAtanParamToFloat() { |
| 254 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 255 | result->fVersionDeclString = "#version 400"; |
| 256 | result->fMustForceNegatedAtanParamToFloat = true; |
| 257 | return result; |
| 258 | } |
| 259 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 260 | static sk_sp<GrShaderCaps> ShaderDerivativeExtensionString() { |
| 261 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 262 | result->fVersionDeclString = "#version 400"; |
| 263 | result->fShaderDerivativeSupport = true; |
| 264 | result->fShaderDerivativeExtensionString = "GL_OES_standard_derivatives"; |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 265 | result->fUsesPrecisionModifiers = true; |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 266 | return result; |
| 267 | } |
Ethan Nicholas | 3605ace | 2016-11-21 15:59:48 -0500 | [diff] [blame] | 268 | |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 269 | static sk_sp<GrShaderCaps> FragCoordsOld() { |
| 270 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 271 | result->fVersionDeclString = "#version 110"; |
| 272 | result->fGLSLGeneration = GrGLSLGeneration::k110_GrGLSLGeneration; |
| 273 | result->fFragCoordConventionsExtensionString = "GL_ARB_fragment_coord_conventions"; |
| 274 | return result; |
| 275 | } |
| 276 | |
| 277 | static sk_sp<GrShaderCaps> FragCoordsNew() { |
| 278 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 279 | result->fVersionDeclString = "#version 400"; |
| 280 | result->fFragCoordConventionsExtensionString = "GL_ARB_fragment_coord_conventions"; |
| 281 | return result; |
| 282 | } |
| 283 | |
Chris Dalton | 8fd7955 | 2018-01-11 00:46:14 -0500 | [diff] [blame] | 284 | static sk_sp<GrShaderCaps> GeometryShaderSupport() { |
| 285 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 286 | result->fVersionDeclString = "#version 400"; |
| 287 | result->fGeometryShaderSupport = true; |
| 288 | result->fGSInvocationsSupport = true; |
| 289 | return result; |
| 290 | } |
| 291 | |
Chris Dalton | f1b47bb | 2017-10-06 11:57:51 -0600 | [diff] [blame] | 292 | static sk_sp<GrShaderCaps> NoGSInvocationsSupport() { |
Ethan Nicholas | 7da6dfa | 2017-06-21 11:25:18 -0400 | [diff] [blame] | 293 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 294 | result->fVersionDeclString = "#version 400"; |
Chris Dalton | f1b47bb | 2017-10-06 11:57:51 -0600 | [diff] [blame] | 295 | result->fGeometryShaderSupport = true; |
| 296 | result->fGSInvocationsSupport = false; |
| 297 | return result; |
| 298 | } |
| 299 | |
Chris Dalton | 8fd7955 | 2018-01-11 00:46:14 -0500 | [diff] [blame] | 300 | static sk_sp<GrShaderCaps> GeometryShaderExtensionString() { |
| 301 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 302 | result->fVersionDeclString = "#version 310es"; |
| 303 | result->fGeometryShaderSupport = true; |
| 304 | result->fGeometryShaderExtensionString = "GL_EXT_geometry_shader"; |
| 305 | result->fGSInvocationsSupport = true; |
| 306 | return result; |
| 307 | } |
| 308 | |
Chris Dalton | f1b47bb | 2017-10-06 11:57:51 -0600 | [diff] [blame] | 309 | static sk_sp<GrShaderCaps> GSInvocationsExtensionString() { |
| 310 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 311 | result->fVersionDeclString = "#version 400"; |
| 312 | result->fGeometryShaderSupport = true; |
| 313 | result->fGSInvocationsSupport = true; |
| 314 | result->fGSInvocationsExtensionString = "GL_ARB_gpu_shader5"; |
Ethan Nicholas | 7da6dfa | 2017-06-21 11:25:18 -0400 | [diff] [blame] | 315 | return result; |
| 316 | } |
| 317 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 318 | static sk_sp<GrShaderCaps> VariousCaps() { |
| 319 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
Ethan Nicholas | 3605ace | 2016-11-21 15:59:48 -0500 | [diff] [blame] | 320 | result->fVersionDeclString = "#version 400"; |
| 321 | result->fExternalTextureSupport = true; |
| 322 | result->fFBFetchSupport = false; |
Ethan Nicholas | 3605ace | 2016-11-21 15:59:48 -0500 | [diff] [blame] | 323 | result->fCanUseAnyFunctionInShader = false; |
| 324 | return result; |
| 325 | } |
Brian Osman | cd3261a | 2018-01-16 13:52:29 +0000 | [diff] [blame] | 326 | |
| 327 | static sk_sp<GrShaderCaps> CannotUseFragCoord() { |
| 328 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 329 | result->fVersionDeclString = "#version 400"; |
| 330 | result->fCanUseFragCoord = false; |
| 331 | return result; |
| 332 | } |
Chris Dalton | c2d0dd6 | 2018-03-07 07:46:10 -0700 | [diff] [blame] | 333 | |
| 334 | static sk_sp<GrShaderCaps> IncompleteShortIntPrecision() { |
| 335 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 336 | result->fVersionDeclString = "#version 310es"; |
| 337 | result->fUsesPrecisionModifiers = true; |
| 338 | result->fIncompleteShortIntPrecision = true; |
| 339 | return result; |
| 340 | } |
Adrienne Walker | ee8295c | 2018-08-21 10:56:30 -0700 | [diff] [blame] | 341 | |
| 342 | static sk_sp<GrShaderCaps> AddAndTrueToLoopCondition() { |
| 343 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 344 | result->fVersionDeclString = "#version 400"; |
| 345 | result->fAddAndTrueToLoopCondition = true; |
| 346 | return result; |
| 347 | } |
Adrienne Walker | c02165f | 2018-08-21 11:08:11 -0700 | [diff] [blame] | 348 | |
| 349 | static sk_sp<GrShaderCaps> UnfoldShortCircuitAsTernary() { |
| 350 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 351 | result->fVersionDeclString = "#version 400"; |
| 352 | result->fUnfoldShortCircuitAsTernary = true; |
| 353 | return result; |
| 354 | } |
Adrienne Walker | 92b161f | 2018-08-22 10:41:52 -0700 | [diff] [blame] | 355 | |
| 356 | static sk_sp<GrShaderCaps> EmulateAbsIntFunction() { |
| 357 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 358 | result->fVersionDeclString = "#version 400"; |
| 359 | result->fEmulateAbsIntFunction = true; |
| 360 | return result; |
| 361 | } |
Adrienne Walker | 8b23ca6 | 2018-08-22 10:45:41 -0700 | [diff] [blame] | 362 | |
| 363 | static sk_sp<GrShaderCaps> RewriteDoWhileLoops() { |
| 364 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 365 | result->fVersionDeclString = "#version 400"; |
| 366 | result->fRewriteDoWhileLoops = true; |
| 367 | return result; |
| 368 | } |
Adrienne Walker | 2f4c09b | 2018-08-22 16:04:57 -0700 | [diff] [blame] | 369 | |
| 370 | static sk_sp<GrShaderCaps> RemovePowWithConstantExponent() { |
| 371 | sk_sp<GrShaderCaps> result = sk_make_sp<GrShaderCaps>(GrContextOptions()); |
| 372 | result->fVersionDeclString = "#version 400"; |
| 373 | result->fRemovePowWithConstantExponent = true; |
| 374 | return result; |
| 375 | } |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 376 | }; |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 377 | #endif |
Ethan Nicholas | 7ef4b74 | 2016-11-11 15:16:46 -0500 | [diff] [blame] | 378 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 379 | void write_stringstream(const StringStream& d, OutputStream& out); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 380 | |
Ethan Nicholas | 0e9401d | 2019-03-21 11:05:37 -0400 | [diff] [blame] | 381 | // Returns true if op is '=' or any compound assignment operator ('+=', '-=', etc.) |
| 382 | bool is_assignment(Token::Kind op); |
| 383 | |
| 384 | // Given a compound assignment operator, returns the non-assignment version of the operator (e.g. |
| 385 | // '+=' becomes '+') |
| 386 | Token::Kind remove_assignment(Token::Kind op); |
| 387 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 388 | NORETURN void sksl_abort(); |
| 389 | |
| 390 | } // namespace |
| 391 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 392 | #endif |