Split drawing functionality out of GrContext and into new GrDrawContext

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
 #include "GrClip.h"
 #include "GrColor.h"
 #include "GrPaint.h"
 #include "GrPathRendererChain.h"
 #include "GrRenderTarget.h"
 #include "GrTextureProvider.h"
 #include "SkMatrix.h"
 #include "SkPathEffect.h"
 #include "SkTypes.h"
 
 class GrAARectRenderer;
 class GrBatchFontCache;
 struct GrContextOptions;
+class GrDrawContext;
 class GrDrawTarget;
 class GrFragmentProcessor;
 class GrGpu;
 class GrGpuTraceMarker;
 class GrIndexBuffer;
 class GrLayerCache;
 class GrOvalRenderer;
 class GrPath;
 class GrPathRenderer;
 class GrPipelineBuilder;
@@ skipping 117 matching lines @@
      * Purge all the unlocked resources from the cache.
      * This entry point is mainly meant for timing texture uploads
      * and is not defined in normal builds of Skia.
      */
     void purgeAllUnlockedResources();
 
     //////////////////////////////////////////////////////////////////////////
     /// Texture and Render Target Queries
 
     /**
+     * Are shader derivatives supported?
+     */
+    bool shaderDerivativeSupport() const;
+
+    /**
      * Can the provided configuration act as a texture?
      */
     bool isConfigTexturable(GrPixelConfig) const;
 
     /**
      * Can non-power-of-two textures be used with tile modes other than clamp?
      */
     bool npotTextureTileSupport() const;
 
     /**
@@ skipping 33 matching lines @@
      *
      * @param  config the configuration of the render target.
      * @param  dpi the display density in dots per inch.
      *
      * @return sample count that should be perform well and have good enough
      *         rendering quality for the display. Alternatively returns 0 if
      *         MSAA is not supported or recommended to be used by default.
      */
     int getRecommendedSampleCount(GrPixelConfig config, SkScalar dpi) const;
 
-    ///////////////////////////////////////////////////////////////////////////
-    // Draws
-
     /**
-     * Clear the entire or rect of the render target, ignoring any clips.
-     * @param rect  the rect to clear or the whole thing if rect is NULL.
-     * @param color the color to clear to.
-     * @param canIgnoreRect allows partial clears to be converted to whole
-     *                      clears on platforms for which that is cheap
-     * @param target The render target to clear.
+     * Returns a helper object to orchestrate draws. 
+     *
+     * @return a draw context
      */
-    void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect, GrRenderTarget* target);
-
-    /**
-     *  Draw everywhere (respecting the clip) with the paint.
-     */
-    void drawPaint(GrRenderTarget*, const GrClip&, const GrPaint&, const SkMatrix& viewMatrix);
-
-    /**
-     *  Draw the rect using a paint.
-     *  @param paint        describes how to color pixels.
-     *  @param viewMatrix   transformation matrix
-     *  @param strokeInfo   the stroke information (width, join, cap), and.
-     *                      the dash information (intervals, count, phase).
-     *                      If strokeInfo == NULL, then the rect is filled.
-     *                      Otherwise, if stroke width == 0, then the stroke
-     *                      is always a single pixel thick, else the rect is
-     *                      mitered/beveled stroked based on stroke width.
-     *  The rects coords are used to access the paint (through texture matrix)
-     */
-    void drawRect(GrRenderTarget*,
-                  const GrClip&,
-                  const GrPaint& paint,
-                  const SkMatrix& viewMatrix,
-                  const SkRect&,
-                  const GrStrokeInfo* strokeInfo = NULL);
-
-    /**
-     * Maps a rectangle of shader coordinates to a rectangle and draws that rectangle
-     *
-     * @param paint         describes how to color pixels.
-     * @param viewMatrix    transformation matrix which applies to rectToDraw
-     * @param rectToDraw    the rectangle to draw
-     * @param localRect     the rectangle of shader coordinates applied to rectToDraw
-     * @param localMatrix   an optional matrix to transform the shader coordinates before applying
-     *                      to rectToDraw
-     */
-    void drawNonAARectToRect(GrRenderTarget*,
-                             const GrClip&,
-                             const GrPaint& paint,
-                             const SkMatrix& viewMatrix,
-                             const SkRect& rectToDraw,
-                             const SkRect& localRect,
-                             const SkMatrix* localMatrix = NULL);
-
-    /**
-     * Draws a non-AA rect with paint and a localMatrix
-     */
-    void drawNonAARectWithLocalMatrix(GrRenderTarget* rt,
-                                      const GrClip& clip,
-                                      const GrPaint& paint,
-                                      const SkMatrix& viewMatrix,
-                                      const SkRect& rect,
-                                      const SkMatrix& localMatrix) {
-        this->drawNonAARectToRect(rt, clip, paint, viewMatrix, rect, rect, &localMatrix);
+    GrDrawContext* drawContext() {
+        return fDrawingMgr.drawContext();    
     }
 
-    /**
-     *  Draw a roundrect using a paint.
-     *
-     *  @param paint        describes how to color pixels.
-     *  @param viewMatrix   transformation matrix
-     *  @param rrect        the roundrect to draw
-     *  @param strokeInfo   the stroke information (width, join, cap) and
-     *                      the dash information (intervals, count, phase).
-     */
-    void drawRRect(GrRenderTarget*,
-                   const GrClip&,
-                   const GrPaint&,
-                   const SkMatrix& viewMatrix,
-                   const SkRRect& rrect,
-                   const GrStrokeInfo&);
-
-    /**
-     *  Shortcut for drawing an SkPath consisting of nested rrects using a paint.
-     *  Does not support stroking. The result is undefined if outer does not contain
-     *  inner.
-     *
-     *  @param paint        describes how to color pixels.
-     *  @param viewMatrix   transformation matrix
-     *  @param outer        the outer roundrect
-     *  @param inner        the inner roundrect
-     */
-    void drawDRRect(GrRenderTarget*,
-                    const GrClip&,
-                    const GrPaint&,
-                    const SkMatrix& viewMatrix,
-                    const SkRRect& outer,
-                    const SkRRect& inner);
-
-
-    /**
-     * Draws a path.
-     *
-     * @param paint         describes how to color pixels.
-     * @param viewMatrix    transformation matrix
-     * @param path          the path to draw
-     * @param strokeInfo    the stroke information (width, join, cap) and
-     *                      the dash information (intervals, count, phase).
-     */
-    void drawPath(GrRenderTarget*,
-                  const GrClip&,
-                  const GrPaint&,
-                  const SkMatrix& viewMatrix,
-                  const SkPath&,
-                  const GrStrokeInfo&);
-
-    /**
-     * Draws vertices with a paint.
-     *
-     * @param   paint           describes how to color pixels.
-     * @param   viewMatrix      transformation matrix
-     * @param   primitiveType   primitives type to draw.
-     * @param   vertexCount     number of vertices.
-     * @param   positions       array of vertex positions, required.
-     * @param   texCoords       optional array of texture coordinates used
-     *                          to access the paint.
-     * @param   colors          optional array of per-vertex colors, supercedes
-     *                          the paint's color field.
-     * @param   indices         optional array of indices. If NULL vertices
-     *                          are drawn non-indexed.
-     * @param   indexCount      if indices is non-null then this is the
-     *                          number of indices.
-     */
-    void drawVertices(GrRenderTarget*,
-                      const GrClip&,
-                      const GrPaint& paint,
-                      const SkMatrix& viewMatrix,
-                      GrPrimitiveType primitiveType,
-                      int vertexCount,
-                      const SkPoint positions[],
-                      const SkPoint texs[],
-                      const GrColor colors[],
-                      const uint16_t indices[],
-                      int indexCount);
-
-    /**
-     * Draws an oval.
-     *
-     * @param paint         describes how to color pixels.
-     * @param viewMatrix    transformation matrix
-     * @param oval          the bounding rect of the oval.
-     * @param strokeInfo    the stroke information (width, join, cap) and
-     *                      the dash information (intervals, count, phase).
-     */
-    void drawOval(GrRenderTarget*,
-                  const GrClip&,
-                  const GrPaint& paint,
-                  const SkMatrix& viewMatrix,
-                  const SkRect& oval,
-                  const GrStrokeInfo& strokeInfo);
-
     ///////////////////////////////////////////////////////////////////////////
     // Misc.
 
     /**
      * Flags that affect flush() behavior.
      */
     enum FlushBits {
         /**
          * A client may reach a point where it has partially rendered a frame
          * through a GrContext that it knows the user will never see. This flag
          * causes the flush to skip submission of deferred content to the 3D API
          * during the flush.
          */
         kDiscard_FlushBit                    = 0x2,
     };
 
     /**
      * Call to ensure all drawing to the context has been issued to the
      * underlying 3D API.
      * @param flagsBitfield     flags that control the flushing behavior. See
      *                          FlushBits.
      */
     void flush(int flagsBitfield = 0);
 
+    void flushIfNecessary() {
+        if (fFlushToReduceCacheSize) {
+            this->flush();
+        }    
+    }
+
    /**
     * These flags can be used with the read/write pixels functions below.
     */
     enum PixelOpsFlags {
         /** The GrContext will not be flushed before the surface read or write. This means that
             the read or write may occur before previous draws have executed. */
         kDontFlush_PixelOpsFlag = 0x1,
         /** Any surface writes should be flushed to the backend 3D API after the surface operation
             is complete */
         kFlushWrites_PixelOp = 0x2,
@@ skipping 83 matching lines @@
      * used to make the surface contents available to be read in the backend 3D API, usually for a
      * compositing step external to Skia.
      *
      * It is not necessary to call this before reading the render target via Skia/GrContext.
      * GrContext will detect when it must perform a resolve before reading pixels back from the
      * surface or using it as a texture.
      */
     void prepareSurfaceForExternalRead(GrSurface*);
 
     /**
-     * Provides a perfomance hint that the render target's contents are allowed
-     * to become undefined.
-     */
-    void discardRenderTarget(GrRenderTarget*);
-
-    /**
      * An ID associated with this context, guaranteed to be unique.
      */
     uint32_t uniqueID() { return fUniqueID; }
 
     ///////////////////////////////////////////////////////////////////////////
     // Functions intended for internal use only.
     GrGpu* getGpu() { return fGpu; }
     const GrGpu* getGpu() const { return fGpu; }
     GrBatchFontCache* getBatchFontCache() { return fBatchFontCache; }
     GrLayerCache* getLayerCache() { return fLayerCache.get(); }
     GrTextBlobCache* getTextBlobCache() { return fTextBlobCache; }
-    GrDrawTarget* getTextTarget();
-    GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
+    bool abandoned() const { return fDrawingMgr.abandoned(); }
     GrResourceProvider* resourceProvider() { return fResourceProvider; }
     const GrResourceProvider* resourceProvider() const { return fResourceProvider; }
     GrResourceCache* getResourceCache() { return fResourceCache; }
 
     // Called by tests that draw directly to the context via GrDrawTarget
     void getTestTarget(GrTestTarget*);
 
     void addGpuTraceMarker(const GrGpuTraceMarker* marker);
     void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
 
@@ skipping 25 matching lines @@
         GrTextureProvider*          fTextureProvider;
     };
 
     GrBatchFontCache*               fBatchFontCache;
     SkAutoTDelete<GrLayerCache>     fLayerCache;
     SkAutoTDelete<GrTextBlobCache>  fTextBlobCache;
 
     GrPathRendererChain*            fPathRendererChain;
     GrSoftwarePathRenderer*         fSoftwarePathRenderer;
 
-    GrDrawTarget*                   fDrawBuffer;
-
     // Set by OverbudgetCB() to request that GrContext flush before exiting a draw.
     bool                            fFlushToReduceCacheSize;
-    GrAARectRenderer*               fAARectRenderer;
-    GrOvalRenderer*                 fOvalRenderer;
-
     bool                            fDidTestPMConversions;
     int                             fPMToUPMConversion;
     int                             fUPMToPMConversion;
 
     struct CleanUpData {
         PFCleanUpFunc fFunc;
         void*         fInfo;
     };
 
     SkTDArray<CleanUpData>          fCleanUpData;
 
     int                             fMaxTextureSizeOverride;
 
     const uint32_t                  fUniqueID;
 
     GrContext(); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext, const GrContextOptions& options);
+
+    // Currently the DrawingMgr just wraps the single GrDrawTarget in a single
+    // GrDrawContext and hands it out. In the future this class will allocate
+    // a new GrDrawContext for each GrRenderTarget/GrDrawTarget and manage
+    // the DAG.
+    class DrawingMgr {
+    public:
+        DrawingMgr()
+            : fDrawTarget(NULL)
+            , fDrawContext(NULL) {
+        }
+
+        ~DrawingMgr();
+
+        void init(GrContext* context);
+
+        void abandon();
+        bool abandoned() const { return NULL == fDrawTarget; }
+
+        void purgeResources();
+        void reset();
+        void flush();
+
+        // Callers should take a ref if they rely on the GrDrawContext sticking around.
+        // NULL will be returned if the context has been abandoned.
+        GrDrawContext* drawContext();
+
+    private:
+        friend class GrContext;  // for access to fDrawTarget for testing
+
+        GrDrawTarget*     fDrawTarget;
+
+        GrDrawContext*    fDrawContext;
+    };
+
+    DrawingMgr                      fDrawingMgr;
+
     void initMockContext();
     void initCommon();
 
-    class AutoCheckFlush;
-    // Sets the paint and returns the target to draw into.
-    GrDrawTarget* prepareToDraw(GrPipelineBuilder*,
-                                GrRenderTarget* rt,
-                                const GrClip&,
-                                const GrPaint* paint,
-                                const AutoCheckFlush*);
-
-    // A simpler version of the above which just returns the draw target.  Clip is *NOT* set
-    GrDrawTarget* prepareToDraw();
-
-    void internalDrawPath(GrDrawTarget*,
-                          GrPipelineBuilder*,
-                          const SkMatrix& viewMatrix,
-                          GrColor,
-                          bool useAA,
-                          const SkPath&,
-                          const GrStrokeInfo&);
-
     /**
      * Creates a new text rendering context that is optimal for the
      * render target and the context. Caller assumes the ownership
      * of the returned object. The returned object must be deleted
      * before the context is destroyed.
      * TODO we can possibly bury this behind context, but we need to be able to use the
      * drawText_asPaths logic on SkGpuDevice
      */
     GrTextContext* createTextContext(GrRenderTarget*,
                                      SkGpuDevice*,
@@ skipping 21 matching lines @@
      */
     static void TextBlobCacheOverBudgetCB(void* data);
 
     // TODO see note on createTextContext
     friend class SkGpuDevice;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif