remove view matrix from context

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
 
@@ skipping 369 matching lines @@
      * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
      * the client will resolve to a texture).
      *
      * @param  desc     description of the object to create.
      *
      * @return GrTexture object or NULL on failure.
      */
      GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
 
     ///////////////////////////////////////////////////////////////////////////
-    // Matrix state
-
-    /**
-     * Gets the current transformation matrix.
-     * @return the current matrix.
-     */
-    const SkMatrix& getMatrix() const { return fViewMatrix; }
-
-    /**
-     * Sets the transformation matrix.
-     * @param m the matrix to set.
-     */
-    void setMatrix(const SkMatrix& m) { fViewMatrix = m; }
-
-    /**
-     * Sets the current transformation matrix to identity.
-     */
-    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) { fViewMatrix.preConcat(m); }
-
-
-    ///////////////////////////////////////////////////////////////////////////
     // Clip state
     /**
      * Gets the current clip.
      * @return the current clip.
      */
     const GrClipData* getClip() const { return fClip; }
 
     /**
      * Sets the clip.
      * @param clipData  the clip to set.
      */
     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 canIgnoreRect allows partial clears to be converted to whole
      *                      clears on platforms for which that is cheap
      * @param target The render target to clear.
      */
     void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect, GrRenderTarget* target);
 
     /**
      *  Draw everywhere (respecting the clip) with the paint.
      */
-    void drawPaint(const GrPaint& paint);
+    void drawPaint(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(const GrPaint& paint,
+                  const SkMatrix& viewMatrix,
                   const SkRect&,
                   const GrStrokeInfo* strokeInfo = NULL);
 
     /**
      * Maps a rect of local coordinates onto the a rect of destination
      * coordinates. The localRect is stretched over the dstRect. The dstRect is
      * transformed by the context's matrix. An additional optional matrix can be
      *  provided to transform the local rect.
      *
      * @param paint         describes how to color pixels.
+     * @param viewMatrix    transformation matrix
      * @param dstRect       the destination rect to draw.
      * @param localRect     rect of local coordinates to be mapped onto dstRect
-     * @param localMatrix   Optional matrix to transform localRect.
      */
     void drawRectToRect(const GrPaint& paint,
+                        const SkMatrix& viewMatrix,
                         const SkRect& dstRect,
-                        const SkRect& localRect,
-                        const SkMatrix* localMatrix = NULL);
+                        const SkRect& localRect);
 
     /**
      *  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(const GrPaint& paint, const SkRRect& rrect, const GrStrokeInfo& strokeInfo);
+    void drawRRect(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(const GrPaint& paint, const SkRRect& outer, const SkRRect& inner);
+    void drawDRRect(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(const GrPaint& paint, const SkPath& path, const GrStrokeInfo& strokeInfo);
+    void drawPath(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(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(const GrPaint& paint,
+                  const SkMatrix& viewMatrix,
                   const SkRect& oval,
                   const GrStrokeInfo& strokeInfo);
 
     ///////////////////////////////////////////////////////////////////////////
     // Misc.
 
     /**
      * Flags that affect flush() behavior.
      */
     enum FlushBits {
@@ skipping 146 matching lines @@
             if (fContext) {
                 fContext->setRenderTarget(fPrevTarget);
             }
             SkSafeUnref(fPrevTarget);
         }
     private:
         GrContext*      fContext;
         GrRenderTarget* fPrevTarget;
     };
 
-    /**
-     * Save/restore the view-matrix in the context. It can optionally adjust a paint to account
-     * for a coordinate system change. Here is an example of how the paint param can be used:
-     *
-     * A GrPaint is setup with GrProcessors. The stages will have access to the pre-matrix source
-     * geometry positions when the draw is executed. Later on a decision is made to transform the
-     * geometry to device space on the CPU. The effects now need to know that the space in which
-     * the geometry will be specified has changed.
-     *
-     * Note that when restore is called (or in the destructor) the context's matrix will be
-     * restored. However, the paint will not be restored. The caller must make a copy of the
-     * paint if necessary. Hint: use SkTCopyOnFirstWrite if the AutoMatrix is conditionally
-     * initialized.
-     */
-    class AutoMatrix : public ::SkNoncopyable {
-    public:
-        AutoMatrix() : fContext(NULL) {}
-
-        ~AutoMatrix() { this->restore(); }
-
-        /**
-         * Initializes by pre-concat'ing the context's current matrix with the preConcat param.
-         */
-        void setPreConcat(GrContext* context, const SkMatrix& preConcat, GrPaint* paint = NULL) {
-            SkASSERT(context);
-
-            this->restore();
-
-            fContext = context;
-            fMatrix = context->getMatrix();
-            this->preConcat(preConcat, paint);
-        }
-
-        /**
-         * Sets the context's matrix to identity. Returns false if the inverse matrix is required to
-         * update a paint but the matrix cannot be inverted.
-         */
-        bool setIdentity(GrContext* context, GrPaint* paint = NULL) {
-            SkASSERT(context);
-
-            this->restore();
-
-            if (paint) {
-                if (!paint->localCoordChangeInverse(context->getMatrix())) {
-                    return false;
-                }
-            }
-            fMatrix = context->getMatrix();
-            fContext = context;
-            context->setIdentityMatrix();
-            return true;
-        }
-
-        /**
-         * Replaces the context's matrix with a new matrix. Returns false if the inverse matrix is
-         * required to update a paint but the matrix cannot be inverted.
-         */
-        bool set(GrContext* context, const SkMatrix& newMatrix, GrPaint* paint = NULL) {
-            if (paint) {
-                if (!this->setIdentity(context, paint)) {
-                    return false;
-                }
-                this->preConcat(newMatrix, paint);
-            } else {
-                this->restore();
-                fContext = context;
-                fMatrix = context->getMatrix();
-                context->setMatrix(newMatrix);
-            }
-            return true;
-        }
-
-        /**
-         * If this has been initialized then the context's matrix will be further updated by
-         * pre-concat'ing the preConcat param. The matrix that will be restored remains unchanged.
-         * The paint is assumed to be relative to the context's matrix at the time this call is
-         * made, not the matrix at the time AutoMatrix was first initialized. In other words, this
-         * performs an incremental update of the paint.
-         */
-        void preConcat(const SkMatrix& preConcat, GrPaint* paint = NULL) {
-            if (paint) {
-                paint->localCoordChange(preConcat);
-            }
-            fContext->concatMatrix(preConcat);
-        }
-
-        /**
-         * Returns false if never initialized or the inverse matrix was required to update a paint
-         * but the matrix could not be inverted.
-         */
-        bool succeeded() const { return SkToBool(fContext); }
-
-        /**
-         * If this has been initialized then the context's original matrix is restored.
-         */
-        void restore() {
-            if (fContext) {
-                fContext->setMatrix(fMatrix);
-                fContext = NULL;
-            }
-        }
-
-    private:
-        GrContext*  fContext;
-        SkMatrix    fMatrix;
-    };
-
     class AutoClip : public ::SkNoncopyable {
     public:
         // This enum exists to require a caller of the constructor to acknowledge that the clip will
         // initially be wide open. It also could be extended if there are other desirable initial
         // clip states.
         enum InitialClip {
             kWideOpen_InitialClip,
         };
 
         AutoClip(GrContext* context, InitialClip SkDEBUGCODE(initialState))
@@ skipping 25 matching lines @@
 
         SkClipStack       fNewClipStack;
         GrClipData        fNewClipData;
     };
 
     class AutoWideOpenIdentityDraw {
     public:
         AutoWideOpenIdentityDraw(GrContext* ctx, GrRenderTarget* rt)
             : fAutoClip(ctx, AutoClip::kWideOpen_InitialClip)
             , fAutoRT(ctx, rt) {
-            fAutoMatrix.setIdentity(ctx);
-            // should never fail with no paint param.
-            SkASSERT(fAutoMatrix.succeeded());
         }
 
     private:
         AutoClip fAutoClip;
         AutoRenderTarget fAutoRT;
-        AutoMatrix fAutoMatrix;
     };
 
     ///////////////////////////////////////////////////////////////////////////
     // Functions intended for internal use only.
     GrGpu* getGpu() { return fGpu; }
     const GrGpu* getGpu() const { return fGpu; }
     GrFontCache* getFontCache() { return fFontCache; }
     GrLayerCache* getLayerCache() { return fLayerCache.get(); }
     GrDrawTarget* getTextTarget();
     const GrIndexBuffer* getQuadIndexBuffer() const;
@@ skipping 44 matching lines @@
         void incShaderCompilations() {}
 #endif
     };
 
 #if GR_GPU_STATS
     const GPUStats* gpuStats() const;
 #endif
 
 private:
     GrGpu*                          fGpu;
-    SkMatrix                        fViewMatrix;
     SkAutoTUnref<GrRenderTarget>    fRenderTarget;
     const GrClipData*               fClip;  // TODO: make this ref counted
 
     GrResourceCache2*               fResourceCache2;
     GrFontCache*                    fFontCache;
     SkAutoTDelete<GrLayerCache>     fLayerCache;
 
     GrPathRendererChain*            fPathRendererChain;
     GrSoftwarePathRenderer*         fSoftwarePathRenderer;
 
@@ skipping 24 matching lines @@
     GrContext(const Options&); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext);
     void initMockContext();
     void initCommon();
 
     void setupDrawBuffer();
 
     class AutoCheckFlush;
     /// Sets the paint and returns the target to draw into. The paint can be NULL in which case the
     /// draw state is left unmodified.
-    GrDrawTarget* prepareToDraw(GrDrawState* ds, const GrPaint* paint, const AutoCheckFlush*);
+    GrDrawTarget* prepareToDraw(GrDrawState* ds,
+                                const GrPaint* paint,
+                                const SkMatrix* viewMatrix,
+                                const AutoCheckFlush*);
 
     void internalDrawPath(GrDrawTarget*,
                           GrDrawState*,
+                          const SkMatrix& viewMatrix,
                           GrColor,
                           bool useAA,
                           const SkPath&,
                           const GrStrokeInfo&);
 
     GrTexture* createResizedTexture(const GrSurfaceDesc& desc,
                                     const GrCacheID& cacheID,
                                     const void* srcData,
                                     size_t rowBytes,
                                     bool filter);
 
     /**
      * These functions create premul <-> unpremul effects if it is possible to generate a pair
      * of effects that make a readToUPM->writeToPM->readToUPM cycle invariant. Otherwise, they
      * return NULL.
      */
     const GrFragmentProcessor* createPMToUPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
     const GrFragmentProcessor* createUPMToPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
 
     /**
      *  This callback allows the resource cache to callback into the GrContext
      *  when the cache is still over budget after a purge.
      */
     static void OverBudgetCB(void* data);
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif