src/gpu/GrDrawTarget.h

   1 /*
   2  * Copyright 2010 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #ifndef GrDrawTarget_DEFINED
   9 #define GrDrawTarget_DEFINED
  10
  11 #include "GrClip.h"
  12 #include "GrClipMaskManager.h"
  13 #include "GrContext.h"
  14 #include "GrPathProcessor.h"
  15 #include "GrPrimitiveProcessor.h"
  16 #include "GrIndexBuffer.h"
  17 #include "GrPathRendering.h"
  18 #include "GrPipelineBuilder.h"
  19 #include "GrTraceMarker.h"
  20 #include "GrVertexBuffer.h"
  21
  22 #include "SkClipStack.h"
  23 #include "SkMatrix.h"
  24 #include "SkPath.h"
  25 #include "SkStrokeRec.h"
  26 #include "SkTArray.h"
  27 #include "SkTLazy.h"
  28 #include "SkTypes.h"
  29 #include "SkXfermode.h"
  30
  31 class GrBatch;
  32 class GrClip;
  33 class GrDrawTargetCaps;
  34 class GrGeometryProcessor;
  35 class GrPath;
  36 class GrPathRange;
  37 class GrPipeline;
  38
  39 class GrDrawTarget : public SkRefCnt {
  40 public:
  41     SK_DECLARE_INST_COUNT(GrDrawTarget)
  42
  43     typedef GrPathRange::PathIndexType PathIndexType;
  44     typedef GrPathRendering::PathTransformType PathTransformType;
  45
  46     ///////////////////////////////////////////////////////////////////////////
  47
  48     // The context may not be fully constructed and should not be used during GrDrawTarget
  49     // construction.
  50     GrDrawTarget(GrContext* context);
  51     virtual ~GrDrawTarget();
  52
  53     /**
  54      * Gets the capabilities of the draw target.
  55      */
  56     const GrDrawTargetCaps* caps() const { return fCaps.get(); }
  57
  58     /**
  59      * There are two types of "sources" of geometry (vertices and indices) for
  60      * draw calls made on the target. When performing an indexed draw, the
  61      * indices and vertices can use different source types. Once a source is
  62      * specified it can be used for multiple draws. However, the time at which
  63      * the geometry data is no longer editable depends on the source type.
  64      *
  65      * Sometimes it is necessary to perform a draw while upstack code has
  66      * already specified geometry that it isn't finished with. So there are push
  67      * and pop methods. This allows the client to push the sources, draw
  68      * something using alternate sources, and then pop to restore the original
  69      * sources.
  70      *
  71      * Aside from pushes and pops, a source remains valid until another source
  72      * is set or resetVertexSource / resetIndexSource is called. Drawing from
  73      * a reset source is an error.
  74      *
  75      * The two types of sources are:
  76      *
  77      * 1. Reserve. This is most useful when the caller has data it must
  78      *    transform before drawing and is not long-lived. The caller requests
  79      *    that the draw target make room for some amount of vertex and/or index
  80      *    data. The target provides ptrs to hold the vertex and/or index data.
  81      *
  82      *    The data is writable up until the next drawIndexed, drawNonIndexed,
  83      *    drawIndexedInstances, drawRect, copySurface, or pushGeometrySource. At
  84      *    this point the data is frozen and the ptrs are no longer valid.
  85      *
  86      *    Where the space is allocated and how it is uploaded to the GPU is
  87      *    subclass-dependent.
  88      *
  89      * 2. Vertex and Index Buffers. This is most useful for geometry that will
  90      *    is long-lived. When the data in the buffer is consumed depends on the
  91      *    GrDrawTarget subclass. For deferred subclasses the caller has to
  92      *    guarantee that the data is still available in the buffers at playback.
  93      *    (TODO: Make this more automatic as we have done for read/write pixels)
  94      */
  95
  96     /**
  97      * Reserves space for vertices and/or indices. Zero can be specifed as
  98      * either the vertex or index count if the caller desires to only reserve
  99      * space for only indices or only vertices. If zero is specifed for
 100      * vertexCount then the vertex source will be unmodified and likewise for
 101      * indexCount.
 102      *
 103      * If the function returns true then the reserve suceeded and the vertices
 104      * and indices pointers will point to the space created.
 105      *
 106      * If the target cannot make space for the request then this function will
 107      * return false. If vertexCount was non-zero then upon failure the vertex
 108      * source is reset and likewise for indexCount.
 109      *
 110      * The pointers to the space allocated for vertices and indices remain valid
 111      * until a drawIndexed, drawNonIndexed, drawIndexedInstances, drawRect,
 112      * copySurface, or push/popGeomtrySource is called. At that point logically a
 113      * snapshot of the data is made and the pointers are invalid.
 114      *
 115      * @param vertexCount  the number of vertices to reserve space for. Can be
 116      *                     0. Vertex size is queried from the current GrPipelineBuilder.
 117      * @param indexCount   the number of indices to reserve space for. Can be 0.
 118      * @param vertices     will point to reserved vertex space if vertexCount is
 119      *                     non-zero. Illegal to pass NULL if vertexCount > 0.
 120      * @param indices      will point to reserved index space if indexCount is
 121      *                     non-zero. Illegal to pass NULL if indexCount > 0.
 122      */
 123      bool reserveVertexAndIndexSpace(int vertexCount,
 124                                      size_t vertexStride,
 125                                      int indexCount,
 126                                      void** vertices,
 127                                      void** indices);
 128
 129     /**
 130      * Provides hints to caller about the number of vertices and indices
 131      * that can be allocated cheaply. This can be useful if caller is reserving
 132      * space but doesn't know exactly how much geometry is needed.
 133      *
 134      * Also may hint whether the draw target should be flushed first. This is
 135      * useful for deferred targets.
 136      *
 137      * @param vertexCount  in: hint about how many vertices the caller would
 138      *                     like to allocate. Vertex size is queried from the
 139      *                     current GrPipelineBuilder.
 140      *                     out: a hint about the number of vertices that can be
 141      *                     allocated cheaply. Negative means no hint.
 142      *                     Ignored if NULL.
 143      * @param indexCount   in: hint about how many indices the caller would
 144      *                     like to allocate.
 145      *                     out: a hint about the number of indices that can be
 146      *                     allocated cheaply. Negative means no hint.
 147      *                     Ignored if NULL.
 148      *
 149      * @return  true if target should be flushed based on the input values.
 150      */
 151     virtual bool geometryHints(size_t vertexStride, int* vertexCount, int* indexCount) const;
 152
 153     /**
 154      * Sets source of vertex data for the next draw. Data does not have to be
 155      * in the buffer until drawIndexed, drawNonIndexed, or drawIndexedInstances.
 156      *
 157      * @param buffer        vertex buffer containing vertex data. Must be
 158      *                      unlocked before draw call. Vertex size is queried
 159      *                      from current GrPipelineBuilder.
 160      */
 161     void setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride);
 162
 163     /**
 164      * Sets source of index data for the next indexed draw. Data does not have
 165      * to be in the buffer until drawIndexed.
 166      *
 167      * @param buffer index buffer containing indices. Must be unlocked
 168      *               before indexed draw call.
 169      */
 170     void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
 171
 172     /**
 173      * Resets vertex source. Drawing from reset vertices is illegal. Set vertex
 174      * source to reserved, array, or buffer before next draw. May be able to free
 175      * up temporary storage allocated by setVertexSourceToArray or
 176      * reserveVertexSpace.
 177      */
 178     void resetVertexSource();
 179
 180     /**
 181      * Resets index source. Indexed Drawing from reset indices is illegal. Set
 182      * index source to reserved, array, or buffer before next indexed draw. May
 183      * be able to free up temporary storage allocated by setIndexSourceToArray
 184      * or reserveIndexSpace.
 185      */
 186     void resetIndexSource();
 187
 188     /**
 189      * Query to find out if the vertex or index source is reserved.
 190      */
 191     bool hasReservedVerticesOrIndices() const {
 192         return kReserved_GeometrySrcType == this->getGeomSrc().fVertexSrc ||
 193         kReserved_GeometrySrcType == this->getGeomSrc().fIndexSrc;
 194     }
 195
 196     /**
 197      * Pushes and resets the vertex/index sources. Any reserved vertex / index
 198      * data is finalized (i.e. cannot be updated after the matching pop but can
 199      * be drawn from). Must be balanced by a pop.
 200      */
 201     void pushGeometrySource();
 202
 203     /**
 204      * Pops the vertex / index sources from the matching push.
 205      */
 206     void popGeometrySource();
 207
 208     /**
 209      * Draws indexed geometry using the current state and current vertex / index
 210      * sources.
 211      *
 212      * @param type         The type of primitives to draw.
 213      * @param startVertex  the vertex in the vertex array/buffer corresponding
 214      *                     to index 0
 215      * @param startIndex   first index to read from index src.
 216      * @param vertexCount  one greater than the max index.
 217      * @param indexCount   the number of index elements to read. The index count
 218      *                     is effectively trimmed to the last completely
 219      *                     specified primitive.
 220      * @param devBounds    optional bounds hint. This is a promise from the caller,
 221      *                     not a request for clipping.
 222      */
 223     void drawIndexed(GrPipelineBuilder*,
 224                      const GrGeometryProcessor*,
 225                      GrPrimitiveType type,
 226                      int startVertex,
 227                      int startIndex,
 228                      int vertexCount,
 229                      int indexCount,
 230                      const SkRect* devBounds = NULL);
 231
 232     /**
 233      * Draws non-indexed geometry using the current state and current vertex
 234      * sources.
 235      *
 236      * @param type         The type of primitives to draw.
 237      * @param startVertex  the vertex in the vertex array/buffer corresponding
 238      *                     to index 0
 239      * @param vertexCount  one greater than the max index.
 240      * @param devBounds    optional bounds hint. This is a promise from the caller,
 241      *                     not a request for clipping.
 242      */
 243     void drawNonIndexed(GrPipelineBuilder*,
 244                         const GrGeometryProcessor*,
 245                         GrPrimitiveType type,
 246                         int startVertex,
 247                         int vertexCount,
 248                         const SkRect* devBounds = NULL);
 249
 250     // TODO devbounds should live on the batch
 251     void drawBatch(GrPipelineBuilder*, GrBatch*, const SkRect* devBounds = NULL);
 252
 253     /**
 254      * Draws path into the stencil buffer. The fill must be either even/odd or
 255      * winding (not inverse or hairline). It will respect the HW antialias flag
 256      * on the GrPipelineBuilder (if possible in the 3D API).  Note, we will never have an inverse
 257      * fill with stencil path
 258      */
 259     void stencilPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
 260                      GrPathRendering::FillType);
 261
 262     /**
 263      * Draws a path. Fill must not be a hairline. It will respect the HW
 264      * antialias flag on the GrPipelineBuilder (if possible in the 3D API).
 265      */
 266     void drawPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
 267                   GrPathRendering::FillType);
 268
 269     /**
 270      * Draws the aggregate path from combining multiple. Note that this will not
 271      * always be equivalent to back-to-back calls to drawPath(). It will respect
 272      * the HW antialias flag on the GrPipelineBuilder (if possible in the 3D API).
 273      *
 274      * @param pathRange       Source paths to draw from
 275      * @param indices         Array of path indices to draw
 276      * @param indexType       Data type of the array elements in indexBuffer
 277      * @param transformValues Array of transforms for the individual paths
 278      * @param transformType   Type of transforms in transformBuffer
 279      * @param count           Number of paths to draw
 280      * @param fill            Fill type for drawing all the paths
 281      */
 282     void drawPaths(GrPipelineBuilder*,
 283                    const GrPathProcessor*,
 284                    const GrPathRange* pathRange,
 285                    const void* indices,
 286                    PathIndexType indexType,
 287                    const float transformValues[],
 288                    PathTransformType transformType,
 289                    int count,
 290                    GrPathRendering::FillType fill);
 291
 292     /**
 293      * Helper function for drawing rects. It performs a geometry src push and pop
 294      * and thus will finalize any reserved geometry.
 295      *
 296      * @param rect        the rect to draw
 297      * @param localRect   optional rect that specifies local coords to map onto
 298      *                    rect. If NULL then rect serves as the local coords.
 299      * @param localMatrix Optional local matrix. The local coordinates are specified by localRect,
 300      *                    or if it is NULL by rect. This matrix applies to the coordinate implied by
 301      *                    that rectangle before it is input to GrCoordTransforms that read local
 302      *                    coordinates
 303      */
 304     void drawRect(GrPipelineBuilder* pipelineBuilder,
 305                   GrColor color,
 306                   const SkMatrix& viewMatrix,
 307                   const SkRect& rect,
 308                   const SkRect* localRect,
 309                   const SkMatrix* localMatrix) {
 310         this->onDrawRect(pipelineBuilder, color, viewMatrix, rect, localRect, localMatrix);
 311     }
 312
 313     /**
 314      * Helper for drawRect when the caller doesn't need separate local rects or matrices.
 315      */
 316     void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM,
 317                         const SkRect& rect) {
 318         this->drawRect(ds, color, viewM, rect, NULL, NULL);
 319     }
 320     void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM,
 321                         const SkIRect& irect) {
 322         SkRect rect = SkRect::Make(irect);
 323         this->drawRect(ds, color, viewM, rect, NULL, NULL);
 324     }
 325
 326     /**
 327      * This call is used to draw multiple instances of some geometry with a
 328      * given number of vertices (V) and indices (I) per-instance. The indices in
 329      * the index source must have the form i[k+I] == i[k] + V. Also, all indices
 330      * i[kI] ... i[(k+1)I-1] must be elements of the range kV ... (k+1)V-1. As a
 331      * concrete example, the following index buffer for drawing a series of
 332      * quads each as two triangles each satisfies these conditions with V=4 and
 333      * I=6:
 334      *      (0,1,2,0,2,3, 4,5,6,4,6,7, 8,9,10,8,10,11, ...)
 335      *
 336      * The call assumes that the pattern of indices fills the entire index
 337      * source. The size of the index buffer limits the number of instances that
 338      * can be drawn by the GPU in a single draw. However, the caller may specify
 339      * any (positive) number for instanceCount and if necessary multiple GPU
 340      * draws will be issued. Moreover, when drawIndexedInstances is called
 341      * multiple times it may be possible for GrDrawTarget to group them into a
 342      * single GPU draw.
 343      *
 344      * @param type          the type of primitives to draw
 345      * @param instanceCount the number of instances to draw. Each instance
 346      *                      consists of verticesPerInstance vertices indexed by
 347      *                      indicesPerInstance indices drawn as the primitive
 348      *                      type specified by type.
 349      * @param verticesPerInstance   The number of vertices in each instance (V
 350      *                              in the above description).
 351      * @param indicesPerInstance    The number of indices in each instance (I
 352      *                              in the above description).
 353      * @param devBounds    optional bounds hint. This is a promise from the caller,
 354      *                     not a request for clipping.
 355      */
 356     void drawIndexedInstances(GrPipelineBuilder*,
 357                               const GrGeometryProcessor*,
 358                               GrPrimitiveType type,
 359                               int instanceCount,
 360                               int verticesPerInstance,
 361                               int indicesPerInstance,
 362                               const SkRect* devBounds = NULL);
 363
 364     /**
 365      * Clear the passed in render target. Ignores the GrPipelineBuilder and clip. Clears the whole
 366      * thing if rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire
 367      * render target can be optionally cleared.
 368      */
 369     void clear(const SkIRect* rect,
 370                GrColor color,
 371                bool canIgnoreRect,
 372                GrRenderTarget* renderTarget);
 373
 374     /**
 375      * Discards the contents render target.
 376      **/
 377     virtual void discard(GrRenderTarget*) = 0;
 378
 379     /**
 380      * Called at start and end of gpu trace marking
 381      * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start
 382      * and end of a code block respectively
 383      */
 384     void addGpuTraceMarker(const GrGpuTraceMarker* marker);
 385     void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
 386
 387     /**
 388      * Takes the current active set of markers and stores them for later use. Any current marker
 389      * in the active set is removed from the active set and the targets remove function is called.
 390      * These functions do not work as a stack so you cannot call save a second time before calling
 391      * restore. Also, it is assumed that when restore is called the current active set of markers
 392      * is empty. When the stored markers are added back into the active set, the targets add marker
 393      * is called.
 394      */
 395     void saveActiveTraceMarkers();
 396     void restoreActiveTraceMarkers();
 397
 398     /**
 399      * Copies a pixel rectangle from one surface to another. This call may finalize
 400      * reserved vertex/index data (as though a draw call was made). The src pixels
 401      * copied are specified by srcRect. They are copied to a rect of the same
 402      * size in dst with top left at dstPoint. If the src rect is clipped by the
 403      * src bounds then  pixel values in the dst rect corresponding to area clipped
 404      * by the src rect are not overwritten. This method can fail and return false
 405      * depending on the type of surface, configs, etc, and the backend-specific
 406      * limitations. If rect is clipped out entirely by the src or dst bounds then
 407      * true is returned since there is no actual copy necessary to succeed.
 408      */
 409     bool copySurface(GrSurface* dst,
 410                      GrSurface* src,
 411                      const SkIRect& srcRect,
 412                      const SkIPoint& dstPoint);
 413     /**
 414      * Function that determines whether a copySurface call would succeed without actually
 415      * performing the copy.
 416      */
 417     bool canCopySurface(const GrSurface* dst,
 418                         const GrSurface* src,
 419                         const SkIRect& srcRect,
 420                         const SkIPoint& dstPoint);
 421
 422     /**
 423      * Release any resources that are cached but not currently in use. This
 424      * is intended to give an application some recourse when resources are low.
 425      */
 426     virtual void purgeResources() {};
 427
 428     ////////////////////////////////////////////////////////////////////////////
 429
 430     class AutoReleaseGeometry : public ::SkNoncopyable {
 431     public:
 432         AutoReleaseGeometry(GrDrawTarget*  target,
 433                             int            vertexCount,
 434                             size_t         vertexStride,
 435                             int            indexCount);
 436         AutoReleaseGeometry();
 437         ~AutoReleaseGeometry();
 438         bool set(GrDrawTarget*  target,
 439                  int            vertexCount,
 440                  size_t         vertexStride,
 441                  int            indexCount);
 442         bool succeeded() const { return SkToBool(fTarget); }
 443         void* vertices() const { SkASSERT(this->succeeded()); return fVertices; }
 444         void* indices() const { SkASSERT(this->succeeded()); return fIndices; }
 445         SkPoint* positions() const {
 446             return static_cast<SkPoint*>(this->vertices());
 447         }
 448
 449     private:
 450         void reset();
 451
 452         GrDrawTarget* fTarget;
 453         void*         fVertices;
 454         void*         fIndices;
 455     };
 456
 457     ////////////////////////////////////////////////////////////////////////////
 458
 459     /**
 460      * Saves the geometry src state at construction and restores in the destructor. It also saves
 461      * and then restores the vertex attrib state.
 462      */
 463     class AutoGeometryPush : public ::SkNoncopyable {
 464     public:
 465         AutoGeometryPush(GrDrawTarget* target) {
 466             SkASSERT(target);
 467             fTarget = target;
 468             target->pushGeometrySource();
 469         }
 470
 471         ~AutoGeometryPush() { fTarget->popGeometrySource(); }
 472
 473     private:
 474         GrDrawTarget*                           fTarget;
 475     };
 476
 477     ///////////////////////////////////////////////////////////////////////////
 478     // Draw execution tracking (for font atlases and other resources)
 479     class DrawToken {
 480     public:
 481         DrawToken(GrDrawTarget* drawTarget, uint32_t drawID) :
 482                   fDrawTarget(drawTarget), fDrawID(drawID) {}
 483
 484         bool isIssued() { return fDrawTarget && fDrawTarget->isIssued(fDrawID); }
 485
 486     private:
 487         GrDrawTarget*  fDrawTarget;
 488         uint32_t       fDrawID;   // this may wrap, but we're doing direct comparison
 489                                   // so that should be okay
 490     };
 491
 492     virtual DrawToken getCurrentDrawToken() { return DrawToken(this, 0); }
 493
 494     /**
 495      * Used to communicate draws to GPUs / subclasses
 496      */
 497     class DrawInfo {
 498     public:
 499         DrawInfo() { fDevBounds = NULL; }
 500         DrawInfo(const DrawInfo& di) { (*this) = di; }
 501         DrawInfo& operator =(const DrawInfo& di);
 502
 503         GrPrimitiveType primitiveType() const { return fPrimitiveType; }
 504         int startVertex() const { return fStartVertex; }
 505         int startIndex() const { return fStartIndex; }
 506         int vertexCount() const { return fVertexCount; }
 507         int indexCount() const { return fIndexCount; }
 508         int verticesPerInstance() const { return fVerticesPerInstance; }
 509         int indicesPerInstance() const { return fIndicesPerInstance; }
 510         int instanceCount() const { return fInstanceCount; }
 511
 512         void setPrimitiveType(GrPrimitiveType type) { fPrimitiveType = type; }
 513         void setStartVertex(int startVertex) { fStartVertex = startVertex; }
 514         void setStartIndex(int startIndex) { fStartIndex = startIndex; }
 515         void setVertexCount(int vertexCount) { fVertexCount = vertexCount; }
 516         void setIndexCount(int indexCount) { fIndexCount = indexCount; }
 517         void setVerticesPerInstance(int verticesPerI) { fVerticesPerInstance = verticesPerI; }
 518         void setIndicesPerInstance(int indicesPerI) { fIndicesPerInstance = indicesPerI; }
 519         void setInstanceCount(int instanceCount) { fInstanceCount = instanceCount; }
 520
 521         bool isIndexed() const { return fIndexCount > 0; }
 522 #ifdef SK_DEBUG
 523         bool isInstanced() const; // this version is longer because of asserts
 524 #else
 525         bool isInstanced() const { return fInstanceCount > 0; }
 526 #endif
 527
 528         // adds or remove instances
 529         void adjustInstanceCount(int instanceOffset);
 530         // shifts the start vertex
 531         void adjustStartVertex(int vertexOffset);
 532         // shifts the start index
 533         void adjustStartIndex(int indexOffset);
 534
 535         void setDevBounds(const SkRect& bounds) {
 536             fDevBoundsStorage = bounds;
 537             fDevBounds = &fDevBoundsStorage;
 538         }
 539         const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
 540         const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
 541         void setVertexBuffer(const GrVertexBuffer* vb) {
 542             fVertexBuffer.reset(vb);
 543         }
 544         void setIndexBuffer(const GrIndexBuffer* ib) {
 545             fIndexBuffer.reset(ib);
 546         }
 547         const SkRect* getDevBounds() const { return fDevBounds; }
 548
 549     private:
 550         friend class GrDrawTarget;
 551
 552         GrPrimitiveType         fPrimitiveType;
 553
 554         int                     fStartVertex;
 555         int                     fStartIndex;
 556         int                     fVertexCount;
 557         int                     fIndexCount;
 558
 559         int                     fInstanceCount;
 560         int                     fVerticesPerInstance;
 561         int                     fIndicesPerInstance;
 562
 563         SkRect                  fDevBoundsStorage;
 564         SkRect*                 fDevBounds;
 565
 566         GrPendingIOResource<const GrVertexBuffer, kRead_GrIOType> fVertexBuffer;
 567         GrPendingIOResource<const GrIndexBuffer, kRead_GrIOType>  fIndexBuffer;
 568     };
 569
 570     /**
 571      * Used to populate the vertex and index buffer on the draw info before onDraw is called.
 572      */
 573     virtual void setDrawBuffers(DrawInfo*, size_t vertexStride) = 0;;
 574     bool programUnitTest(int maxStages);
 575
 576 protected:
 577     friend class GrTargetCommands; // for PipelineInfo
 578
 579     enum GeometrySrcType {
 580         kNone_GeometrySrcType,     //<! src has not been specified
 581         kReserved_GeometrySrcType, //<! src was set using reserve*Space
 582         kBuffer_GeometrySrcType    //<! src was set using set*SourceToBuffer
 583     };
 584
 585     struct GeometrySrcState {
 586         GeometrySrcType         fVertexSrc;
 587         union {
 588             // valid if src type is buffer
 589             const GrVertexBuffer*   fVertexBuffer;
 590             // valid if src type is reserved or array
 591             int                     fVertexCount;
 592         };
 593
 594         GeometrySrcType         fIndexSrc;
 595         union {
 596             // valid if src type is buffer
 597             const GrIndexBuffer*    fIndexBuffer;
 598             // valid if src type is reserved or array
 599             int                     fIndexCount;
 600         };
 601
 602         size_t                  fVertexSize;
 603     };
 604
 605     int indexCountInCurrentSource() const {
 606         const GeometrySrcState& src = this->getGeomSrc();
 607         switch (src.fIndexSrc) {
 608             case kNone_GeometrySrcType:
 609                 return 0;
 610             case kReserved_GeometrySrcType:
 611                 return src.fIndexCount;
 612             case kBuffer_GeometrySrcType:
 613                 return static_cast<int>(src.fIndexBuffer->gpuMemorySize() / sizeof(uint16_t));
 614             default:
 615                 SkFAIL("Unexpected Index Source.");
 616                 return 0;
 617         }
 618     }
 619
 620     GrContext* getContext() { return fContext; }
 621     const GrContext* getContext() const { return fContext; }
 622
 623     // subclasses must call this in their destructors to ensure all vertex
 624     // and index sources have been released (including those held by
 625     // pushGeometrySource())
 626     void releaseGeometry();
 627
 628     // accessors for derived classes
 629     const GeometrySrcState& getGeomSrc() const { return fGeoSrcStateStack.back(); }
 630     // it is preferable to call this rather than getGeomSrc()->fVertexSize because of the assert.
 631     size_t getVertexSize() const {
 632         // the vertex layout is only valid if a vertex source has been specified.
 633         SkASSERT(this->getGeomSrc().fVertexSrc != kNone_GeometrySrcType);
 634         return this->getGeomSrc().fVertexSize;
 635     }
 636
 637     // Subclass must initialize this in its constructor.
 638     SkAutoTUnref<const GrDrawTargetCaps> fCaps;
 639
 640     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 641
 642     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
 643     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
 644     // needs to be accessed by GLPrograms to setup a correct drawstate
 645     bool setupDstReadIfNecessary(const GrPipelineBuilder&,
 646                                  const GrProcOptInfo& colorPOI,
 647                                  const GrProcOptInfo& coveragePOI,
 648                                  GrDeviceCoordTexture* dstCopy,
 649                                  const SkRect* drawBounds);
 650
 651     struct PipelineInfo {
 652         PipelineInfo(GrPipelineBuilder* pipelineBuilder, GrScissorState* scissor,
 653                      const GrPrimitiveProcessor* primProc,
 654                      const SkRect* devBounds, GrDrawTarget* target);
 655
 656         PipelineInfo(GrPipelineBuilder* pipelineBuilder, GrScissorState* scissor,
 657                      const GrBatch* batch, const SkRect* devBounds,
 658                      GrDrawTarget* target);
 659
 660         bool willBlendWithDst(const GrPrimitiveProcessor* primProc) const {
 661             return fPipelineBuilder->willBlendWithDst(primProc);
 662         }
 663     private:
 664         friend class GrDrawTarget;
 665
 666         bool mustSkipDraw() const { return (NULL == fPipelineBuilder); }
 667
 668         GrPipelineBuilder*      fPipelineBuilder;
 669         GrScissorState*         fScissor;
 670         GrProcOptInfo           fColorPOI;
 671         GrProcOptInfo           fCoveragePOI;
 672         GrDeviceCoordTexture    fDstCopy;
 673     };
 674
 675     void setupPipeline(const PipelineInfo& pipelineInfo, GrPipeline* pipeline);
 676
 677     // A subclass can optionally overload this function to be notified before
 678     // vertex and index space is reserved.
 679     virtual void willReserveVertexAndIndexSpace(int vertexCount,
 680                                                 size_t vertexStride,
 681                                                 int indexCount) {}
 682
 683 private:
 684     /**
 685      * This will be called before allocating a texture as a dst for copySurface. This function
 686      * populates the dstDesc's config, flags, and origin so as to maximize efficiency and guarantee
 687      * success of the copySurface call.
 688      */
 689     void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* dstDesc) {
 690         if (!this->onInitCopySurfaceDstDesc(src, dstDesc)) {
 691             dstDesc->fOrigin = kDefault_GrSurfaceOrigin;
 692             dstDesc->fFlags = kRenderTarget_GrSurfaceFlag;
 693             dstDesc->fConfig = src->config();
 694         }
 695     }
 696
 697     /** Internal implementation of canCopySurface. */
 698     bool internalCanCopySurface(const GrSurface* dst,
 699                                 const GrSurface* src,
 700                                 const SkIRect& clippedSrcRect,
 701                                 const SkIPoint& clippedDstRect);
 702
 703     // implemented by subclass to allocate space for reserved geom
 704     virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) = 0;
 705     virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
 706     // implemented by subclass to handle release of reserved geom space
 707     virtual void releaseReservedVertexSpace() = 0;
 708     virtual void releaseReservedIndexSpace() = 0;
 709     // subclass overrides to be notified just before geo src state is pushed/popped.
 710     virtual void geometrySourceWillPush() = 0;
 711     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
 712     // subclass called to perform drawing
 713     virtual void onDraw(const GrGeometryProcessor*, const DrawInfo&, const PipelineInfo&) = 0;
 714     virtual void onDrawBatch(GrBatch*, const PipelineInfo&) = 0;
 715     // TODO copy in order drawbuffer onDrawRect to here
 716     virtual void onDrawRect(GrPipelineBuilder*,
 717                             GrColor color,
 718                             const SkMatrix& viewMatrix,
 719                             const SkRect& rect,
 720                             const SkRect* localRect,
 721                             const SkMatrix* localMatrix) = 0;
 722
 723     virtual void onStencilPath(const GrPipelineBuilder&,
 724                                const GrPathProcessor*,
 725                                const GrPath*,
 726                                const GrScissorState&,
 727                                const GrStencilSettings&) = 0;
 728     virtual void onDrawPath(const GrPathProcessor*,
 729                             const GrPath*,
 730                             const GrStencilSettings&,
 731                             const PipelineInfo&) = 0;
 732     virtual void onDrawPaths(const GrPathProcessor*,
 733                              const GrPathRange*,
 734                              const void* indices,
 735                              PathIndexType,
 736                              const float transformValues[],
 737                              PathTransformType,
 738                              int count,
 739                              const GrStencilSettings&,
 740                              const PipelineInfo&) = 0;
 741
 742     virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
 743                          GrRenderTarget* renderTarget) = 0;
 744
 745     /** The subclass will get a chance to copy the surface for falling back to the default
 746         implementation, which simply draws a rectangle (and fails if dst isn't a render target). It
 747         should assume that any clipping has already been performed on the rect and point. It won't
 748         be called if the copy can be skipped. */
 749     virtual bool onCopySurface(GrSurface* dst,
 750                                GrSurface* src,
 751                                const SkIRect& srcRect,
 752                                const SkIPoint& dstPoint) = 0;
 753
 754     /** Indicates whether onCopySurface would succeed. It should assume that any clipping has
 755         already been performed on the rect and point. It won't be called if the copy can be
 756         skipped. */
 757     virtual bool onCanCopySurface(const GrSurface* dst,
 758                                   const GrSurface* src,
 759                                   const SkIRect& srcRect,
 760                                   const SkIPoint& dstPoint) = 0;
 761     /**
 762      * This will be called before allocating a texture to be a dst for onCopySurface. Only the
 763      * dstDesc's config, flags, and origin need be set by the function. If the subclass cannot
 764      * create a surface that would succeed its implementation of onCopySurface, it should return
 765      * false. The base class will fall back to creating a render target to draw into using the src.
 766      */
 767     virtual bool onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* dstDesc) = 0;
 768
 769     // helpers for reserving vertex and index space.
 770     bool reserveVertexSpace(size_t vertexSize,
 771                             int vertexCount,
 772                             void** vertices);
 773     bool reserveIndexSpace(int indexCount, void** indices);
 774
 775     // called by drawIndexed and drawNonIndexed. Use a negative indexCount to
 776     // indicate non-indexed drawing.
 777     bool checkDraw(const GrPipelineBuilder&,
 778                    const GrGeometryProcessor*,
 779                    GrPrimitiveType type,
 780                    int startVertex,
 781                    int startIndex,
 782                    int vertexCount,
 783                    int indexCount) const;
 784     // called when setting a new vert/idx source to unref prev vb/ib
 785     void releasePreviousVertexSource();
 786     void releasePreviousIndexSource();
 787
 788     // Check to see if this set of draw commands has been sent out
 789     virtual bool       isIssued(uint32_t drawID) { return true; }
 790     void getPathStencilSettingsForFilltype(GrPathRendering::FillType,
 791                                            const GrStencilBuffer*,
 792                                            GrStencilSettings*);
 793     virtual GrClipMaskManager* clipMaskManager() = 0;
 794     virtual bool setupClip(GrPipelineBuilder*,
 795                            GrPipelineBuilder::AutoRestoreFragmentProcessors*,
 796                            GrPipelineBuilder::AutoRestoreStencil*,
 797                            GrScissorState*,
 798                            const SkRect* devBounds) = 0;
 799
 800     enum {
 801         kPreallocGeoSrcStateStackCnt = 4,
 802     };
 803     SkSTArray<kPreallocGeoSrcStateStackCnt, GeometrySrcState, true> fGeoSrcStateStack;
 804     // The context owns us, not vice-versa, so this ptr is not ref'ed by DrawTarget.
 805     GrContext*                                                      fContext;
 806     // To keep track that we always have at least as many debug marker adds as removes
 807     int                                                             fGpuTraceMarkerCount;
 808     GrTraceMarkerSet                                                fActiveTraceMarkers;
 809     GrTraceMarkerSet                                                fStoredTraceMarkers;
 810
 811     typedef SkRefCnt INHERITED;
 812 };
 813
 814 /*
 815  * This class is JUST for clip mask manager.  Everyone else should just use draw target above.
 816  */
 817 class GrClipTarget : public GrDrawTarget {
 818 public:
 819     GrClipTarget(GrContext* context) : INHERITED(context) {
 820         fClipMaskManager.setClipTarget(this);
 821     }
 822
 823     /* Clip mask manager needs access to the context.
 824      * TODO we only need a very small subset of context in the CMM.
 825      */
 826     GrContext* getContext() { return INHERITED::getContext(); }
 827     const GrContext* getContext() const { return INHERITED::getContext(); }
 828
 829     /**
 830      * Clip Mask Manager(and no one else) needs to clear private stencil bits.
 831      * ClipTarget subclass sets clip bit in the stencil buffer. The subclass
 832      * is free to clear the remaining bits to zero if masked clears are more
 833      * expensive than clearing all bits.
 834      */
 835     virtual void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* = NULL) = 0;
 836
 837     /**
 838      * Release any resources that are cached but not currently in use. This
 839      * is intended to give an application some recourse when resources are low.
 840      */
 841     void purgeResources() override {
 842         // The clip mask manager can rebuild all its clip masks so just
 843         // get rid of them all.
 844         fClipMaskManager.purgeResources();
 845     };
 846
 847 protected:
 848     GrClipMaskManager           fClipMaskManager;
 849
 850 private:
 851     GrClipMaskManager* clipMaskManager() override { return &fClipMaskManager; }
 852
 853     virtual bool setupClip(GrPipelineBuilder*,
 854                            GrPipelineBuilder::AutoRestoreFragmentProcessors*,
 855                            GrPipelineBuilder::AutoRestoreStencil*,
 856                            GrScissorState* scissorState,
 857                            const SkRect* devBounds) override;
 858
 859     typedef GrDrawTarget INHERITED;
 860 };
 861
 862 #endif