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 <SkCanvas.h> 25 #include <SkColorFilter.h> 26 #include <SkMatrix.h> 27 #include <SkPaint.h> 28 #include <SkRegion.h> 29 #include <SkXfermode.h> 30 31 #include <utils/Blur.h> 32 #include <utils/Functor.h> 33 #include <utils/RefBase.h> 34 #include <utils/SortedVector.h> 35 #include <utils/Vector.h> 36 37 #include <cutils/compiler.h> 38 39 #include <androidfw/ResourceTypes.h> 40 41 #include "Debug.h" 42 #include "Extensions.h" 43 #include "Matrix.h" 44 #include "Program.h" 45 #include "Rect.h" 46 #include "Renderer.h" 47 #include "Snapshot.h" 48 #include "StatefulBaseRenderer.h" 49 #include "UvMapper.h" 50 #include "Vertex.h" 51 #include "Caches.h" 52 #include "CanvasProperty.h" 53 54 class SkShader; 55 56 namespace android { 57 namespace uirenderer { 58 59 class DeferredDisplayState; 60 class RenderState; 61 class RenderNode; 62 class TextSetupFunctor; 63 class VertexBuffer; 64 65 struct DrawModifiers { 66 DrawModifiers() { 67 reset(); 68 } 69 70 void reset() { 71 memset(this, 0, sizeof(DrawModifiers)); 72 } 73 74 float mOverrideLayerAlpha; 75 76 // Draw filters 77 bool mHasDrawFilter; 78 int mPaintFilterClearBits; 79 int mPaintFilterSetBits; 80 }; 81 82 enum StateDeferFlags { 83 kStateDeferFlag_Draw = 0x1, 84 kStateDeferFlag_Clip = 0x2 85 }; 86 87 enum ClipSideFlags { 88 kClipSide_None = 0x0, 89 kClipSide_Left = 0x1, 90 kClipSide_Top = 0x2, 91 kClipSide_Right = 0x4, 92 kClipSide_Bottom = 0x8, 93 kClipSide_Full = 0xF, 94 kClipSide_ConservativeFull = 0x1F 95 }; 96 97 enum VertexBufferDisplayFlags { 98 kVertexBuffer_Offset = 0x1, 99 kVertexBuffer_ShadowInterp = 0x2, 100 }; 101 102 /** 103 * Defines additional transformation that should be applied by the model view matrix, beyond that of 104 * the currentTransform() 105 */ 106 enum ModelViewMode { 107 /** 108 * Used when the model view should simply translate geometry passed to the shader. The resulting 109 * matrix will be a simple translation. 110 */ 111 kModelViewMode_Translate = 0, 112 113 /** 114 * Used when the model view should translate and scale geometry. The resulting matrix will be a 115 * translation + scale. This is frequently used together with VBO 0, the (0,0,1,1) rect. 116 */ 117 kModelViewMode_TranslateAndScale = 1, 118 }; 119 120 /////////////////////////////////////////////////////////////////////////////// 121 // Renderer 122 /////////////////////////////////////////////////////////////////////////////// 123 /** 124 * OpenGL Renderer implementation. 125 */ 126 class OpenGLRenderer : public StatefulBaseRenderer { 127 public: 128 OpenGLRenderer(RenderState& renderState); 129 virtual ~OpenGLRenderer(); 130 131 void initProperties(); 132 void initLight(const Vector3& lightCenter, float lightRadius, 133 uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha); 134 135 virtual void onViewportInitialized(); 136 virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque); 137 virtual void finish(); 138 139 void setCountOverdrawEnabled(bool enabled) { 140 mCountOverdraw = enabled; 141 } 142 143 float getOverdraw() { 144 return mCountOverdraw ? mOverdraw : 0.0f; 145 } 146 147 virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty); 148 149 void pushLayerUpdate(Layer* layer); 150 void cancelLayerUpdate(Layer* layer); 151 void clearLayerUpdates(); 152 void flushLayerUpdates(); 153 void markLayersAsBuildLayers(); 154 155 virtual int saveLayer(float left, float top, float right, float bottom, 156 const SkPaint* paint, int flags) { 157 return saveLayer(left, top, right, bottom, paint, flags, NULL); 158 } 159 160 // Specialized saveLayer implementation, which will pass the convexMask to an FBO layer, if 161 // created, which will in turn clip to that mask when drawn back/restored. 162 int saveLayer(float left, float top, float right, float bottom, 163 const SkPaint* paint, int flags, const SkPath* convexMask); 164 165 int saveLayerDeferred(float left, float top, float right, float bottom, 166 const SkPaint* paint, int flags); 167 168 virtual status_t drawRenderNode(RenderNode* displayList, Rect& dirty, int32_t replayFlags = 1); 169 virtual status_t drawLayer(Layer* layer, float x, float y); 170 virtual status_t drawBitmap(const SkBitmap* bitmap, const SkPaint* paint); 171 status_t drawBitmaps(const SkBitmap* bitmap, AssetAtlas::Entry* entry, int bitmapCount, 172 TextureVertex* vertices, bool pureTranslate, const Rect& bounds, const SkPaint* paint); 173 virtual status_t drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop, 174 float srcRight, float srcBottom, float dstLeft, float dstTop, 175 float dstRight, float dstBottom, const SkPaint* paint); 176 virtual status_t drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint); 177 virtual status_t drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight, 178 const float* vertices, const int* colors, const SkPaint* paint); 179 status_t drawPatches(const SkBitmap* bitmap, AssetAtlas::Entry* entry, 180 TextureVertex* vertices, uint32_t indexCount, const SkPaint* paint); 181 virtual status_t drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch, 182 float left, float top, float right, float bottom, const SkPaint* paint); 183 status_t drawPatch(const SkBitmap* bitmap, const Patch* mesh, AssetAtlas::Entry* entry, 184 float left, float top, float right, float bottom, const SkPaint* paint); 185 virtual status_t drawColor(int color, SkXfermode::Mode mode); 186 virtual status_t drawRect(float left, float top, float right, float bottom, 187 const SkPaint* paint); 188 virtual status_t drawRoundRect(float left, float top, float right, float bottom, 189 float rx, float ry, const SkPaint* paint); 190 virtual status_t drawCircle(float x, float y, float radius, const SkPaint* paint); 191 virtual status_t drawOval(float left, float top, float right, float bottom, 192 const SkPaint* paint); 193 virtual status_t drawArc(float left, float top, float right, float bottom, 194 float startAngle, float sweepAngle, bool useCenter, const SkPaint* paint); 195 virtual status_t drawPath(const SkPath* path, const SkPaint* paint); 196 virtual status_t drawLines(const float* points, int count, const SkPaint* paint); 197 virtual status_t drawPoints(const float* points, int count, const SkPaint* paint); 198 virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, const SkPath* path, 199 float hOffset, float vOffset, const SkPaint* paint); 200 virtual status_t drawPosText(const char* text, int bytesCount, int count, 201 const float* positions, const SkPaint* paint); 202 virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y, 203 const float* positions, const SkPaint* paint, float totalAdvance, const Rect& bounds, 204 DrawOpMode drawOpMode = kDrawOpMode_Immediate); 205 virtual status_t drawRects(const float* rects, int count, const SkPaint* paint); 206 207 status_t drawShadow(float casterAlpha, 208 const VertexBuffer* ambientShadowVertexBuffer, const VertexBuffer* spotShadowVertexBuffer); 209 210 virtual void resetPaintFilter(); 211 virtual void setupPaintFilter(int clearBits, int setBits); 212 213 // If this value is set to < 1.0, it overrides alpha set on layer (see drawBitmap, drawLayer) 214 void setOverrideLayerAlpha(float alpha) { mDrawModifiers.mOverrideLayerAlpha = alpha; } 215 216 const SkPaint* filterPaint(const SkPaint* paint); 217 218 /** 219 * Store the current display state (most importantly, the current clip and transform), and 220 * additionally map the state's bounds from local to window coordinates. 221 * 222 * Returns true if quick-rejected 223 */ 224 bool storeDisplayState(DeferredDisplayState& state, int stateDeferFlags); 225 void restoreDisplayState(const DeferredDisplayState& state, bool skipClipRestore = false); 226 void setupMergedMultiDraw(const Rect* clipRect); 227 228 const DrawModifiers& getDrawModifiers() { return mDrawModifiers; } 229 void setDrawModifiers(const DrawModifiers& drawModifiers) { mDrawModifiers = drawModifiers; } 230 231 bool isCurrentTransformSimple() { 232 return currentTransform()->isSimple(); 233 } 234 235 Caches& getCaches() { 236 return mCaches; 237 } 238 239 // simple rect clip 240 bool isCurrentClipSimple() { 241 return mSnapshot->clipRegion->isEmpty(); 242 } 243 244 int getViewportWidth() { return currentSnapshot()->getViewportWidth(); } 245 int getViewportHeight() { return currentSnapshot()->getViewportHeight(); } 246 247 /** 248 * Scales the alpha on the current snapshot. This alpha value will be modulated 249 * with other alpha values when drawing primitives. 250 */ 251 void scaleAlpha(float alpha) { 252 mSnapshot->alpha *= alpha; 253 } 254 255 /** 256 * Inserts a named event marker in the stream of GL commands. 257 */ 258 void eventMark(const char* name) const; 259 260 /** 261 * Inserts a formatted event marker in the stream of GL commands. 262 */ 263 void eventMarkDEBUG(const char *fmt, ...) const; 264 265 /** 266 * Inserts a named group marker in the stream of GL commands. This marker 267 * can be used by tools to group commands into logical groups. A call to 268 * this method must always be followed later on by a call to endMark(). 269 */ 270 void startMark(const char* name) const; 271 272 /** 273 * Closes the last group marker opened by startMark(). 274 */ 275 void endMark() const; 276 277 /** 278 * Gets the alpha and xfermode out of a paint object. If the paint is null 279 * alpha will be 255 and the xfermode will be SRC_OVER. This method does 280 * not multiply the paint's alpha by the current snapshot's alpha, and does 281 * not replace the alpha with the overrideLayerAlpha 282 * 283 * @param paint The paint to extract values from 284 * @param alpha Where to store the resulting alpha 285 * @param mode Where to store the resulting xfermode 286 */ 287 static inline void getAlphaAndModeDirect(const SkPaint* paint, int* alpha, SkXfermode::Mode* mode) { 288 *mode = getXfermodeDirect(paint); 289 *alpha = getAlphaDirect(paint); 290 } 291 292 static inline SkXfermode::Mode getXfermodeDirect(const SkPaint* paint) { 293 if (!paint) return SkXfermode::kSrcOver_Mode; 294 return getXfermode(paint->getXfermode()); 295 } 296 297 static inline int getAlphaDirect(const SkPaint* paint) { 298 if (!paint) return 255; 299 return paint->getAlpha(); 300 } 301 302 struct TextShadow { 303 SkScalar radius; 304 float dx; 305 float dy; 306 SkColor color; 307 }; 308 309 static inline bool getTextShadow(const SkPaint* paint, TextShadow* textShadow) { 310 SkDrawLooper::BlurShadowRec blur; 311 if (paint && paint->getLooper() && paint->getLooper()->asABlurShadow(&blur)) { 312 if (textShadow) { 313 textShadow->radius = Blur::convertSigmaToRadius(blur.fSigma); 314 textShadow->dx = blur.fOffset.fX; 315 textShadow->dy = blur.fOffset.fY; 316 textShadow->color = blur.fColor; 317 } 318 return true; 319 } 320 return false; 321 } 322 323 static inline bool hasTextShadow(const SkPaint* paint) { 324 return getTextShadow(paint, NULL); 325 } 326 327 /** 328 * Build the best transform to use to rasterize text given a full 329 * transform matrix, and whether filteration is needed. 330 * 331 * Returns whether filtration is needed 332 */ 333 bool findBestFontTransform(const mat4& transform, SkMatrix* outMatrix) const; 334 335 #if DEBUG_MERGE_BEHAVIOR 336 void drawScreenSpaceColorRect(float left, float top, float right, float bottom, int color) { 337 mCaches.setScissorEnabled(false); 338 339 // should only be called outside of other draw ops, so stencil can only be in test state 340 bool stencilWasEnabled = mCaches.stencil.isTestEnabled(); 341 mCaches.stencil.disable(); 342 343 drawColorRect(left, top, right, bottom, color, SkXfermode::kSrcOver_Mode, true); 344 345 if (stencilWasEnabled) mCaches.stencil.enableTest(); 346 } 347 #endif 348 349 const Vector3& getLightCenter() const { return currentSnapshot()->getRelativeLightCenter(); } 350 float getLightRadius() const { return mLightRadius; } 351 uint8_t getAmbientShadowAlpha() const { return mAmbientShadowAlpha; } 352 uint8_t getSpotShadowAlpha() const { return mSpotShadowAlpha; } 353 354 protected: 355 /** 356 * Perform the setup specific to a frame. This method does not 357 * issue any OpenGL commands. 358 */ 359 void setupFrameState(float left, float top, float right, float bottom, bool opaque); 360 361 /** 362 * Indicates the start of rendering. This method will setup the 363 * initial OpenGL state (viewport, clearing the buffer, etc.) 364 */ 365 status_t startFrame(); 366 367 /** 368 * Clears the underlying surface if needed. 369 */ 370 virtual status_t clear(float left, float top, float right, float bottom, bool opaque); 371 372 /** 373 * Call this method after updating a layer during a drawing pass. 374 */ 375 void resumeAfterLayer(); 376 377 /** 378 * This method is called whenever a stencil buffer is required. Subclasses 379 * should override this method and call attachStencilBufferToLayer() on the 380 * appropriate layer(s). 381 */ 382 virtual void ensureStencilBuffer(); 383 384 /** 385 * Obtains a stencil render buffer (allocating it if necessary) and 386 * attaches it to the specified layer. 387 */ 388 void attachStencilBufferToLayer(Layer* layer); 389 390 bool quickRejectSetupScissor(float left, float top, float right, float bottom, 391 const SkPaint* paint = NULL); 392 bool quickRejectSetupScissor(const Rect& bounds, const SkPaint* paint = NULL) { 393 return quickRejectSetupScissor(bounds.left, bounds.top, 394 bounds.right, bounds.bottom, paint); 395 } 396 397 /** 398 * Compose the layer defined in the current snapshot with the layer 399 * defined by the previous snapshot. 400 * 401 * The current snapshot *must* be a layer (flag kFlagIsLayer set.) 402 * 403 * @param curent The current snapshot containing the layer to compose 404 * @param previous The previous snapshot to compose the current layer with 405 */ 406 virtual void composeLayer(const Snapshot& current, const Snapshot& previous); 407 408 /** 409 * Marks the specified region as dirty at the specified bounds. 410 */ 411 void dirtyLayerUnchecked(Rect& bounds, Region* region); 412 413 /** 414 * Returns the region of the current layer. 415 */ 416 virtual Region* getRegion() const { 417 return mSnapshot->region; 418 } 419 420 /** 421 * Indicates whether rendering is currently targeted at a layer. 422 */ 423 virtual bool hasLayer() const { 424 return (mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region; 425 } 426 427 /** 428 * Returns the name of the FBO this renderer is rendering into. 429 */ 430 virtual GLuint getTargetFbo() const { 431 return 0; 432 } 433 434 /** 435 * Renders the specified layer as a textured quad. 436 * 437 * @param layer The layer to render 438 * @param rect The bounds of the layer 439 */ 440 void drawTextureLayer(Layer* layer, const Rect& rect); 441 442 /** 443 * Gets the alpha and xfermode out of a paint object. If the paint is null 444 * alpha will be 255 and the xfermode will be SRC_OVER. Accounts for both 445 * snapshot alpha, and overrideLayerAlpha 446 * 447 * @param paint The paint to extract values from 448 * @param alpha Where to store the resulting alpha 449 * @param mode Where to store the resulting xfermode 450 */ 451 inline void getAlphaAndMode(const SkPaint* paint, int* alpha, SkXfermode::Mode* mode) const; 452 453 /** 454 * Gets the alpha from a layer, accounting for snapshot alpha and overrideLayerAlpha 455 * 456 * @param layer The layer from which the alpha is extracted 457 */ 458 inline float getLayerAlpha(const Layer* layer) const; 459 460 /** 461 * Safely retrieves the ColorFilter from the given Paint. If the paint is 462 * null then null is returned. 463 */ 464 static inline SkColorFilter* getColorFilter(const SkPaint* paint) { 465 return paint ? paint->getColorFilter() : NULL; 466 } 467 468 /** 469 * Safely retrieves the Shader from the given Paint. If the paint is 470 * null then null is returned. 471 */ 472 static inline const SkShader* getShader(const SkPaint* paint) { 473 return paint ? paint->getShader() : NULL; 474 } 475 476 /** 477 * Set to true to suppress error checks at the end of a frame. 478 */ 479 virtual bool suppressErrorChecks() const { 480 return false; 481 } 482 483 inline RenderState& renderState() { return mRenderState; } 484 485 private: 486 /** 487 * Discards the content of the framebuffer if supported by the driver. 488 * This method should be called at the beginning of a frame to optimize 489 * rendering on some tiler architectures. 490 */ 491 void discardFramebuffer(float left, float top, float right, float bottom); 492 493 /** 494 * Ensures the state of the renderer is the same as the state of 495 * the GL context. 496 */ 497 void syncState(); 498 499 /** 500 * Tells the GPU what part of the screen is about to be redrawn. 501 * This method will use the current layer space clip rect. 502 * This method needs to be invoked every time getTargetFbo() is 503 * bound again. 504 */ 505 void startTilingCurrentClip(bool opaque = false, bool expand = false); 506 507 /** 508 * Tells the GPU what part of the screen is about to be redrawn. 509 * This method needs to be invoked every time getTargetFbo() is 510 * bound again. 511 */ 512 void startTiling(const Rect& clip, int windowHeight, bool opaque = false, bool expand = false); 513 514 /** 515 * Tells the GPU that we are done drawing the frame or that we 516 * are switching to another render target. 517 */ 518 void endTiling(); 519 520 void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored); 521 522 /** 523 * Sets the clipping rectangle using glScissor. The clip is defined by 524 * the current snapshot's clipRect member. 525 */ 526 void setScissorFromClip(); 527 528 /** 529 * Sets the clipping region using the stencil buffer. The clip region 530 * is defined by the current snapshot's clipRegion member. 531 */ 532 void setStencilFromClip(); 533 534 /** 535 * Given the local bounds of the layer, calculates ... 536 */ 537 void calculateLayerBoundsAndClip(Rect& bounds, Rect& clip, bool fboLayer); 538 539 /** 540 * Given the local bounds + clip of the layer, updates current snapshot's empty/invisible 541 */ 542 void updateSnapshotIgnoreForLayer(const Rect& bounds, const Rect& clip, 543 bool fboLayer, int alpha); 544 545 /** 546 * Creates a new layer stored in the specified snapshot. 547 * 548 * @param snapshot The snapshot associated with the new layer 549 * @param left The left coordinate of the layer 550 * @param top The top coordinate of the layer 551 * @param right The right coordinate of the layer 552 * @param bottom The bottom coordinate of the layer 553 * @param alpha The translucency of the layer 554 * @param mode The blending mode of the layer 555 * @param flags The layer save flags 556 * @param mask A mask to use when drawing the layer back, may be empty 557 * 558 * @return True if the layer was successfully created, false otherwise 559 */ 560 bool createLayer(float left, float top, float right, float bottom, 561 const SkPaint* paint, int flags, const SkPath* convexMask); 562 563 /** 564 * Creates a new layer stored in the specified snapshot as an FBO. 565 * 566 * @param layer The layer to store as an FBO 567 * @param snapshot The snapshot associated with the new layer 568 * @param bounds The bounds of the layer 569 */ 570 bool createFboLayer(Layer* layer, Rect& bounds, Rect& clip); 571 572 /** 573 * Compose the specified layer as a region. 574 * 575 * @param layer The layer to compose 576 * @param rect The layer's bounds 577 */ 578 void composeLayerRegion(Layer* layer, const Rect& rect); 579 580 /** 581 * Compose the specified layer as a simple rectangle. 582 * 583 * @param layer The layer to compose 584 * @param rect The layer's bounds 585 * @param swap If true, the source and destination are swapped 586 */ 587 void composeLayerRect(Layer* layer, const Rect& rect, bool swap = false); 588 589 /** 590 * Clears all the regions corresponding to the current list of layers. 591 * This method MUST be invoked before any drawing operation. 592 */ 593 void clearLayerRegions(); 594 595 /** 596 * Mark the layer as dirty at the specified coordinates. The coordinates 597 * are transformed with the supplied matrix. 598 */ 599 void dirtyLayer(const float left, const float top, 600 const float right, const float bottom, const mat4 transform); 601 602 /** 603 * Mark the layer as dirty at the specified coordinates. 604 */ 605 void dirtyLayer(const float left, const float top, 606 const float right, const float bottom); 607 608 /** 609 * Draws a colored rectangle with the specified color. The specified coordinates 610 * are transformed by the current snapshot's transform matrix unless specified 611 * otherwise. 612 * 613 * @param left The left coordinate of the rectangle 614 * @param top The top coordinate of the rectangle 615 * @param right The right coordinate of the rectangle 616 * @param bottom The bottom coordinate of the rectangle 617 * @param paint The paint containing the color, blending mode, etc. 618 * @param ignoreTransform True if the current transform should be ignored 619 */ 620 void drawColorRect(float left, float top, float right, float bottom, 621 const SkPaint* paint, bool ignoreTransform = false); 622 623 /** 624 * Draws a series of colored rectangles with the specified color. The specified 625 * coordinates are transformed by the current snapshot's transform matrix unless 626 * specified otherwise. 627 * 628 * @param rects A list of rectangles, 4 floats (left, top, right, bottom) 629 * per rectangle 630 * @param paint The paint containing the color, blending mode, etc. 631 * @param ignoreTransform True if the current transform should be ignored 632 * @param dirty True if calling this method should dirty the current layer 633 * @param clip True if the rects should be clipped, false otherwise 634 */ 635 status_t drawColorRects(const float* rects, int count, const SkPaint* paint, 636 bool ignoreTransform = false, bool dirty = true, bool clip = true); 637 638 /** 639 * Draws the shape represented by the specified path texture. 640 * This method invokes drawPathTexture() but takes into account 641 * the extra left/top offset and the texture offset to correctly 642 * position the final shape. 643 * 644 * @param left The left coordinate of the shape to render 645 * @param top The top coordinate of the shape to render 646 * @param texture The texture reprsenting the shape 647 * @param paint The paint to draw the shape with 648 */ 649 status_t drawShape(float left, float top, const PathTexture* texture, const SkPaint* paint); 650 651 /** 652 * Draws the specified texture as an alpha bitmap. Alpha bitmaps obey 653 * different compositing rules. 654 * 655 * @param texture The texture to draw with 656 * @param left The x coordinate of the bitmap 657 * @param top The y coordinate of the bitmap 658 * @param paint The paint to render with 659 */ 660 void drawAlphaBitmap(Texture* texture, float left, float top, const SkPaint* paint); 661 662 /** 663 * Renders a strip of polygons with the specified paint, used for tessellated geometry. 664 * 665 * @param vertexBuffer The VertexBuffer to be drawn 666 * @param paint The paint to render with 667 * @param flags flags with which to draw 668 */ 669 status_t drawVertexBuffer(float translateX, float translateY, const VertexBuffer& vertexBuffer, 670 const SkPaint* paint, int flags = 0); 671 672 /** 673 * Convenience for translating method 674 */ 675 status_t drawVertexBuffer(const VertexBuffer& vertexBuffer, 676 const SkPaint* paint, int flags = 0) { 677 return drawVertexBuffer(0.0f, 0.0f, vertexBuffer, paint, flags); 678 } 679 680 /** 681 * Renders the convex hull defined by the specified path as a strip of polygons. 682 * 683 * @param path The hull of the path to draw 684 * @param paint The paint to render with 685 */ 686 status_t drawConvexPath(const SkPath& path, const SkPaint* paint); 687 688 /** 689 * Draws a textured rectangle with the specified texture. The specified coordinates 690 * are transformed by the current snapshot's transform matrix. 691 * 692 * @param left The left coordinate of the rectangle 693 * @param top The top coordinate of the rectangle 694 * @param right The right coordinate of the rectangle 695 * @param bottom The bottom coordinate of the rectangle 696 * @param texture The texture to use 697 * @param paint The paint containing the alpha, blending mode, etc. 698 */ 699 void drawTextureRect(float left, float top, float right, float bottom, 700 Texture* texture, const SkPaint* paint); 701 702 /** 703 * Draws a textured mesh with the specified texture. If the indices are omitted, 704 * the mesh is drawn as a simple quad. The mesh pointers become offsets when a 705 * VBO is bound. 706 * 707 * @param left The left coordinate of the rectangle 708 * @param top The top coordinate of the rectangle 709 * @param right The right coordinate of the rectangle 710 * @param bottom The bottom coordinate of the rectangle 711 * @param texture The texture name to map onto the rectangle 712 * @param paint The paint containing the alpha, blending mode, colorFilter, etc. 713 * @param blend True if the texture contains an alpha channel 714 * @param vertices The vertices that define the mesh 715 * @param texCoords The texture coordinates of each vertex 716 * @param elementsCount The number of elements in the mesh, required by indices 717 * @param swapSrcDst Whether or not the src and dst blending operations should be swapped 718 * @param ignoreTransform True if the current transform should be ignored 719 * @param vbo The VBO used to draw the mesh 720 * @param modelViewMode Defines whether the model view matrix should be scaled 721 * @param dirty True if calling this method should dirty the current layer 722 */ 723 void drawTextureMesh(float left, float top, float right, float bottom, GLuint texture, 724 const SkPaint* paint, bool blend, 725 GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount, 726 bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0, 727 ModelViewMode modelViewMode = kModelViewMode_TranslateAndScale, bool dirty = true); 728 729 void drawIndexedTextureMesh(float left, float top, float right, float bottom, GLuint texture, 730 const SkPaint* paint, bool blend, 731 GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount, 732 bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0, 733 ModelViewMode modelViewMode = kModelViewMode_TranslateAndScale, bool dirty = true); 734 735 void drawAlpha8TextureMesh(float left, float top, float right, float bottom, 736 GLuint texture, const SkPaint* paint, 737 GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount, 738 bool ignoreTransform, ModelViewMode modelViewMode = kModelViewMode_TranslateAndScale, 739 bool dirty = true); 740 741 /** 742 * Draws the specified list of vertices as quads using indexed GL_TRIANGLES. 743 * If the number of vertices to draw exceeds the number of indices we have 744 * pre-allocated, this method will generate several glDrawElements() calls. 745 */ 746 void issueIndexedQuadDraw(Vertex* mesh, GLsizei quadsCount); 747 748 /** 749 * Draws text underline and strike-through if needed. 750 * 751 * @param text The text to decor 752 * @param bytesCount The number of bytes in the text 753 * @param totalAdvance The total advance in pixels, defines underline/strikethrough length 754 * @param x The x coordinate where the text will be drawn 755 * @param y The y coordinate where the text will be drawn 756 * @param paint The paint to draw the text with 757 */ 758 void drawTextDecorations(float totalAdvance, float x, float y, const SkPaint* paint); 759 760 /** 761 * Draws shadow layer on text (with optional positions). 762 * 763 * @param paint The paint to draw the shadow with 764 * @param text The text to draw 765 * @param bytesCount The number of bytes in the text 766 * @param count The number of glyphs in the text 767 * @param positions The x, y positions of individual glyphs (or NULL) 768 * @param fontRenderer The font renderer object 769 * @param alpha The alpha value for drawing the shadow 770 * @param x The x coordinate where the shadow will be drawn 771 * @param y The y coordinate where the shadow will be drawn 772 */ 773 void drawTextShadow(const SkPaint* paint, const char* text, int bytesCount, int count, 774 const float* positions, FontRenderer& fontRenderer, int alpha, 775 float x, float y); 776 777 /** 778 * Draws a path texture. Path textures are alpha8 bitmaps that need special 779 * compositing to apply colors/filters/etc. 780 * 781 * @param texture The texture to render 782 * @param x The x coordinate where the texture will be drawn 783 * @param y The y coordinate where the texture will be drawn 784 * @param paint The paint to draw the texture with 785 */ 786 void drawPathTexture(const PathTexture* texture, float x, float y, const SkPaint* paint); 787 788 /** 789 * Resets the texture coordinates stored in mMeshVertices. Setting the values 790 * back to default is achieved by calling: 791 * 792 * resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f); 793 * 794 * @param u1 The left coordinate of the texture 795 * @param v1 The bottom coordinate of the texture 796 * @param u2 The right coordinate of the texture 797 * @param v2 The top coordinate of the texture 798 */ 799 void resetDrawTextureTexCoords(float u1, float v1, float u2, float v2); 800 801 /** 802 * Returns true if the specified paint will draw invisible text. 803 */ 804 bool canSkipText(const SkPaint* paint) const; 805 806 /** 807 * Binds the specified texture. The texture unit must have been selected 808 * prior to calling this method. 809 */ 810 inline void bindTexture(GLuint texture) { 811 mCaches.bindTexture(texture); 812 } 813 814 /** 815 * Binds the specified EGLImage texture. The texture unit must have been selected 816 * prior to calling this method. 817 */ 818 inline void bindExternalTexture(GLuint texture) { 819 mCaches.bindTexture(GL_TEXTURE_EXTERNAL_OES, texture); 820 } 821 822 /** 823 * Enable or disable blending as necessary. This function sets the appropriate 824 * blend function based on the specified xfermode. 825 */ 826 inline void chooseBlending(bool blend, SkXfermode::Mode mode, ProgramDescription& description, 827 bool swapSrcDst = false); 828 829 /** 830 * Use the specified program with the current GL context. If the program is already 831 * in use, it will not be bound again. If it is not in use, the current program is 832 * marked unused and the specified program becomes used and becomes the new 833 * current program. 834 * 835 * @param program The program to use 836 * 837 * @return true If the specified program was already in use, false otherwise. 838 */ 839 inline bool useProgram(Program* program); 840 841 /** 842 * Invoked before any drawing operation. This sets required state. 843 */ 844 void setupDraw(bool clear = true); 845 846 /** 847 * Various methods to setup OpenGL rendering. 848 */ 849 void setupDrawWithTexture(bool isAlpha8 = false); 850 void setupDrawWithTextureAndColor(bool isAlpha8 = false); 851 void setupDrawWithExternalTexture(); 852 void setupDrawNoTexture(); 853 void setupDrawVertexAlpha(bool useShadowAlphaInterp); 854 void setupDrawColor(int color, int alpha); 855 void setupDrawColor(float r, float g, float b, float a); 856 void setupDrawAlpha8Color(int color, int alpha); 857 void setupDrawTextGamma(const SkPaint* paint); 858 void setupDrawShader(const SkShader* shader); 859 void setupDrawColorFilter(const SkColorFilter* filter); 860 void setupDrawBlending(const Layer* layer, bool swapSrcDst = false); 861 void setupDrawBlending(const SkPaint* paint, bool blend = true, bool swapSrcDst = false); 862 void setupDrawProgram(); 863 void setupDrawDirtyRegionsDisabled(); 864 865 /** 866 * Setup the current program matrices based upon the nature of the geometry. 867 * 868 * @param mode If kModelViewMode_Translate, the geometry must be translated by the left and top 869 * parameters. If kModelViewMode_TranslateAndScale, the geometry that exists in the (0,0, 1,1) 870 * space must be scaled up and translated to fill the quad provided in (l,t,r,b). These 871 * transformations are stored in the modelView matrix and uploaded to the shader. 872 * 873 * @param offset Set to true if the the matrix should be fudged (translated) slightly to disambiguate 874 * geometry pixel positioning. See Vertex::GeometryFudgeFactor(). 875 * 876 * @param ignoreTransform Set to true if l,t,r,b coordinates already in layer space, 877 * currentTransform() will be ignored. (e.g. when drawing clip in layer coordinates to stencil, 878 * or when simple translation has been extracted) 879 */ 880 void setupDrawModelView(ModelViewMode mode, bool offset, 881 float left, float top, float right, float bottom, bool ignoreTransform = false); 882 void setupDrawColorUniforms(bool hasShader); 883 void setupDrawPureColorUniforms(); 884 885 /** 886 * Setup uniforms for the current shader. 887 * 888 * @param shader SkShader on the current paint. 889 * 890 * @param ignoreTransform Set to true to ignore the transform in shader. 891 */ 892 void setupDrawShaderUniforms(const SkShader* shader, bool ignoreTransform = false); 893 void setupDrawColorFilterUniforms(const SkColorFilter* paint); 894 void setupDrawSimpleMesh(); 895 void setupDrawTexture(GLuint texture); 896 void setupDrawExternalTexture(GLuint texture); 897 void setupDrawTextureTransform(); 898 void setupDrawTextureTransformUniforms(mat4& transform); 899 void setupDrawTextGammaUniforms(); 900 void setupDrawMesh(const GLvoid* vertices, const GLvoid* texCoords = NULL, GLuint vbo = 0); 901 void setupDrawMesh(const GLvoid* vertices, const GLvoid* texCoords, const GLvoid* colors); 902 void setupDrawMeshIndices(const GLvoid* vertices, const GLvoid* texCoords, GLuint vbo = 0); 903 void setupDrawIndexedVertices(GLvoid* vertices); 904 void accountForClear(SkXfermode::Mode mode); 905 906 bool updateLayer(Layer* layer, bool inFrame); 907 void updateLayers(); 908 void flushLayers(); 909 910 #if DEBUG_LAYERS_AS_REGIONS 911 /** 912 * Renders the specified region as a series of rectangles. This method 913 * is used for debugging only. 914 */ 915 void drawRegionRectsDebug(const Region& region); 916 #endif 917 918 /** 919 * Renders the specified region as a series of rectangles. The region 920 * must be in screen-space coordinates. 921 */ 922 void drawRegionRects(const SkRegion& region, const SkPaint& paint, bool dirty = false); 923 924 /** 925 * Draws the current clip region if any. Only when DEBUG_CLIP_REGIONS 926 * is turned on. 927 */ 928 void debugClip(); 929 930 void debugOverdraw(bool enable, bool clear); 931 void renderOverdraw(); 932 void countOverdraw(); 933 934 /** 935 * Should be invoked every time the glScissor is modified. 936 */ 937 inline void dirtyClip() { 938 mDirtyClip = true; 939 } 940 941 inline const UvMapper& getMapper(const Texture* texture) { 942 return texture && texture->uvMapper ? *texture->uvMapper : mUvMapper; 943 } 944 945 /** 946 * Returns a texture object for the specified bitmap. The texture can 947 * come from the texture cache or an atlas. If this method returns 948 * NULL, the texture could not be found and/or allocated. 949 */ 950 Texture* getTexture(const SkBitmap* bitmap); 951 952 /** 953 * Model-view matrix used to position/size objects 954 * 955 * Stores operation-local modifications to the draw matrix that aren't incorporated into the 956 * currentTransform(). 957 * 958 * If generated with kModelViewMode_Translate, mModelViewMatrix will reflect an x/y offset, 959 * e.g. the offset in drawLayer(). If generated with kModelViewMode_TranslateAndScale, 960 * mModelViewMatrix will reflect a translation and scale, e.g. the translation and scale 961 * required to make VBO 0 (a rect of (0,0,1,1)) scaled to match the x,y offset, and width/height 962 * of a bitmap. 963 * 964 * Used as input to SkiaShader transformation. 965 */ 966 mat4 mModelViewMatrix; 967 968 // State used to define the clipping region 969 Rect mTilingClip; 970 // Is the target render surface opaque 971 bool mOpaque; 972 // Is a frame currently being rendered 973 bool mFrameStarted; 974 975 // Used to draw textured quads 976 TextureVertex mMeshVertices[4]; 977 978 // Default UV mapper 979 const UvMapper mUvMapper; 980 981 // shader, filters, and shadow 982 DrawModifiers mDrawModifiers; 983 SkPaint mFilteredPaint; 984 985 // Various caches 986 Caches& mCaches; 987 Extensions& mExtensions; 988 RenderState& mRenderState; 989 990 // List of rectangles to clear after saveLayer() is invoked 991 Vector<Rect*> mLayers; 992 // List of layers to update at the beginning of a frame 993 Vector<Layer*> mLayerUpdates; 994 995 // The following fields are used to setup drawing 996 // Used to describe the shaders to generate 997 ProgramDescription mDescription; 998 // Color description 999 bool mColorSet; 1000 float mColorA, mColorR, mColorG, mColorB; 1001 // Indicates that the shader should get a color 1002 bool mSetShaderColor; 1003 // Current texture unit 1004 GLuint mTextureUnit; 1005 // Track dirty regions, true by default 1006 bool mTrackDirtyRegions; 1007 // Indicate whether we are drawing an opaque frame 1008 bool mOpaqueFrame; 1009 1010 // See PROPERTY_DISABLE_SCISSOR_OPTIMIZATION in 1011 // Properties.h 1012 bool mScissorOptimizationDisabled; 1013 1014 // No-ops start/endTiling when set 1015 bool mSuppressTiling; 1016 bool mFirstFrameAfterResize; 1017 1018 // If true, this renderer will setup drawing to emulate 1019 // an increment stencil buffer in the color buffer 1020 bool mCountOverdraw; 1021 float mOverdraw; 1022 1023 bool mSkipOutlineClip; 1024 1025 // Lighting + shadows 1026 Vector3 mLightCenter; 1027 float mLightRadius; 1028 uint8_t mAmbientShadowAlpha; 1029 uint8_t mSpotShadowAlpha; 1030 1031 friend class Layer; 1032 friend class TextSetupFunctor; 1033 friend class DrawBitmapOp; 1034 friend class DrawPatchOp; 1035 1036 }; // class OpenGLRenderer 1037 1038 }; // namespace uirenderer 1039 }; // namespace android 1040 1041 #endif // ANDROID_HWUI_OPENGL_RENDERER_H 1042