1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_HWUI_PROGRAM_H 18 #define ANDROID_HWUI_PROGRAM_H 19 20 #include <utils/KeyedVector.h> 21 22 #include <GLES2/gl2.h> 23 #include <GLES2/gl2ext.h> 24 25 #include <SkXfermode.h> 26 27 #include "Debug.h" 28 #include "Matrix.h" 29 #include "Properties.h" 30 31 namespace android { 32 namespace uirenderer { 33 34 /////////////////////////////////////////////////////////////////////////////// 35 // Defines 36 /////////////////////////////////////////////////////////////////////////////// 37 38 // Debug 39 #if DEBUG_PROGRAMS 40 #define PROGRAM_LOGD(...) ALOGD(__VA_ARGS__) 41 #else 42 #define PROGRAM_LOGD(...) 43 #endif 44 45 #define COLOR_COMPONENT_THRESHOLD 1.0f 46 #define COLOR_COMPONENT_INV_THRESHOLD 0.0f 47 48 #define PROGRAM_KEY_TEXTURE 0x1 49 #define PROGRAM_KEY_A8_TEXTURE 0x2 50 #define PROGRAM_KEY_BITMAP 0x4 51 #define PROGRAM_KEY_GRADIENT 0x8 52 #define PROGRAM_KEY_BITMAP_FIRST 0x10 53 #define PROGRAM_KEY_COLOR_MATRIX 0x20 54 #define PROGRAM_KEY_COLOR_LIGHTING 0x40 55 #define PROGRAM_KEY_COLOR_BLEND 0x80 56 #define PROGRAM_KEY_BITMAP_NPOT 0x100 57 #define PROGRAM_KEY_SWAP_SRC_DST 0x2000 58 59 #define PROGRAM_KEY_BITMAP_WRAPS_MASK 0x600 60 #define PROGRAM_KEY_BITMAP_WRAPT_MASK 0x1800 61 62 // Encode the xfermodes on 6 bits 63 #define PROGRAM_MAX_XFERMODE 0x1f 64 #define PROGRAM_XFERMODE_SHADER_SHIFT 26 65 #define PROGRAM_XFERMODE_COLOR_OP_SHIFT 20 66 #define PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT 14 67 68 #define PROGRAM_BITMAP_WRAPS_SHIFT 9 69 #define PROGRAM_BITMAP_WRAPT_SHIFT 11 70 71 #define PROGRAM_GRADIENT_TYPE_SHIFT 33 72 #define PROGRAM_MODULATE_SHIFT 35 73 74 #define PROGRAM_IS_POINT_SHIFT 36 75 76 #define PROGRAM_HAS_AA_SHIFT 37 77 78 #define PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT 38 79 #define PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT 39 80 81 #define PROGRAM_HAS_GAMMA_CORRECTION 40 82 83 #define PROGRAM_IS_SIMPLE_GRADIENT 41 84 85 #define PROGRAM_HAS_COLORS 42 86 87 #define PROGRAM_HAS_DEBUG_HIGHLIGHT 43 88 89 /////////////////////////////////////////////////////////////////////////////// 90 // Types 91 /////////////////////////////////////////////////////////////////////////////// 92 93 typedef uint64_t programid; 94 95 /////////////////////////////////////////////////////////////////////////////// 96 // Program description 97 /////////////////////////////////////////////////////////////////////////////// 98 99 /** 100 * Describe the features required for a given program. The features 101 * determine the generation of both the vertex and fragment shaders. 102 * A ProgramDescription must be used in conjunction with a ProgramCache. 103 */ 104 struct ProgramDescription { 105 enum ColorModifier { 106 kColorNone = 0, 107 kColorMatrix, 108 kColorLighting, 109 kColorBlend 110 }; 111 112 enum Gradient { 113 kGradientLinear = 0, 114 kGradientCircular, 115 kGradientSweep 116 }; 117 118 ProgramDescription() { 119 reset(); 120 } 121 122 // Texturing 123 bool hasTexture; 124 bool hasAlpha8Texture; 125 bool hasExternalTexture; 126 bool hasTextureTransform; 127 128 // Color attribute 129 bool hasColors; 130 131 // Modulate, this should only be set when setColor() return true 132 bool modulate; 133 134 // Shaders 135 bool hasBitmap; 136 bool isBitmapNpot; 137 138 bool isAA; // drawing with a per-vertex alpha 139 140 bool hasGradient; 141 Gradient gradientType; 142 bool isSimpleGradient; 143 144 SkXfermode::Mode shadersMode; 145 146 bool isBitmapFirst; 147 GLenum bitmapWrapS; 148 GLenum bitmapWrapT; 149 150 // Color operations 151 ColorModifier colorOp; 152 SkXfermode::Mode colorMode; 153 154 // Framebuffer blending (requires Extensions.hasFramebufferFetch()) 155 // Ignored for all values < SkXfermode::kPlus_Mode 156 SkXfermode::Mode framebufferMode; 157 bool swapSrcDst; 158 159 bool isPoint; 160 float pointSize; 161 162 bool hasGammaCorrection; 163 float gamma; 164 165 bool hasDebugHighlight; 166 167 /** 168 * Resets this description. All fields are reset back to the default 169 * values they hold after building a new instance. 170 */ 171 void reset() { 172 hasTexture = false; 173 hasAlpha8Texture = false; 174 hasExternalTexture = false; 175 hasTextureTransform = false; 176 177 hasColors = false; 178 179 isAA = false; 180 181 modulate = false; 182 183 hasBitmap = false; 184 isBitmapNpot = false; 185 186 hasGradient = false; 187 gradientType = kGradientLinear; 188 isSimpleGradient = false; 189 190 shadersMode = SkXfermode::kClear_Mode; 191 192 isBitmapFirst = false; 193 bitmapWrapS = GL_CLAMP_TO_EDGE; 194 bitmapWrapT = GL_CLAMP_TO_EDGE; 195 196 colorOp = kColorNone; 197 colorMode = SkXfermode::kClear_Mode; 198 199 framebufferMode = SkXfermode::kClear_Mode; 200 swapSrcDst = false; 201 202 isPoint = false; 203 pointSize = 0.0f; 204 205 hasGammaCorrection = false; 206 gamma = 2.2f; 207 208 hasDebugHighlight = false; 209 } 210 211 /** 212 * Indicates, for a given color, whether color modulation is required in 213 * the fragment shader. When this method returns true, the program should 214 * be provided with a modulation color. 215 */ 216 bool setColor(const float r, const float g, const float b, const float a) { 217 modulate = a < COLOR_COMPONENT_THRESHOLD; 218 return modulate; 219 } 220 221 /** 222 * Indicates, for a given color, whether color modulation is required in 223 * the fragment shader. When this method returns true, the program should 224 * be provided with a modulation color. 225 */ 226 bool setAlpha8Color(const float r, const float g, const float b, const float a) { 227 modulate = a < COLOR_COMPONENT_THRESHOLD || r > COLOR_COMPONENT_INV_THRESHOLD || 228 g > COLOR_COMPONENT_INV_THRESHOLD || b > COLOR_COMPONENT_INV_THRESHOLD; 229 return modulate; 230 } 231 232 /** 233 * Computes the unique key identifying this program. 234 */ 235 programid key() const { 236 programid key = 0; 237 if (hasTexture) key |= PROGRAM_KEY_TEXTURE; 238 if (hasAlpha8Texture) key |= PROGRAM_KEY_A8_TEXTURE; 239 if (hasBitmap) { 240 key |= PROGRAM_KEY_BITMAP; 241 if (isBitmapNpot) { 242 key |= PROGRAM_KEY_BITMAP_NPOT; 243 key |= getEnumForWrap(bitmapWrapS) << PROGRAM_BITMAP_WRAPS_SHIFT; 244 key |= getEnumForWrap(bitmapWrapT) << PROGRAM_BITMAP_WRAPT_SHIFT; 245 } 246 } 247 if (hasGradient) key |= PROGRAM_KEY_GRADIENT; 248 key |= programid(gradientType) << PROGRAM_GRADIENT_TYPE_SHIFT; 249 if (isBitmapFirst) key |= PROGRAM_KEY_BITMAP_FIRST; 250 if (hasBitmap && hasGradient) { 251 key |= (shadersMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_SHADER_SHIFT; 252 } 253 switch (colorOp) { 254 case kColorMatrix: 255 key |= PROGRAM_KEY_COLOR_MATRIX; 256 break; 257 case kColorLighting: 258 key |= PROGRAM_KEY_COLOR_LIGHTING; 259 break; 260 case kColorBlend: 261 key |= PROGRAM_KEY_COLOR_BLEND; 262 key |= (colorMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_COLOR_OP_SHIFT; 263 break; 264 case kColorNone: 265 break; 266 } 267 key |= (framebufferMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT; 268 if (swapSrcDst) key |= PROGRAM_KEY_SWAP_SRC_DST; 269 if (modulate) key |= programid(0x1) << PROGRAM_MODULATE_SHIFT; 270 if (isPoint) key |= programid(0x1) << PROGRAM_IS_POINT_SHIFT; 271 if (isAA) key |= programid(0x1) << PROGRAM_HAS_AA_SHIFT; 272 if (hasExternalTexture) key |= programid(0x1) << PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT; 273 if (hasTextureTransform) key |= programid(0x1) << PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT; 274 if (hasGammaCorrection) key |= programid(0x1) << PROGRAM_HAS_GAMMA_CORRECTION; 275 if (isSimpleGradient) key |= programid(0x1) << PROGRAM_IS_SIMPLE_GRADIENT; 276 if (hasColors) key |= programid(0x1) << PROGRAM_HAS_COLORS; 277 if (hasDebugHighlight) key |= programid(0x1) << PROGRAM_HAS_DEBUG_HIGHLIGHT; 278 return key; 279 } 280 281 /** 282 * Logs the specified message followed by the key identifying this program. 283 */ 284 void log(const char* message) const { 285 #if DEBUG_PROGRAMS 286 programid k = key(); 287 PROGRAM_LOGD("%s (key = 0x%.8x%.8x)", message, uint32_t(k >> 32), 288 uint32_t(k & 0xffffffff)); 289 #endif 290 } 291 292 private: 293 static inline uint32_t getEnumForWrap(GLenum wrap) { 294 switch (wrap) { 295 case GL_CLAMP_TO_EDGE: 296 return 0; 297 case GL_REPEAT: 298 return 1; 299 case GL_MIRRORED_REPEAT: 300 return 2; 301 } 302 return 0; 303 } 304 305 }; // struct ProgramDescription 306 307 /** 308 * A program holds a vertex and a fragment shader. It offers several utility 309 * methods to query attributes and uniforms. 310 */ 311 class Program { 312 public: 313 enum ShaderBindings { 314 kBindingPosition, 315 kBindingTexCoords 316 }; 317 318 /** 319 * Creates a new program with the specified vertex and fragment 320 * shaders sources. 321 */ 322 Program(const ProgramDescription& description, const char* vertex, const char* fragment); 323 virtual ~Program(); 324 325 /** 326 * Binds this program to the GL context. 327 */ 328 virtual void use(); 329 330 /** 331 * Marks this program as unused. This will not unbind 332 * the program from the GL context. 333 */ 334 virtual void remove(); 335 336 /** 337 * Returns the OpenGL name of the specified attribute. 338 */ 339 int getAttrib(const char* name); 340 341 /** 342 * Returns the OpenGL name of the specified uniform. 343 */ 344 int getUniform(const char* name); 345 346 /** 347 * Indicates whether this program is currently in use with 348 * the GL context. 349 */ 350 inline bool isInUse() const { 351 return mUse; 352 } 353 354 /** 355 * Indicates whether this program was correctly compiled and linked. 356 */ 357 inline bool isInitialized() const { 358 return mInitialized; 359 } 360 361 /** 362 * Binds the program with the specified projection, modelView and 363 * transform matrices. 364 */ 365 void set(const mat4& projectionMatrix, const mat4& modelViewMatrix, 366 const mat4& transformMatrix, bool offset = false); 367 368 /** 369 * Sets the color associated with this shader. 370 */ 371 void setColor(const float r, const float g, const float b, const float a); 372 373 /** 374 * Name of the position attribute. 375 */ 376 int position; 377 378 /** 379 * Name of the texCoords attribute if it exists, -1 otherwise. 380 */ 381 int texCoords; 382 383 /** 384 * Name of the transform uniform. 385 */ 386 int transform; 387 388 /** 389 * Name of the projection uniform. 390 */ 391 int projection; 392 393 protected: 394 /** 395 * Adds an attribute with the specified name. 396 * 397 * @return The OpenGL name of the attribute. 398 */ 399 int addAttrib(const char* name); 400 401 /** 402 * Binds the specified attribute name to the specified slot. 403 */ 404 int bindAttrib(const char* name, ShaderBindings bindingSlot); 405 406 /** 407 * Adds a uniform with the specified name. 408 * 409 * @return The OpenGL name of the uniform. 410 */ 411 int addUniform(const char* name); 412 413 private: 414 /** 415 * Compiles the specified shader of the specified type. 416 * 417 * @return The name of the compiled shader. 418 */ 419 GLuint buildShader(const char* source, GLenum type); 420 421 // Name of the OpenGL program and shaders 422 GLuint mProgramId; 423 GLuint mVertexShader; 424 GLuint mFragmentShader; 425 426 // Keeps track of attributes and uniforms slots 427 KeyedVector<const char*, int> mAttributes; 428 KeyedVector<const char*, int> mUniforms; 429 430 bool mUse; 431 bool mInitialized; 432 433 bool mHasColorUniform; 434 int mColorUniform; 435 436 bool mHasSampler; 437 }; // class Program 438 439 }; // namespace uirenderer 440 }; // namespace android 441 442 #endif // ANDROID_HWUI_PROGRAM_H 443
