Make GrContext track the current matrix, render target, and clip directly rather than using GrDrawS…

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
@@ skipping 239 matching lines @@
     /**
      *  Return the max width or height of a texture supported by the current GPU.
      */
     int getMaxTextureSize() const;
 
     ///////////////////////////////////////////////////////////////////////////
     // Render targets
 
     /**
      * Sets the render target.
-     * @param target    the render target to set. (should not be NULL.)
+     * @param target    the render target to set.
      */
-    void setRenderTarget(GrRenderTarget* target);
+    void setRenderTarget(GrRenderTarget* target) {
+        fRenderTarget.reset(SkSafeRef(target));
+    }
 
     /**
      * Gets the current render target.
-     * @return the currently bound render target. Should never be NULL.
+     * @return the currently bound render target.
      */
-    const GrRenderTarget* getRenderTarget() const;
-    GrRenderTarget* getRenderTarget();
+    const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
+    GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); }
 
     GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
 
     /**
      * Can the provided configuration act as a color render target?
      */
     bool isConfigRenderable(GrPixelConfig config) const;
 
     /**
      * Return the max width or height of a render target supported by the
@@ skipping 34 matching lines @@
      */
      GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
 
     ///////////////////////////////////////////////////////////////////////////
     // Matrix state
 
     /**
      * Gets the current transformation matrix.
      * @return the current matrix.
      */
-    const SkMatrix& getMatrix() const;
+    const SkMatrix& getMatrix() const { return fViewMatrix; }
 
     /**
      * Sets the transformation matrix.
      * @param m the matrix to set.
      */
-    void setMatrix(const SkMatrix& m);
+    void setMatrix(const SkMatrix& m) { fViewMatrix = m; }
 
     /**
      * Sets the current transformation matrix to identity.
      */
-    void setIdentityMatrix();
+    void setIdentityMatrix() { fViewMatrix.reset(); }
 
     /**
      * Concats the current matrix. The passed matrix is applied before the
      * current matrix.
      * @param m the matrix to concat.
      */
-    void concatMatrix(const SkMatrix& m) const;
+    void concatMatrix(const SkMatrix& m) { fViewMatrix.preConcat(m); }
 
 
     ///////////////////////////////////////////////////////////////////////////
     // Clip state
     /**
      * Gets the current clip.
      * @return the current clip.
      */
-    const GrClipData* getClip() const;
+    const GrClipData* getClip() const { return fClip; }
 
     /**
      * Sets the clip.
      * @param clipData  the clip to set.
      */
-    void setClip(const GrClipData* clipData);
+    void setClip(const GrClipData* clipData) { fClip = clipData; }
 
     ///////////////////////////////////////////////////////////////////////////
     // 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 target if non-NULL, the render target to clear otherwise clear
      *               the current render target
@@ skipping 489 matching lines @@
 #endif
 
 private:
     // Used to indicate whether a draw should be performed immediately or queued in fDrawBuffer.
     enum BufferedDraw {
         kYes_BufferedDraw,
         kNo_BufferedDraw,
     };
     BufferedDraw fLastDrawWasBuffered;
 
-    GrGpu*              fGpu;
-    GrDrawState*        fDrawState;
+    GrGpu*                          fGpu;
+    SkMatrix                        fViewMatrix;
+    SkAutoTUnref<GrRenderTarget>    fRenderTarget;
+    const GrClipData*               fClip;  // TODO: make this ref counted
+    GrDrawState*                    fDrawState;
 
-    GrResourceCache*    fTextureCache;
-    GrFontCache*        fFontCache;
+    GrResourceCache*                fTextureCache;
+    GrFontCache*                    fFontCache;
 
-    GrPathRendererChain*        fPathRendererChain;
-    GrSoftwarePathRenderer*     fSoftwarePathRenderer;
+    GrPathRendererChain*            fPathRendererChain;
+    GrSoftwarePathRenderer*         fSoftwarePathRenderer;
 
-    GrVertexBufferAllocPool*    fDrawBufferVBAllocPool;
-    GrIndexBufferAllocPool*     fDrawBufferIBAllocPool;
-    GrInOrderDrawBuffer*        fDrawBuffer;
+    GrVertexBufferAllocPool*        fDrawBufferVBAllocPool;
+    GrIndexBufferAllocPool*         fDrawBufferIBAllocPool;
+    GrInOrderDrawBuffer*            fDrawBuffer;
 
-    GrAARectRenderer*           fAARectRenderer;
-    GrOvalRenderer*             fOvalRenderer;
+    GrAARectRenderer*               fAARectRenderer;
+    GrOvalRenderer*                 fOvalRenderer;
 
-    bool                        fDidTestPMConversions;
-    int                         fPMToUPMConversion;
-    int                         fUPMToPMConversion;
+    bool                            fDidTestPMConversions;
+    int                             fPMToUPMConversion;
+    int                             fUPMToPMConversion;
 
     struct CleanUpData {
         PFCleanUpFunc fFunc;
         void*         fInfo;
     };
 
     SkTDArray<CleanUpData>      fCleanUpData;
 
     GrContext(); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext);
@@ skipping 118 matching lines @@
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif