hack

src/gpu/GrDrawState.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
@@ skipping 614 matching lines @@
     ///////////////////////////////////////////////////////////////////////////
     /// @name Render Target
     ////
 
     /**
      * Sets the render-target used at the next drawing call
      *
      * @param target  The render target to set.
      */
     void setRenderTarget(GrRenderTarget* target) {
-        fRenderTarget.reset(SkSafeRef(target));
+        //SkDebugf("GrDrawState::setRenderTarget\n");
+        fRenderTarget1.reset(SkSafeRef(target));
     }
 
     /**
      * Retrieves the currently set render-target.
      *
      * @return    The currently set render target.
      */
-    const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
-    GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); }
+    const GrRenderTarget* getRenderTarget() const { return fRenderTarget1.get(); }
+    GrRenderTarget* getRenderTarget() { return fRenderTarget1.get(); }
 
     class AutoRenderTargetRestore : public ::SkNoncopyable {
     public:
         AutoRenderTargetRestore() : fDrawState(NULL), fSavedTarget(NULL) {}
         AutoRenderTargetRestore(GrDrawState* ds, GrRenderTarget* newTarget) {
             fDrawState = NULL;
             fSavedTarget = NULL;
             this->set(ds, newTarget);
         }
         ~AutoRenderTargetRestore() { this->restore(); }
@@ skipping 184 matching lines @@
      * or both faces.
      * @return the current draw face(s).
      */
     DrawFace getDrawFace() const { return fCommon.fDrawFace; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
     bool operator ==(const GrDrawState& s) const {
-        if (fRenderTarget.get() != s.fRenderTarget.get() ||
+        if (fRenderTarget1.get() != s.fRenderTarget1.get() ||
             fColorStages.count() != s.fColorStages.count() ||
             fCoverageStages.count() != s.fCoverageStages.count() ||
             fCommon != s.fCommon) {
             return false;
         }
         for (int i = 0; i < fColorStages.count(); i++) {
             if (fColorStages[i] != s.fColorStages[i]) {
                 return false;
             }
         }
         for (int i = 0; i < fCoverageStages.count(); i++) {
             if (fCoverageStages[i] != s.fCoverageStages[i]) {
                 return false;
             }
         }
         return true;
     }
     bool operator !=(const GrDrawState& s) const { return !(*this == s); }
 
     GrDrawState& operator= (const GrDrawState& s) {
         SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
-        this->setRenderTarget(s.fRenderTarget.get());
+        this->setRenderTarget(s.fRenderTarget1.get());
         fCommon = s.fCommon;
         fColorStages = s.fColorStages;
         fCoverageStages = s.fCoverageStages;
         return *this;
     }
 
 private:
 
     void onReset(const SkMatrix* initialViewMatrix) {
         SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
         fColorStages.reset();
         fCoverageStages.reset();
 
-        fRenderTarget.reset(NULL);
+        fRenderTarget1.reset(NULL);
 
         this->setDefaultVertexAttribs();
 
         fCommon.fColor = 0xffffffff;
         if (NULL == initialViewMatrix) {
             fCommon.fViewMatrix.reset();
         } else {
             fCommon.fViewMatrix = *initialViewMatrix;
         }
         fCommon.fSrcBlend = kOne_GrBlendCoeff;
@@ skipping 54 matching lines @@
 
 public:
     /**
      * DeferredState contains all of the data of a GrDrawState but does not hold refs on GrResource
      * objects. Resources are allowed to hit zero ref count while in DeferredStates. Their internal
      * dispose mechanism returns them to the cache. This allows recycling resources through the
      * the cache while they are in a deferred draw queue.
      */
     class DeferredState {
     public:
-        DeferredState() : fRenderTarget(NULL) {
+        DeferredState() : fRenderTarget1(NULL) {
             SkDEBUGCODE(fInitialized = false;)
         }
         // TODO: Remove this when DeferredState no longer holds a ref to the RT
-        ~DeferredState() { SkSafeUnref(fRenderTarget); }
+        ~DeferredState() { SkSafeUnref(fRenderTarget1); }
 
         void saveFrom(const GrDrawState& drawState) {
             fCommon = drawState.fCommon;
             // TODO: Here we will copy the GrRenderTarget pointer without taking a ref.
-            fRenderTarget = drawState.fRenderTarget.get();
-            SkSafeRef(fRenderTarget);
+//            SkDebugf("DeferredState::render target change\n");
+            fRenderTarget1 = drawState.fRenderTarget1.get();
+            SkSafeRef(fRenderTarget1);
             // Here we ref the effects directly rather than the effect-refs. TODO: When the effect-
             // ref gets fully unref'ed it will cause the underlying effect to unref its resources
             // and recycle them to the cache (if no one else is holding a ref to the resources).
             fStages.reset(drawState.fColorStages.count() + drawState.fCoverageStages.count());
             fColorStageCnt = drawState.fColorStages.count();
             for (int i = 0; i < fColorStageCnt; ++i) {
                 fStages[i].saveFrom(drawState.fColorStages[i]);
             }
             for (int i = 0; i < drawState.fCoverageStages.count(); ++i) {
                 fStages[i + fColorStageCnt].saveFrom(drawState.fCoverageStages[i]);
             }
             SkDEBUGCODE(fInitialized = true;)
         }
 
         void restoreTo(GrDrawState* drawState) {
             SkASSERT(fInitialized);
             drawState->fCommon = fCommon;
-            drawState->setRenderTarget(fRenderTarget);
+            drawState->setRenderTarget(fRenderTarget1);
             // reinflate color/cov stage arrays.
             drawState->fColorStages.reset();
             for (int i = 0; i < fColorStageCnt; ++i) {
                 SkNEW_APPEND_TO_TARRAY(&drawState->fColorStages, GrEffectStage, (fStages[i]));
             }
             int coverageStageCnt = fStages.count() - fColorStageCnt;
             drawState->fCoverageStages.reset();
             for (int i = 0; i < coverageStageCnt; ++i) {
                 SkNEW_APPEND_TO_TARRAY(&drawState->fCoverageStages,
                                         GrEffectStage, (fStages[i + fColorStageCnt]));
             }
         }
 
         bool isEqual(const GrDrawState& state) const {
             int numCoverageStages = fStages.count() - fColorStageCnt;
-            if (fRenderTarget != state.fRenderTarget.get() ||
+            if (fRenderTarget1 != state.fRenderTarget1.get() ||
                 fColorStageCnt != state.fColorStages.count() ||
                 numCoverageStages != state.fCoverageStages.count() ||
                 fCommon != state.fCommon) {
                 return false;
             }
             bool explicitLocalCoords = state.hasLocalCoordAttribute();
             for (int i = 0; i < fColorStageCnt; ++i) {
                 if (!fStages[i].isEqual(state.fColorStages[i], explicitLocalCoords)) {
                     return false;
                 }
             }
             for (int i = 0; i < numCoverageStages; ++i) {
                 int s = fColorStageCnt + i;
                 if (!fStages[s].isEqual(state.fCoverageStages[i], explicitLocalCoords)) {
                     return false;
                 }
             }
             return true;
         }
 
     private:
         typedef SkAutoSTArray<8, GrEffectStage::DeferredStage> DeferredStageArray;
 
-        GrRenderTarget*                       fRenderTarget;
+        GrRenderTarget*                       fRenderTarget1;
         CommonState                           fCommon;
         int                                   fColorStageCnt;
         DeferredStageArray                    fStages;
 
         SkDEBUGCODE(bool fInitialized;)
     };
 
 private:
 
-    SkAutoTUnref<GrRenderTarget>        fRenderTarget;
+    SkAutoTUnref<GrRenderTarget>        fRenderTarget1;
     CommonState                         fCommon;
 
     typedef SkSTArray<4, GrEffectStage> EffectStageArray;
     EffectStageArray                    fColorStages;
     EffectStageArray                    fCoverageStages;
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
     SkDEBUGCODE(int fBlockEffectRemovalCnt;)
 
     /**
      *  Sets vertex attributes for next draw.
      *
      *  @param attribs    the array of vertex attributes to set.
      *  @param count      the number of attributes being set, limited to kMaxVertexAttribCnt.
      */
     void setVertexAttribs(const GrVertexAttrib attribs[], int count);
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif