Move ViewMatrix off of drawstate

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
@@ skipping 431 matching lines @@
                                int indexCount,
                                const SkRect* devBounds) {
     SkASSERT(ds);
     if (indexCount > 0 &&
         this->checkDraw(*ds, gp, type, startVertex, startIndex, vertexCount, indexCount)) {
 
         // Setup clip
         GrScissorState scissorState;
         GrDrawState::AutoRestoreEffects are;
         GrDrawState::AutoRestoreStencil ars;
-        if (!this->setupClip(devBounds, &are, &ars, ds, &scissorState)) {
+        if (!this->setupClip(ds, &are, &ars, &scissorState, devBounds)) {
             return;
         }
 
         DrawInfo info;
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = startIndex;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = indexCount;
 
@@ skipping 22 matching lines @@
                                   int startVertex,
                                   int vertexCount,
                                   const SkRect* devBounds) {
     SkASSERT(ds);
     if (vertexCount > 0 && this->checkDraw(*ds, gp, type, startVertex, -1, vertexCount, -1)) {
 
         // Setup clip
         GrScissorState scissorState;
         GrDrawState::AutoRestoreEffects are;
         GrDrawState::AutoRestoreStencil ars;
-        if (!this->setupClip(devBounds, &are, &ars, ds, &scissorState)) {
+        if (!this->setupClip(ds, &are, &ars, &scissorState, devBounds)) {
             return;
         }
 
         DrawInfo info;
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = 0;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = 0;
 
@@ skipping 58 matching lines @@
                                GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
     SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
     SkASSERT(ds);
 
     // Setup clip
     GrScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
-    if (!this->setupClip(NULL, &are, &ars, ds, &scissorState)) {
+    if (!this->setupClip(ds, &are, &ars, &scissorState, NULL)) {
         return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
     this->getPathStencilSettingsForFilltype(fill,
                                             ds->getRenderTarget()->getStencilBuffer(),
                                             &stencilSettings);
 
     this->onStencilPath(*ds, pathProc, path, scissorState, stencilSettings);
 }
 
 void GrDrawTarget::drawPath(GrDrawState* ds,
                             const GrPathProcessor* pathProc,
                             const GrPath* path,
                             GrPathRendering::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path rendering.
     SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
     SkASSERT(ds);
 
     SkRect devBounds = path->getBounds();
-    SkMatrix viewM = ds->getViewMatrix();
-    viewM.mapRect(&devBounds);
+    pathProc->viewMatrix().mapRect(&devBounds);
 
     // Setup clip
     GrScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
-    if (!this->setupClip(&devBounds, &are, &ars, ds, &scissorState)) {
+    if (!this->setupClip(ds, &are, &ars, &scissorState, &devBounds)) {
        return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
     this->getPathStencilSettingsForFilltype(fill,
                                             ds->getRenderTarget()->getStencilBuffer(),
                                             &stencilSettings);
 
     GrDeviceCoordTexture dstCopy;
@@ skipping 19 matching lines @@
     SkASSERT(indices);
     SkASSERT(0 == reinterpret_cast<long>(indices) % GrPathRange::PathIndexSizeInBytes(indexType));
     SkASSERT(transformValues);
     SkASSERT(ds);
 
     // Setup clip
     GrScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
 
-    if (!this->setupClip(NULL, &are, &ars, ds, &scissorState)) {
+    if (!this->setupClip(ds, &are, &ars, &scissorState, NULL)) {
         return;
     }
 
     // set stencil settings for path
     GrStencilSettings stencilSettings;
     this->getPathStencilSettingsForFilltype(fill,
                                             ds->getRenderTarget()->getStencilBuffer(),
                                             &stencilSettings);
 
     // Don't compute a bounding box for setupDstReadIfNecessary(), we'll opt
@@ skipping 20 matching lines @@
         SkIRect rtRect = SkIRect::MakeWH(renderTarget->width(), renderTarget->height());
         if (NULL == rect || canIgnoreRect || rect->contains(rtRect)) {
             rect = &rtRect;
             // We first issue a discard() since that may help tilers.
             this->discard(renderTarget);
         }
 
         GrDrawState drawState;
         drawState.setRenderTarget(renderTarget);
 
-        this->drawSimpleRect(&drawState, color, *rect);
+        this->drawSimpleRect(&drawState, color, SkMatrix::I(), *rect);
     } else {       
         this->onClear(rect, color, canIgnoreRect, renderTarget);
     }
 }
 
 typedef GrTraceMarkerSet::Iter TMIter;
 void GrDrawTarget::saveActiveTraceMarkers() {
     if (this->caps()->gpuTracingSupport()) {
         SkASSERT(0 == fStoredTraceMarkers.count());
         fStoredTraceMarkers.addSet(fActiveTraceMarkers);
@@ skipping 48 matching lines @@
 
     int maxInstancesPerDraw = this->indexCountInCurrentSource() / indicesPerInstance;
     if (!maxInstancesPerDraw) {
         return;
     }
 
     // Setup clip
     GrScissorState scissorState;
     GrDrawState::AutoRestoreEffects are;
     GrDrawState::AutoRestoreStencil ars;
-    if (!this->setupClip(devBounds, &are, &ars, ds, &scissorState)) {
+    if (!this->setupClip(ds, &are, &ars, &scissorState, devBounds)) {
         return;
     }
 
     DrawInfo info;
     info.fPrimitiveType = type;
     info.fStartIndex = 0;
     info.fStartVertex = 0;
     info.fIndicesPerInstance = indicesPerInstance;
     info.fVerticesPerInstance = verticesPerInstance;
 
     // Set the same bounds for all the draws.
     if (devBounds) {
         info.setDevBounds(*devBounds);
     }
 
     // TODO: We should continue with incorrect blending.
     GrDeviceCoordTexture dstCopy;
-    if (!this->setupDstReadIfNecessary(ds, gp, &dstCopy,devBounds)) {
+    if (!this->setupDstReadIfNecessary(ds, gp, &dstCopy, devBounds)) {
         return;
     }
 
     while (instanceCount) {
         info.fInstanceCount = SkTMin(instanceCount, maxInstancesPerDraw);
         info.fVertexCount = info.fInstanceCount * verticesPerInstance;
         info.fIndexCount = info.fInstanceCount * indicesPerInstance;
 
         if (this->checkDraw(*ds,
                             gp,
@@ skipping 161 matching lines @@
     drawState.setRenderTarget(rt);
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(clippedSrcRect.fLeft - clippedDstPoint.fX),
                         SkIntToScalar(clippedSrcRect.fTop - clippedDstPoint.fY));
     matrix.postIDiv(tex->width(), tex->height());
     drawState.addColorTextureProcessor(tex, matrix);
     SkIRect dstRect = SkIRect::MakeXYWH(clippedDstPoint.fX,
                                         clippedDstPoint.fY,
                                         clippedSrcRect.width(),
                                         clippedSrcRect.height());
-    this->drawSimpleRect(&drawState, GrColor_WHITE, dstRect);
+    this->drawSimpleRect(&drawState, GrColor_WHITE, SkMatrix::I(), dstRect);
     return true;
 }
 
 bool GrDrawTarget::canCopySurface(const GrSurface* dst,
                                   const GrSurface* src,
                                   const SkIRect& srcRect,
                                   const SkIPoint& dstPoint) {
     SkASSERT(dst);
     SkASSERT(src);
 
@@ skipping 240 matching lines @@
     static int32_t gUniqueID = SK_InvalidUniqueID;
     uint32_t id;
     do {
         id = static_cast<uint32_t>(sk_atomic_inc(&gUniqueID) + 1);
     } while (id == SK_InvalidUniqueID);
     return id;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool GrClipTarget::setupClip(const SkRect* devBounds,
+bool GrClipTarget::setupClip(GrDrawState* ds,
                              GrDrawState::AutoRestoreEffects* are,
                              GrDrawState::AutoRestoreStencil* ars,
-                             GrDrawState* ds,
-                             GrScissorState* scissorState) {
+                             GrScissorState* scissorState,
+                             const SkRect* devBounds) {
     return fClipMaskManager.setupClipping(ds,
                                           are,
                                           ars,
                                           scissorState,
                                           this->getClip(),
                                           devBounds);
 }