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