GrShaderVar.h 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295
  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. */
  7. #ifndef GrShaderVar_DEFINED
  8. #define GrShaderVar_DEFINED
  9. #include "include/core/SkString.h"
  10. #include "include/private/GrTypesPriv.h"
  11. class GrShaderCaps;
  12. #define USE_UNIFORM_FLOAT_ARRAYS true
  13. /**
  14. * Represents a variable in a shader
  15. */
  16. class GrShaderVar {
  17. public:
  18. enum TypeModifier {
  19. kNone_TypeModifier,
  20. kOut_TypeModifier,
  21. kIn_TypeModifier,
  22. kInOut_TypeModifier,
  23. kUniform_TypeModifier,
  24. };
  25. /**
  26. * Values for array count that have special meaning. We allow 1-sized arrays.git
  27. */
  28. enum {
  29. kNonArray = 0, // not an array
  30. kUnsizedArray = -1, // an unsized array (declared with [])
  31. };
  32. /**
  33. * Defaults to a non-arry half with no type modifier or layout qualifier.
  34. */
  35. GrShaderVar()
  36. : fType(kHalf_GrSLType)
  37. , fTypeModifier(kNone_TypeModifier)
  38. , fCount(kNonArray)
  39. , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
  40. }
  41. GrShaderVar(const SkString& name, GrSLType type, int arrayCount = kNonArray)
  42. : fType(type)
  43. , fTypeModifier(kNone_TypeModifier)
  44. , fCount(arrayCount)
  45. , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
  46. , fName(name) {
  47. SkASSERT(kVoid_GrSLType != type);
  48. fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
  49. }
  50. GrShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray)
  51. : fType(type)
  52. , fTypeModifier(kNone_TypeModifier)
  53. , fCount(arrayCount)
  54. , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
  55. , fName(name) {
  56. SkASSERT(kVoid_GrSLType != type);
  57. fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
  58. }
  59. GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier)
  60. : fType(type)
  61. , fTypeModifier(typeModifier)
  62. , fCount(kNonArray)
  63. , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
  64. , fName(name) {
  65. SkASSERT(kVoid_GrSLType != type);
  66. }
  67. GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier, int arrayCount)
  68. : fType(type)
  69. , fTypeModifier(typeModifier)
  70. , fCount(arrayCount)
  71. , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
  72. , fName(name) {
  73. SkASSERT(kVoid_GrSLType != type);
  74. }
  75. GrShaderVar(const GrShaderVar& that)
  76. : fType(that.fType)
  77. , fTypeModifier(that.fTypeModifier)
  78. , fCount(that.fCount)
  79. , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
  80. , fName(that.fName)
  81. , fLayoutQualifier(that.fLayoutQualifier)
  82. , fExtraModifiers(that.fExtraModifiers) {
  83. SkASSERT(kVoid_GrSLType != that.getType());
  84. }
  85. /**
  86. * Sets as a non-array.
  87. */
  88. void set(GrSLType type,
  89. const SkString& name,
  90. TypeModifier typeModifier = kNone_TypeModifier,
  91. const char* layoutQualifier = nullptr,
  92. const char* extraModifiers = nullptr,
  93. bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
  94. SkASSERT(kVoid_GrSLType != type);
  95. fType = type;
  96. fTypeModifier = typeModifier;
  97. fName = name;
  98. fCount = kNonArray;
  99. fLayoutQualifier = layoutQualifier;
  100. if (extraModifiers) {
  101. fExtraModifiers.printf("%s ", extraModifiers);
  102. }
  103. fUseUniformFloatArrays = useUniformFloatArrays;
  104. }
  105. /**
  106. * Sets as a non-array.
  107. */
  108. void set(GrSLType type,
  109. const char* name,
  110. TypeModifier typeModifier = kNone_TypeModifier,
  111. const char* layoutQualifier = nullptr,
  112. const char* extraModifiers = nullptr,
  113. bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
  114. SkASSERT(kVoid_GrSLType != type);
  115. fType = type;
  116. fTypeModifier = typeModifier;
  117. fName = name;
  118. fCount = kNonArray;
  119. fLayoutQualifier = layoutQualifier;
  120. if (extraModifiers) {
  121. fExtraModifiers.printf("%s ", extraModifiers);
  122. }
  123. fUseUniformFloatArrays = useUniformFloatArrays;
  124. }
  125. /**
  126. * Set all var options
  127. */
  128. void set(GrSLType type,
  129. const SkString& name,
  130. int count,
  131. TypeModifier typeModifier,
  132. const char* layoutQualifier = nullptr,
  133. const char* extraModifiers = nullptr,
  134. bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
  135. SkASSERT(kVoid_GrSLType != type);
  136. fType = type;
  137. fTypeModifier = typeModifier;
  138. fName = name;
  139. fCount = count;
  140. fLayoutQualifier = layoutQualifier;
  141. if (extraModifiers) {
  142. fExtraModifiers.printf("%s ", extraModifiers);
  143. }
  144. fUseUniformFloatArrays = useUniformFloatArrays;
  145. }
  146. /**
  147. * Set all var options
  148. */
  149. void set(GrSLType type,
  150. const char* name,
  151. int count,
  152. TypeModifier typeModifier,
  153. const char* layoutQualifier = nullptr,
  154. const char* extraModifiers = nullptr,
  155. bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
  156. SkASSERT(kVoid_GrSLType != type);
  157. fType = type;
  158. fTypeModifier = typeModifier;
  159. fName = name;
  160. fCount = count;
  161. fLayoutQualifier = layoutQualifier;
  162. if (extraModifiers) {
  163. fExtraModifiers.printf("%s ", extraModifiers);
  164. }
  165. fUseUniformFloatArrays = useUniformFloatArrays;
  166. }
  167. /**
  168. * Is the var an array.
  169. */
  170. bool isArray() const { return kNonArray != fCount; }
  171. /**
  172. * Is this an unsized array, (i.e. declared with []).
  173. */
  174. bool isUnsizedArray() const { return kUnsizedArray == fCount; }
  175. /**
  176. * Get the array length of the var.
  177. */
  178. int getArrayCount() const { return fCount; }
  179. /**
  180. * Set the array length of the var
  181. */
  182. void setArrayCount(int count) { fCount = count; }
  183. /**
  184. * Set to be a non-array.
  185. */
  186. void setNonArray() { fCount = kNonArray; }
  187. /**
  188. * Set to be an unsized array.
  189. */
  190. void setUnsizedArray() { fCount = kUnsizedArray; }
  191. /**
  192. * Access the var name as a writable string
  193. */
  194. SkString* accessName() { return &fName; }
  195. /**
  196. * Set the var name
  197. */
  198. void setName(const SkString& n) { fName = n; }
  199. void setName(const char* n) { fName = n; }
  200. /**
  201. * Get the var name.
  202. */
  203. const SkString& getName() const { return fName; }
  204. /**
  205. * Shortcut for this->getName().c_str();
  206. */
  207. const char* c_str() const { return this->getName().c_str(); }
  208. /**
  209. * Get the type of the var
  210. */
  211. GrSLType getType() const { return fType; }
  212. /**
  213. * Set the type of the var
  214. */
  215. void setType(GrSLType type) { fType = type; }
  216. TypeModifier getTypeModifier() const { return fTypeModifier; }
  217. void setTypeModifier(TypeModifier type) { fTypeModifier = type; }
  218. /**
  219. * Appends to the layout qualifier
  220. */
  221. void addLayoutQualifier(const char* layoutQualifier) {
  222. if (!layoutQualifier || !strlen(layoutQualifier)) {
  223. return;
  224. }
  225. if (fLayoutQualifier.isEmpty()) {
  226. fLayoutQualifier = layoutQualifier;
  227. } else {
  228. fLayoutQualifier.appendf(", %s", layoutQualifier);
  229. }
  230. }
  231. void setIOType(GrIOType);
  232. void addModifier(const char* modifier) {
  233. if (modifier) {
  234. fExtraModifiers.appendf("%s ", modifier);
  235. }
  236. }
  237. /**
  238. * Write a declaration of this variable to out.
  239. */
  240. void appendDecl(const GrShaderCaps*, SkString* out) const;
  241. void appendArrayAccess(int index, SkString* out) const {
  242. out->appendf("%s[%d]%s",
  243. this->getName().c_str(),
  244. index,
  245. fUseUniformFloatArrays ? "" : ".x");
  246. }
  247. void appendArrayAccess(const char* indexName, SkString* out) const {
  248. out->appendf("%s[%s]%s",
  249. this->getName().c_str(),
  250. indexName,
  251. fUseUniformFloatArrays ? "" : ".x");
  252. }
  253. private:
  254. GrSLType fType;
  255. TypeModifier fTypeModifier;
  256. int fCount;
  257. /// Work around driver bugs on some hardware that don't correctly
  258. /// support uniform float []
  259. bool fUseUniformFloatArrays;
  260. SkString fName;
  261. SkString fLayoutQualifier;
  262. SkString fExtraModifiers;
  263. };
  264. #endif