OpenGLRenderer.h revision 735738c4ddf3229caa5f6e634bf591953ac29944
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_OPENGL_RENDERER_H 18#define ANDROID_HWUI_OPENGL_RENDERER_H 19 20#include <GLES2/gl2.h> 21#include <GLES2/gl2ext.h> 22 23#include <SkBitmap.h> 24#include <SkMatrix.h> 25#include <SkPaint.h> 26#include <SkRegion.h> 27#include <SkShader.h> 28#include <SkXfermode.h> 29 30#include <utils/Functor.h> 31#include <utils/RefBase.h> 32#include <utils/SortedVector.h> 33#include <utils/Vector.h> 34 35#include <cutils/compiler.h> 36 37#include "Debug.h" 38#include "Extensions.h" 39#include "Matrix.h" 40#include "Program.h" 41#include "Rect.h" 42#include "Snapshot.h" 43#include "Vertex.h" 44#include "SkiaShader.h" 45#include "SkiaColorFilter.h" 46#include "Caches.h" 47 48namespace android { 49namespace uirenderer { 50 51/////////////////////////////////////////////////////////////////////////////// 52// Renderer 53/////////////////////////////////////////////////////////////////////////////// 54 55class DisplayList; 56 57/** 58 * OpenGL renderer used to draw accelerated 2D graphics. The API is a 59 * simplified version of Skia's Canvas API. 60 */ 61class OpenGLRenderer { 62public: 63 ANDROID_API OpenGLRenderer(); 64 virtual ~OpenGLRenderer(); 65 66 /** 67 * Read externally defined properties to control the behavior 68 * of the renderer. 69 */ 70 ANDROID_API void initProperties(); 71 72 /** 73 * Indicates whether this renderer executes drawing commands immediately. 74 * If this method returns true, the drawing commands will be executed 75 * later. 76 */ 77 virtual bool isDeferred(); 78 79 /** 80 * Sets the dimension of the underlying drawing surface. This method must 81 * be called at least once every time the drawing surface changes size. 82 * 83 * @param width The width in pixels of the underlysing surface 84 * @param height The height in pixels of the underlysing surface 85 */ 86 virtual void setViewport(int width, int height); 87 88 /** 89 * Prepares the renderer to draw a frame. This method must be invoked 90 * at the beginning of each frame. When this method is invoked, the 91 * entire drawing surface is assumed to be redrawn. 92 * 93 * @param opaque If true, the target surface is considered opaque 94 * and will not be cleared. If false, the target surface 95 * will be cleared 96 */ 97 ANDROID_API status_t prepare(bool opaque); 98 99 /** 100 * Prepares the renderer to draw a frame. This method must be invoked 101 * at the beginning of each frame. Only the specified rectangle of the 102 * frame is assumed to be dirty. A clip will automatically be set to 103 * the specified rectangle. 104 * 105 * @param left The left coordinate of the dirty rectangle 106 * @param top The top coordinate of the dirty rectangle 107 * @param right The right coordinate of the dirty rectangle 108 * @param bottom The bottom coordinate of the dirty rectangle 109 * @param opaque If true, the target surface is considered opaque 110 * and will not be cleared. If false, the target surface 111 * will be cleared in the specified dirty rectangle 112 */ 113 virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque); 114 115 /** 116 * Indicates the end of a frame. This method must be invoked whenever 117 * the caller is done rendering a frame. 118 */ 119 virtual void finish(); 120 121 /** 122 * This method must be invoked before handing control over to a draw functor. 123 * See callDrawGLFunction() for instance. 124 * 125 * This command must not be recorded inside display lists. 126 */ 127 virtual void interrupt(); 128 129 /** 130 * This method must be invoked after getting control back from a draw functor. 131 * 132 * This command must not be recorded inside display lists. 133 */ 134 virtual void resume(); 135 136 ANDROID_API status_t invokeFunctors(Rect& dirty); 137 ANDROID_API void detachFunctor(Functor* functor); 138 ANDROID_API void attachFunctor(Functor* functor); 139 virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty); 140 141 ANDROID_API void pushLayerUpdate(Layer* layer); 142 ANDROID_API void clearLayerUpdates(); 143 144 ANDROID_API int getSaveCount() const; 145 virtual int save(int flags); 146 virtual void restore(); 147 virtual void restoreToCount(int saveCount); 148 149 virtual int saveLayer(float left, float top, float right, float bottom, 150 SkPaint* p, int flags); 151 virtual int saveLayerAlpha(float left, float top, float right, float bottom, 152 int alpha, int flags); 153 154 virtual void translate(float dx, float dy); 155 virtual void rotate(float degrees); 156 virtual void scale(float sx, float sy); 157 virtual void skew(float sx, float sy); 158 159 ANDROID_API void getMatrix(SkMatrix* matrix); 160 virtual void setMatrix(SkMatrix* matrix); 161 virtual void concatMatrix(SkMatrix* matrix); 162 163 ANDROID_API const Rect& getClipBounds(); 164 ANDROID_API bool quickReject(float left, float top, float right, float bottom); 165 bool quickRejectNoScissor(float left, float top, float right, float bottom); 166 virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op); 167 virtual bool clipPath(SkPath* path, SkRegion::Op op); 168 virtual bool clipRegion(SkRegion* region, SkRegion::Op op); 169 virtual Rect* getClipRect(); 170 171 virtual status_t drawDisplayList(DisplayList* displayList, Rect& dirty, int32_t flags, 172 uint32_t level = 0); 173 virtual void outputDisplayList(DisplayList* displayList, uint32_t level = 0); 174 virtual status_t drawLayer(Layer* layer, float x, float y, SkPaint* paint); 175 virtual status_t drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint); 176 virtual status_t drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint); 177 virtual status_t drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, 178 float srcRight, float srcBottom, float dstLeft, float dstTop, 179 float dstRight, float dstBottom, SkPaint* paint); 180 virtual status_t drawBitmapData(SkBitmap* bitmap, float left, float top, SkPaint* paint); 181 virtual status_t drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, 182 float* vertices, int* colors, SkPaint* paint); 183 virtual status_t drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, 184 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, 185 float left, float top, float right, float bottom, SkPaint* paint); 186 status_t drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, 187 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, 188 float left, float top, float right, float bottom, int alpha, SkXfermode::Mode mode); 189 virtual status_t drawColor(int color, SkXfermode::Mode mode); 190 virtual status_t drawRect(float left, float top, float right, float bottom, SkPaint* paint); 191 virtual status_t drawRoundRect(float left, float top, float right, float bottom, 192 float rx, float ry, SkPaint* paint); 193 virtual status_t drawCircle(float x, float y, float radius, SkPaint* paint); 194 virtual status_t drawOval(float left, float top, float right, float bottom, SkPaint* paint); 195 virtual status_t drawArc(float left, float top, float right, float bottom, 196 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint); 197 virtual status_t drawPath(SkPath* path, SkPaint* paint); 198 virtual status_t drawLines(float* points, int count, SkPaint* paint); 199 virtual status_t drawPoints(float* points, int count, SkPaint* paint); 200 virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path, 201 float hOffset, float vOffset, SkPaint* paint); 202 virtual status_t drawPosText(const char* text, int bytesCount, int count, 203 const float* positions, SkPaint* paint); 204 virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y, 205 const float* positions, SkPaint* paint, float length = -1.0f); 206 virtual status_t drawRects(const float* rects, int count, SkPaint* paint); 207 208 virtual void resetShader(); 209 virtual void setupShader(SkiaShader* shader); 210 211 virtual void resetColorFilter(); 212 virtual void setupColorFilter(SkiaColorFilter* filter); 213 214 virtual void resetShadow(); 215 virtual void setupShadow(float radius, float dx, float dy, int color); 216 217 virtual void resetPaintFilter(); 218 virtual void setupPaintFilter(int clearBits, int setBits); 219 220 SkPaint* filterPaint(SkPaint* paint); 221 222 ANDROID_API bool isCurrentTransformSimple() { 223 return mSnapshot->transform->isSimple(); 224 } 225 226 /** 227 * Sets the alpha on the current snapshot. This alpha value will be modulated 228 * with other alpha values when drawing primitives. 229 */ 230 void setAlpha(float alpha) { 231 mSnapshot->alpha = alpha; 232 } 233 234 /** 235 * Inserts a named group marker in the stream of GL commands. This marker 236 * can be used by tools to group commands into logical groups. A call to 237 * this method must always be followed later on by a call to endMark(). 238 */ 239 void startMark(const char* name) const; 240 241 /** 242 * Closes the last group marker opened by startMark(). 243 */ 244 void endMark() const; 245 246 /** 247 * Gets the alpha and xfermode out of a paint object. If the paint is null 248 * alpha will be 255 and the xfermode will be SRC_OVER. This method does 249 * not multiply the paint's alpha by the current snapshot's alpha. 250 * 251 * @param paint The paint to extract values from 252 * @param alpha Where to store the resulting alpha 253 * @param mode Where to store the resulting xfermode 254 */ 255 static inline void getAlphaAndModeDirect(SkPaint* paint, int* alpha, SkXfermode::Mode* mode) { 256 if (paint) { 257 *mode = getXfermode(paint->getXfermode()); 258 259 // Skia draws using the color's alpha channel if < 255 260 // Otherwise, it uses the paint's alpha 261 int color = paint->getColor(); 262 *alpha = (color >> 24) & 0xFF; 263 if (*alpha == 255) { 264 *alpha = paint->getAlpha(); 265 } 266 } else { 267 *mode = SkXfermode::kSrcOver_Mode; 268 *alpha = 255; 269 } 270 } 271 272protected: 273 /** 274 * Computes the projection matrix, initialize the first snapshot 275 * and stores the dimensions of the render target. 276 */ 277 void initViewport(int width, int height); 278 279 /** 280 * Clears the underlying surface if needed. 281 */ 282 virtual status_t clear(float left, float top, float right, float bottom, bool opaque); 283 284 /** 285 * Call this method after updating a layer during a drawing pass. 286 */ 287 void resumeAfterLayer(); 288 289 /** 290 * Compose the layer defined in the current snapshot with the layer 291 * defined by the previous snapshot. 292 * 293 * The current snapshot *must* be a layer (flag kFlagIsLayer set.) 294 * 295 * @param curent The current snapshot containing the layer to compose 296 * @param previous The previous snapshot to compose the current layer with 297 */ 298 virtual void composeLayer(sp<Snapshot> current, sp<Snapshot> previous); 299 300 /** 301 * Marks the specified region as dirty at the specified bounds. 302 */ 303 void dirtyLayerUnchecked(Rect& bounds, Region* region); 304 305 /** 306 * Returns the current snapshot. 307 */ 308 sp<Snapshot> getSnapshot() { 309 return mSnapshot; 310 } 311 312 /** 313 * Returns the region of the current layer. 314 */ 315 virtual Region* getRegion() { 316 return mSnapshot->region; 317 } 318 319 /** 320 * Indicates whether rendering is currently targeted at a layer. 321 */ 322 virtual bool hasLayer() { 323 return (mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region; 324 } 325 326 /** 327 * Returns the name of the FBO this renderer is rendering into. 328 */ 329 virtual GLint getTargetFbo() { 330 return 0; 331 } 332 333 /** 334 * Renders the specified layer as a textured quad. 335 * 336 * @param layer The layer to render 337 * @param rect The bounds of the layer 338 */ 339 void drawTextureLayer(Layer* layer, const Rect& rect); 340 341 /** 342 * Gets the alpha and xfermode out of a paint object. If the paint is null 343 * alpha will be 255 and the xfermode will be SRC_OVER. 344 * 345 * @param paint The paint to extract values from 346 * @param alpha Where to store the resulting alpha 347 * @param mode Where to store the resulting xfermode 348 */ 349 inline void getAlphaAndMode(SkPaint* paint, int* alpha, SkXfermode::Mode* mode); 350 351 /** 352 * Safely retrieves the mode from the specified xfermode. If the specified 353 * xfermode is null, the mode is assumed to be SkXfermode::kSrcOver_Mode. 354 */ 355 static inline SkXfermode::Mode getXfermode(SkXfermode* mode) { 356 SkXfermode::Mode resultMode; 357 if (!SkXfermode::AsMode(mode, &resultMode)) { 358 resultMode = SkXfermode::kSrcOver_Mode; 359 } 360 return resultMode; 361 } 362 363 /** 364 * Set to true to suppress error checks at the end of a frame. 365 */ 366 virtual bool suppressErrorChecks() { 367 return false; 368 } 369 370 Caches& getCaches() { 371 return mCaches; 372 } 373 374private: 375 /** 376 * Discards the content of the framebuffer if supported by the driver. 377 * This method should be called at the beginning of a frame to optimize 378 * rendering on some tiler architectures. 379 */ 380 void discardFramebuffer(float left, float top, float right, float bottom); 381 382 /** 383 * Ensures the state of the renderer is the same as the state of 384 * the GL context. 385 */ 386 void syncState(); 387 388 /** 389 * Tells the GPU what part of the screen is about to be redrawn. 390 * This method needs to be invoked every time getTargetFbo() is 391 * bound again. 392 */ 393 void startTiling(const sp<Snapshot>& snapshot, bool opaque = false); 394 395 /** 396 * Tells the GPU that we are done drawing the frame or that we 397 * are switching to another render target. 398 */ 399 void endTiling(); 400 401 /** 402 * Saves the current state of the renderer as a new snapshot. 403 * The new snapshot is saved in mSnapshot and the previous snapshot 404 * is linked from mSnapshot->previous. 405 * 406 * @param flags The save flags; see SkCanvas for more information 407 * 408 * @return The new save count. This value can be passed to #restoreToCount() 409 */ 410 int saveSnapshot(int flags); 411 412 /** 413 * Restores the current snapshot; mSnapshot becomes mSnapshot->previous. 414 * 415 * @return True if the clip was modified. 416 */ 417 bool restoreSnapshot(); 418 419 /** 420 * Sets the clipping rectangle using glScissor. The clip is defined by 421 * the current snapshot's clipRect member. 422 */ 423 void setScissorFromClip(); 424 425 /** 426 * Performs a quick reject but does not affect the scissor. Returns 427 * the transformed rect to test and the current clip. 428 */ 429 bool quickRejectNoScissor(float left, float top, float right, float bottom, 430 Rect& transformed, Rect& clip); 431 432 /** 433 * Performs a quick reject but adjust the bounds to account for stroke width if necessary 434 */ 435 bool quickRejectPreStroke(float left, float top, float right, float bottom, SkPaint* paint); 436 437 /** 438 * Creates a new layer stored in the specified snapshot. 439 * 440 * @param snapshot The snapshot associated with the new layer 441 * @param left The left coordinate of the layer 442 * @param top The top coordinate of the layer 443 * @param right The right coordinate of the layer 444 * @param bottom The bottom coordinate of the layer 445 * @param alpha The translucency of the layer 446 * @param mode The blending mode of the layer 447 * @param flags The layer save flags 448 * @param previousFbo The name of the current framebuffer 449 * 450 * @return True if the layer was successfully created, false otherwise 451 */ 452 bool createLayer(float left, float top, float right, float bottom, 453 int alpha, SkXfermode::Mode mode, int flags, GLuint previousFbo); 454 455 /** 456 * Creates a new layer stored in the specified snapshot as an FBO. 457 * 458 * @param layer The layer to store as an FBO 459 * @param snapshot The snapshot associated with the new layer 460 * @param bounds The bounds of the layer 461 * @param previousFbo The name of the current framebuffer 462 */ 463 bool createFboLayer(Layer* layer, Rect& bounds, Rect& clip, GLuint previousFbo); 464 465 /** 466 * Compose the specified layer as a region. 467 * 468 * @param layer The layer to compose 469 * @param rect The layer's bounds 470 */ 471 void composeLayerRegion(Layer* layer, const Rect& rect); 472 473 /** 474 * Compose the specified layer as a simple rectangle. 475 * 476 * @param layer The layer to compose 477 * @param rect The layer's bounds 478 * @param swap If true, the source and destination are swapped 479 */ 480 void composeLayerRect(Layer* layer, const Rect& rect, bool swap = false); 481 482 /** 483 * Clears all the regions corresponding to the current list of layers. 484 * This method MUST be invoked before any drawing operation. 485 */ 486 void clearLayerRegions(); 487 488 /** 489 * Mark the layer as dirty at the specified coordinates. The coordinates 490 * are transformed with the supplied matrix. 491 */ 492 void dirtyLayer(const float left, const float top, 493 const float right, const float bottom, const mat4 transform); 494 495 /** 496 * Mark the layer as dirty at the specified coordinates. 497 */ 498 void dirtyLayer(const float left, const float top, 499 const float right, const float bottom); 500 501 /** 502 * Draws a colored rectangle with the specified color. The specified coordinates 503 * are transformed by the current snapshot's transform matrix unless specified 504 * otherwise. 505 * 506 * @param left The left coordinate of the rectangle 507 * @param top The top coordinate of the rectangle 508 * @param right The right coordinate of the rectangle 509 * @param bottom The bottom coordinate of the rectangle 510 * @param color The rectangle's ARGB color, defined as a packed 32 bits word 511 * @param mode The Skia xfermode to use 512 * @param ignoreTransform True if the current transform should be ignored 513 */ 514 void drawColorRect(float left, float top, float right, float bottom, 515 int color, SkXfermode::Mode mode, bool ignoreTransform = false); 516 517 /** 518 * Draws a series of colored rectangles with the specified color. The specified 519 * coordinates are transformed by the current snapshot's transform matrix unless 520 * specified otherwise. 521 * 522 * @param rects A list of rectangles, 4 floats (left, top, right, bottom) 523 * per rectangle 524 * @param color The rectangles' ARGB color, defined as a packed 32 bits word 525 * @param mode The Skia xfermode to use 526 * @param ignoreTransform True if the current transform should be ignored 527 */ 528 status_t drawColorRects(const float* rects, int count, int color, 529 SkXfermode::Mode mode, bool ignoreTransform = false); 530 531 /** 532 * Draws the shape represented by the specified path texture. 533 * This method invokes drawPathTexture() but takes into account 534 * the extra left/top offset and the texture offset to correctly 535 * position the final shape. 536 * 537 * @param left The left coordinate of the shape to render 538 * @param top The top coordinate of the shape to render 539 * @param texture The texture reprsenting the shape 540 * @param paint The paint to draw the shape with 541 */ 542 status_t drawShape(float left, float top, const PathTexture* texture, SkPaint* paint); 543 544 /** 545 * Draws the specified texture as an alpha bitmap. Alpha bitmaps obey 546 * different compositing rules. 547 * 548 * @param texture The texture to draw with 549 * @param left The x coordinate of the bitmap 550 * @param top The y coordinate of the bitmap 551 * @param paint The paint to render with 552 */ 553 void drawAlphaBitmap(Texture* texture, float left, float top, SkPaint* paint); 554 555 /** 556 * Renders the convex hull defined by the specified path as a strip of polygons. 557 * 558 * @param path The hull of the path to draw 559 * @param paint The paint to render with 560 */ 561 void drawConvexPath(const SkPath& path, SkPaint* paint); 562 563 /** 564 * Draws a textured rectangle with the specified texture. The specified coordinates 565 * are transformed by the current snapshot's transform matrix. 566 * 567 * @param left The left coordinate of the rectangle 568 * @param top The top coordinate of the rectangle 569 * @param right The right coordinate of the rectangle 570 * @param bottom The bottom coordinate of the rectangle 571 * @param texture The texture name to map onto the rectangle 572 * @param alpha An additional translucency parameter, between 0.0f and 1.0f 573 * @param mode The blending mode 574 * @param blend True if the texture contains an alpha channel 575 */ 576 void drawTextureRect(float left, float top, float right, float bottom, GLuint texture, 577 float alpha, SkXfermode::Mode mode, bool blend); 578 579 /** 580 * Draws a textured rectangle with the specified texture. The specified coordinates 581 * are transformed by the current snapshot's transform matrix. 582 * 583 * @param left The left coordinate of the rectangle 584 * @param top The top coordinate of the rectangle 585 * @param right The right coordinate of the rectangle 586 * @param bottom The bottom coordinate of the rectangle 587 * @param texture The texture to use 588 * @param paint The paint containing the alpha, blending mode, etc. 589 */ 590 void drawTextureRect(float left, float top, float right, float bottom, 591 Texture* texture, SkPaint* paint); 592 593 /** 594 * Draws a textured mesh with the specified texture. If the indices are omitted, 595 * the mesh is drawn as a simple quad. The mesh pointers become offsets when a 596 * VBO is bound. 597 * 598 * @param left The left coordinate of the rectangle 599 * @param top The top coordinate of the rectangle 600 * @param right The right coordinate of the rectangle 601 * @param bottom The bottom coordinate of the rectangle 602 * @param texture The texture name to map onto the rectangle 603 * @param alpha An additional translucency parameter, between 0.0f and 1.0f 604 * @param mode The blending mode 605 * @param blend True if the texture contains an alpha channel 606 * @param vertices The vertices that define the mesh 607 * @param texCoords The texture coordinates of each vertex 608 * @param elementsCount The number of elements in the mesh, required by indices 609 * @param swapSrcDst Whether or not the src and dst blending operations should be swapped 610 * @param ignoreTransform True if the current transform should be ignored 611 * @param vbo The VBO used to draw the mesh 612 * @param ignoreScale True if the model view matrix should not be scaled 613 * @param dirty True if calling this method should dirty the current layer 614 */ 615 void drawTextureMesh(float left, float top, float right, float bottom, GLuint texture, 616 float alpha, SkXfermode::Mode mode, bool blend, 617 GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount, 618 bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0, 619 bool ignoreScale = false, bool dirty = true); 620 621 void drawAlpha8TextureMesh(float left, float top, float right, float bottom, 622 GLuint texture, bool hasColor, int color, int alpha, SkXfermode::Mode mode, 623 GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount, 624 bool ignoreTransform, bool dirty = true); 625 626 /** 627 * Draws text underline and strike-through if needed. 628 * 629 * @param text The text to decor 630 * @param bytesCount The number of bytes in the text 631 * @param length The length in pixels of the text, can be <= 0.0f to force a measurement 632 * @param x The x coordinate where the text will be drawn 633 * @param y The y coordinate where the text will be drawn 634 * @param paint The paint to draw the text with 635 */ 636 void drawTextDecorations(const char* text, int bytesCount, float length, 637 float x, float y, SkPaint* paint); 638 639 /** 640 * Draws shadow layer on text (with optional positions). 641 * 642 * @param paint The paint to draw the shadow with 643 * @param text The text to draw 644 * @param bytesCount The number of bytes in the text 645 * @param count The number of glyphs in the text 646 * @param positions The x, y positions of individual glyphs (or NULL) 647 * @param fontRenderer The font renderer object 648 * @param alpha The alpha value for drawing the shadow 649 * @param mode The xfermode for drawing the shadow 650 * @param x The x coordinate where the shadow will be drawn 651 * @param y The y coordinate where the shadow will be drawn 652 */ 653 void drawTextShadow(SkPaint* paint, const char* text, int bytesCount, int count, 654 const float* positions, FontRenderer& fontRenderer, int alpha, SkXfermode::Mode mode, 655 float x, float y); 656 657 /** 658 * Draws a path texture. Path textures are alpha8 bitmaps that need special 659 * compositing to apply colors/filters/etc. 660 * 661 * @param texture The texture to render 662 * @param x The x coordinate where the texture will be drawn 663 * @param y The y coordinate where the texture will be drawn 664 * @param paint The paint to draw the texture with 665 */ 666 void drawPathTexture(const PathTexture* texture, float x, float y, SkPaint* paint); 667 668 /** 669 * Resets the texture coordinates stored in mMeshVertices. Setting the values 670 * back to default is achieved by calling: 671 * 672 * resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f); 673 * 674 * @param u1 The left coordinate of the texture 675 * @param v1 The bottom coordinate of the texture 676 * @param u2 The right coordinate of the texture 677 * @param v2 The top coordinate of the texture 678 */ 679 void resetDrawTextureTexCoords(float u1, float v1, float u2, float v2); 680 681 /** 682 * Binds the specified texture. The texture unit must have been selected 683 * prior to calling this method. 684 */ 685 inline void bindTexture(GLuint texture) { 686 glBindTexture(GL_TEXTURE_2D, texture); 687 } 688 689 /** 690 * Binds the specified EGLImage texture. The texture unit must have been selected 691 * prior to calling this method. 692 */ 693 inline void bindExternalTexture(GLuint texture) { 694 glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture); 695 } 696 697 /** 698 * Enable or disable blending as necessary. This function sets the appropriate 699 * blend function based on the specified xfermode. 700 */ 701 inline void chooseBlending(bool blend, SkXfermode::Mode mode, ProgramDescription& description, 702 bool swapSrcDst = false); 703 704 /** 705 * Use the specified program with the current GL context. If the program is already 706 * in use, it will not be bound again. If it is not in use, the current program is 707 * marked unused and the specified program becomes used and becomes the new 708 * current program. 709 * 710 * @param program The program to use 711 * 712 * @return true If the specified program was already in use, false otherwise. 713 */ 714 inline bool useProgram(Program* program); 715 716 /** 717 * Invoked before any drawing operation. This sets required state. 718 */ 719 void setupDraw(bool clear = true); 720 721 /** 722 * Various methods to setup OpenGL rendering. 723 */ 724 void setupDrawWithTexture(bool isAlpha8 = false); 725 void setupDrawWithExternalTexture(); 726 void setupDrawNoTexture(); 727 void setupDrawAA(); 728 void setupDrawVertexShape(); 729 void setupDrawPoint(float pointSize); 730 void setupDrawColor(int color, int alpha); 731 void setupDrawColor(float r, float g, float b, float a); 732 void setupDrawAlpha8Color(int color, int alpha); 733 void setupDrawTextGamma(const SkPaint* paint); 734 void setupDrawShader(); 735 void setupDrawColorFilter(); 736 void setupDrawBlending(SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode, 737 bool swapSrcDst = false); 738 void setupDrawBlending(bool blend = true, SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode, 739 bool swapSrcDst = false); 740 void setupDrawProgram(); 741 void setupDrawDirtyRegionsDisabled(); 742 void setupDrawModelViewIdentity(bool offset = false); 743 void setupDrawModelView(float left, float top, float right, float bottom, 744 bool ignoreTransform = false, bool ignoreModelView = false); 745 void setupDrawModelViewTranslate(float left, float top, float right, float bottom, 746 bool ignoreTransform = false); 747 void setupDrawPointUniforms(); 748 void setupDrawColorUniforms(); 749 void setupDrawPureColorUniforms(); 750 void setupDrawShaderIdentityUniforms(); 751 void setupDrawShaderUniforms(bool ignoreTransform = false); 752 void setupDrawColorFilterUniforms(); 753 void setupDrawSimpleMesh(); 754 void setupDrawTexture(GLuint texture); 755 void setupDrawExternalTexture(GLuint texture); 756 void setupDrawTextureTransform(); 757 void setupDrawTextureTransformUniforms(mat4& transform); 758 void setupDrawTextGammaUniforms(); 759 void setupDrawMesh(GLvoid* vertices, GLvoid* texCoords = NULL, GLuint vbo = 0); 760 void setupDrawMeshIndices(GLvoid* vertices, GLvoid* texCoords); 761 void setupDrawVertices(GLvoid* vertices); 762 void setupDrawAALine(GLvoid* vertices, GLvoid* distanceCoords, GLvoid* lengthCoords, 763 float strokeWidth, int& widthSlot, int& lengthSlot); 764 void finishDrawAALine(const int widthSlot, const int lengthSlot); 765 void finishDrawTexture(); 766 void accountForClear(SkXfermode::Mode mode); 767 768 bool updateLayer(Layer* layer, bool inFrame); 769 void updateLayers(); 770 771 /** 772 * Renders the specified region as a series of rectangles. This method 773 * is used for debugging only. 774 */ 775 void drawRegionRects(const Region& region); 776 777 void debugOverdraw(bool enable, bool clear); 778 void renderOverdraw(); 779 780 /** 781 * Should be invoked every time the glScissor is modified. 782 */ 783 inline void dirtyClip() { 784 mDirtyClip = true; 785 } 786 787 // Dimensions of the drawing surface 788 int mWidth, mHeight; 789 790 // Matrix used for ortho projection in shaders 791 mat4 mOrthoMatrix; 792 793 // Model-view matrix used to position/size objects 794 mat4 mModelView; 795 796 // Number of saved states 797 int mSaveCount; 798 // Base state 799 sp<Snapshot> mFirstSnapshot; 800 // Current state 801 sp<Snapshot> mSnapshot; 802 // State used to define the clipping region 803 sp<Snapshot> mTilingSnapshot; 804 805 // Shaders 806 SkiaShader* mShader; 807 808 // Color filters 809 SkiaColorFilter* mColorFilter; 810 811 // Used to draw textured quads 812 TextureVertex mMeshVertices[4]; 813 814 // Drop shadow 815 bool mHasShadow; 816 float mShadowRadius; 817 float mShadowDx; 818 float mShadowDy; 819 int mShadowColor; 820 821 // Draw filters 822 bool mHasDrawFilter; 823 int mPaintFilterClearBits; 824 int mPaintFilterSetBits; 825 SkPaint mFilteredPaint; 826 827 // Various caches 828 Caches& mCaches; 829 830 // List of rectangles to clear after saveLayer() is invoked 831 Vector<Rect*> mLayers; 832 // List of functors to invoke after a frame is drawn 833 SortedVector<Functor*> mFunctors; 834 // List of layers to update at the beginning of a frame 835 Vector<Layer*> mLayerUpdates; 836 837 // Indentity matrix 838 const mat4 mIdentity; 839 840 // Indicates whether the clip must be restored 841 bool mDirtyClip; 842 843 // The following fields are used to setup drawing 844 // Used to describe the shaders to generate 845 ProgramDescription mDescription; 846 // Color description 847 bool mColorSet; 848 float mColorA, mColorR, mColorG, mColorB; 849 // Indicates that the shader should get a color 850 bool mSetShaderColor; 851 // Current texture unit 852 GLuint mTextureUnit; 853 // Track dirty regions, true by default 854 bool mTrackDirtyRegions; 855 // Indicate whether we are drawing an opaque frame 856 bool mOpaqueFrame; 857 858 // See PROPERTY_DISABLE_SCISSOR_OPTIMIZATION in 859 // Properties.h 860 bool mScissorOptimizationDisabled; 861 862 // No-ops start/endTiling when set 863 bool mSuppressTiling; 864 865 friend class DisplayListRenderer; 866 867}; // class OpenGLRenderer 868 869}; // namespace uirenderer 870}; // namespace android 871 872#endif // ANDROID_HWUI_OPENGL_RENDERER_H 873