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