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 "GrTypes.h" 12 #include "SkTArray.h" 13 #include "SkRect.h" 14 15 /** 16 * Types of shader-language-specific boxed variables we can create. (Currently only GrGLShaderVars, 17 * but should be applicable to other shader languages.) 18 */ 19 enum GrSLType { 20 kVoid_GrSLType, 21 kFloat_GrSLType, 22 kVec2f_GrSLType, 23 kVec3f_GrSLType, 24 kVec4f_GrSLType, 25 kMat33f_GrSLType, 26 kMat44f_GrSLType, 27 kSampler2D_GrSLType, 28 29 kLast_GrSLType = kSampler2D_GrSLType 30 }; 31 static const int kGrSLTypeCount = kLast_GrSLType + 1; 32 33 enum GrShaderType { 34 kVertex_GrShaderType, 35 kGeometry_GrShaderType, 36 kFragment_GrShaderType, 37 38 kLastkFragment_GrShaderType = kFragment_GrShaderType 39 }; 40 static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1; 41 42 /** 43 * Precisions of shader language variables. Not all shading languages support precisions or actually 44 * vary the internal precision based on the qualifiers. These currently only apply to float types ( 45 * including float vectors and matrices). 46 */ 47 enum GrSLPrecision { 48 kLow_GrSLPrecision, 49 kMedium_GrSLPrecision, 50 kHigh_GrSLPrecision, 51 52 // Default precision is medium. This is because on OpenGL ES 2 highp support is not 53 // guaranteed. On (non-ES) OpenGL the specifiers have no effect on precision. 54 kDefault_GrSLPrecision = kMedium_GrSLPrecision, 55 56 kLast_GrSLPrecision = kHigh_GrSLPrecision 57 }; 58 59 static const int kGrSLPrecisionCount = kLast_GrSLPrecision + 1; 60 61 /** 62 * Gets the vector size of the SLType. Returns -1 for void, matrices, and samplers. 63 */ 64 static inline int GrSLTypeVectorCount(GrSLType type) { 65 SkASSERT(type >= 0 && type < static_cast<GrSLType>(kGrSLTypeCount)); 66 static const int kCounts[] = { -1, 1, 2, 3, 4, -1, -1, -1 }; 67 return kCounts[type]; 68 69 GR_STATIC_ASSERT(0 == kVoid_GrSLType); 70 GR_STATIC_ASSERT(1 == kFloat_GrSLType); 71 GR_STATIC_ASSERT(2 == kVec2f_GrSLType); 72 GR_STATIC_ASSERT(3 == kVec3f_GrSLType); 73 GR_STATIC_ASSERT(4 == kVec4f_GrSLType); 74 GR_STATIC_ASSERT(5 == kMat33f_GrSLType); 75 GR_STATIC_ASSERT(6 == kMat44f_GrSLType); 76 GR_STATIC_ASSERT(7 == kSampler2D_GrSLType); 77 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kCounts) == kGrSLTypeCount); 78 } 79 80 /** Return the type enum for a vector of floats of length n (1..4), 81 e.g. 1 -> kFloat_GrSLType, 2 -> kVec2_GrSLType, ... */ 82 static inline GrSLType GrSLFloatVectorType(int count) { 83 SkASSERT(count > 0 && count <= 4); 84 return (GrSLType)(count); 85 86 GR_STATIC_ASSERT(kFloat_GrSLType == 1); 87 GR_STATIC_ASSERT(kVec2f_GrSLType == 2); 88 GR_STATIC_ASSERT(kVec3f_GrSLType == 3); 89 GR_STATIC_ASSERT(kVec4f_GrSLType == 4); 90 } 91 92 /** Is the shading language type floating point (or vector/matrix of fp)? */ 93 static inline bool GrSLTypeIsFloatType(GrSLType type) { 94 SkASSERT(type >= 0 && type < static_cast<GrSLType>(kGrSLTypeCount)); 95 return type >= 1 && type <= 6; 96 97 GR_STATIC_ASSERT(0 == kVoid_GrSLType); 98 GR_STATIC_ASSERT(1 == kFloat_GrSLType); 99 GR_STATIC_ASSERT(2 == kVec2f_GrSLType); 100 GR_STATIC_ASSERT(3 == kVec3f_GrSLType); 101 GR_STATIC_ASSERT(4 == kVec4f_GrSLType); 102 GR_STATIC_ASSERT(5 == kMat33f_GrSLType); 103 GR_STATIC_ASSERT(6 == kMat44f_GrSLType); 104 GR_STATIC_ASSERT(7 == kSampler2D_GrSLType); 105 GR_STATIC_ASSERT(8 == kGrSLTypeCount); 106 } 107 ////////////////////////////////////////////////////////////////////////////// 108 109 /** 110 * Types used to describe format of vertices in arrays. 111 */ 112 enum GrVertexAttribType { 113 kFloat_GrVertexAttribType = 0, 114 kVec2f_GrVertexAttribType, 115 kVec3f_GrVertexAttribType, 116 kVec4f_GrVertexAttribType, 117 118 kUByte_GrVertexAttribType, // unsigned byte, e.g. coverage 119 kVec4ub_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors 120 121 kVec2s_GrVertexAttribType, // vector of 2 shorts, e.g. texture coordinates 122 123 kLast_GrVertexAttribType = kVec2s_GrVertexAttribType 124 }; 125 static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1; 126 127 /** 128 * Returns the vector size of the type. 129 */ 130 static inline int GrVertexAttribTypeVectorCount(GrVertexAttribType type) { 131 SkASSERT(type >= 0 && type < kGrVertexAttribTypeCount); 132 static const int kCounts[] = { 1, 2, 3, 4, 1, 4, 2 }; 133 return kCounts[type]; 134 135 GR_STATIC_ASSERT(0 == kFloat_GrVertexAttribType); 136 GR_STATIC_ASSERT(1 == kVec2f_GrVertexAttribType); 137 GR_STATIC_ASSERT(2 == kVec3f_GrVertexAttribType); 138 GR_STATIC_ASSERT(3 == kVec4f_GrVertexAttribType); 139 GR_STATIC_ASSERT(4 == kUByte_GrVertexAttribType); 140 GR_STATIC_ASSERT(5 == kVec4ub_GrVertexAttribType); 141 GR_STATIC_ASSERT(6 == kVec2s_GrVertexAttribType); 142 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kCounts) == kGrVertexAttribTypeCount); 143 } 144 145 /** 146 * Returns the size of the attrib type in bytes. 147 */ 148 static inline size_t GrVertexAttribTypeSize(GrVertexAttribType type) { 149 SkASSERT(type >= 0 && type < kGrVertexAttribTypeCount); 150 static const size_t kSizes[] = { 151 sizeof(float), // kFloat_GrVertexAttribType 152 2*sizeof(float), // kVec2f_GrVertexAttribType 153 3*sizeof(float), // kVec3f_GrVertexAttribType 154 4*sizeof(float), // kVec4f_GrVertexAttribType 155 1*sizeof(char), // kUByte_GrVertexAttribType 156 4*sizeof(char), // kVec4ub_GrVertexAttribType 157 2*sizeof(int16_t) // kVec2s_GrVertexAttribType 158 }; 159 return kSizes[type]; 160 161 GR_STATIC_ASSERT(0 == kFloat_GrVertexAttribType); 162 GR_STATIC_ASSERT(1 == kVec2f_GrVertexAttribType); 163 GR_STATIC_ASSERT(2 == kVec3f_GrVertexAttribType); 164 GR_STATIC_ASSERT(3 == kVec4f_GrVertexAttribType); 165 GR_STATIC_ASSERT(4 == kUByte_GrVertexAttribType); 166 GR_STATIC_ASSERT(5 == kVec4ub_GrVertexAttribType); 167 GR_STATIC_ASSERT(6 == kVec2s_GrVertexAttribType); 168 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kSizes) == kGrVertexAttribTypeCount); 169 } 170 171 /** 172 * converts a GrVertexAttribType to a GrSLType 173 */ 174 static inline GrSLType GrVertexAttribTypeToSLType(GrVertexAttribType type) { 175 switch (type) { 176 default: 177 SkFAIL("Unsupported type conversion"); 178 case kUByte_GrVertexAttribType: 179 case kFloat_GrVertexAttribType: 180 return kFloat_GrSLType; 181 case kVec2s_GrVertexAttribType: 182 case kVec2f_GrVertexAttribType: 183 return kVec2f_GrSLType; 184 case kVec3f_GrVertexAttribType: 185 return kVec3f_GrSLType; 186 case kVec4ub_GrVertexAttribType: 187 case kVec4f_GrVertexAttribType: 188 return kVec4f_GrSLType; 189 } 190 } 191 192 ////////////////////////////////////////////////////////////////////////////// 193 194 /** 195 * We have coverage effects that clip rendering to the edge of some geometric primitive. 196 * This enum specifies how that clipping is performed. Not all factories that take a 197 * GrProcessorEdgeType will succeed with all values and it is up to the caller to check for 198 * a NULL return. 199 */ 200 enum GrPrimitiveEdgeType { 201 kFillBW_GrProcessorEdgeType, 202 kFillAA_GrProcessorEdgeType, 203 kInverseFillBW_GrProcessorEdgeType, 204 kInverseFillAA_GrProcessorEdgeType, 205 kHairlineAA_GrProcessorEdgeType, 206 207 kLast_GrProcessorEdgeType = kHairlineAA_GrProcessorEdgeType 208 }; 209 210 static const int kGrProcessorEdgeTypeCnt = kLast_GrProcessorEdgeType + 1; 211 212 static inline bool GrProcessorEdgeTypeIsFill(const GrPrimitiveEdgeType edgeType) { 213 return (kFillAA_GrProcessorEdgeType == edgeType || kFillBW_GrProcessorEdgeType == edgeType); 214 } 215 216 static inline bool GrProcessorEdgeTypeIsInverseFill(const GrPrimitiveEdgeType edgeType) { 217 return (kInverseFillAA_GrProcessorEdgeType == edgeType || 218 kInverseFillBW_GrProcessorEdgeType == edgeType); 219 } 220 221 static inline bool GrProcessorEdgeTypeIsAA(const GrPrimitiveEdgeType edgeType) { 222 return (kFillBW_GrProcessorEdgeType != edgeType && kInverseFillBW_GrProcessorEdgeType != edgeType); 223 } 224 225 static inline GrPrimitiveEdgeType GrInvertProcessorEdgeType(const GrPrimitiveEdgeType edgeType) { 226 switch (edgeType) { 227 case kFillBW_GrProcessorEdgeType: 228 return kInverseFillBW_GrProcessorEdgeType; 229 case kFillAA_GrProcessorEdgeType: 230 return kInverseFillAA_GrProcessorEdgeType; 231 case kInverseFillBW_GrProcessorEdgeType: 232 return kFillBW_GrProcessorEdgeType; 233 case kInverseFillAA_GrProcessorEdgeType: 234 return kFillAA_GrProcessorEdgeType; 235 case kHairlineAA_GrProcessorEdgeType: 236 SkFAIL("Hairline fill isn't invertible."); 237 } 238 return kFillAA_GrProcessorEdgeType; // suppress warning. 239 } 240 241 /** 242 * Indicates the type of pending IO operations that can be recorded for gpu resources. 243 */ 244 enum GrIOType { 245 kRead_GrIOType, 246 kWrite_GrIOType, 247 kRW_GrIOType 248 }; 249 250 struct GrScissorState { 251 GrScissorState() : fEnabled(false) {} 252 void set(const SkIRect& rect) { fRect = rect; fEnabled = true; } 253 bool operator==(const GrScissorState& other) const { 254 return fEnabled == other.fEnabled && 255 (false == fEnabled || fRect == other.fRect); 256 } 257 bool operator!=(const GrScissorState& other) const { return !(*this == other); } 258 259 bool enabled() const { return fEnabled; } 260 const SkIRect& rect() const { return fRect; } 261 262 private: 263 bool fEnabled; 264 SkIRect fRect; 265 }; 266 267 #ifdef SK_DEBUG 268 // Takes a pointer to a GrContext, and will suppress prints if required 269 #define GrContextDebugf(context, ...) \ 270 if (!context->suppressPrints()) { \ 271 SkDebugf(__VA_ARGS__); \ 272 } 273 #else 274 #define GrContextDebugf(context, ...) 275 #endif 276 277 #endif 278