scissor state on optstate

src/gpu/GrOptDrawState.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOptDrawState.h"
 
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "GrProcOptInfo.h"
 
 GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
                                BlendOptFlags blendOptFlags,
                                GrBlendCoeff optSrcCoeff,
                                GrBlendCoeff optDstCoeff,
                                GrGpu* gpu,
+                               const ScissorState& scissorState,
                                const GrDeviceCoordTexture* dstCopy,
                                GrGpu::DrawType drawType)
 : fRenderTarget(drawState.fRenderTarget.get()) {
+    fScissorState = scissorState;
     fViewMatrix = drawState.getViewMatrix();
     fBlendConstant = drawState.getBlendConstant();
     fFlagBits = drawState.getFlagBits();
     fVAPtr = drawState.getVertexAttribs();
     fVACount = drawState.getVertexAttribCount();
     fVAStride = drawState.getVertexStride();
     fStencilSettings = drawState.getStencil();
     fDrawFace = (DrawFace)drawState.getDrawFace();
     fBlendOptFlags = blendOptFlags;
     fSrcBlend = optSrcCoeff;
@@ skipping 50 matching lines @@
     }
 
     this->setOutputStateInfo(drawState, *gpu->caps(), &descInfo);
 
     // now create a key
     gpu->buildProgramDesc(*this, descInfo, drawType, dstCopy, &fDesc);
 };
 
 GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState,
                                        GrGpu* gpu,
+                                       const ScissorState& scissorState,
                                        const GrDeviceCoordTexture* dstCopy,
                                        GrGpu::DrawType drawType) {
     GrBlendCoeff srcCoeff;
     GrBlendCoeff dstCoeff;
     BlendOptFlags blendFlags = (BlendOptFlags) drawState.getBlendOpts(false,
                                                                       &srcCoeff,
                                                                       &dstCoeff);
 
     // If our blend coeffs are set to 0,1 we know we will not end up drawing unless we are
     // stenciling. When path rendering the stencil settings are not always set on the draw state
     // so we must check the draw type. In cases where we will skip drawing we simply return a
     // null GrOptDrawState.
     if (kZero_GrBlendCoeff == srcCoeff && kOne_GrBlendCoeff == dstCoeff &&
         !drawState.getStencil().doesWrite() && GrGpu::kStencilPath_DrawType != drawType) {
         return NULL;
     }
 
     return SkNEW_ARGS(GrOptDrawState, (drawState, blendFlags, srcCoeff,
-                                       dstCoeff, gpu, dstCopy, drawType));
+                                       dstCoeff, gpu, scissorState, dstCopy, drawType));
 }
 
 void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
                                         const GrDrawTargetCaps& caps,
                                         GrProgramDesc::DescInfo* descInfo) {
     // Set this default and then possibly change our mind if there is coverage.
     descInfo->fPrimaryOutputType = GrProgramDesc::kModulate_PrimaryOutputType;
     descInfo->fSecondaryOutputType = GrProgramDesc::kNone_SecondaryOutputType;
 
     // If we do have coverage determine whether it matters.  Dual source blending is expensive so
@@ skipping 131 matching lines @@
 bool GrOptDrawState::operator== (const GrOptDrawState& that) const {
     if (this->fDesc != that.fDesc) {
         return false;
     }
     bool usingVertexColors = that.fDesc.header().fColorAttributeIndex != -1;
     if (!usingVertexColors && this->fColor != that.fColor) {
         return false;
     }
 
     if (this->getRenderTarget() != that.getRenderTarget() ||
+        this->fScissorState != that.fScissorState ||
         !this->fViewMatrix.cheapEqualTo(that.fViewMatrix) ||
         this->fSrcBlend != that.fSrcBlend ||
         this->fDstBlend != that.fDstBlend ||
         this->fBlendConstant != that.fBlendConstant ||
         this->fFlagBits != that.fFlagBits ||
         this->fVACount != that.fVACount ||
         this->fVAStride != that.fVAStride ||
         memcmp(this->fVAPtr, that.fVAPtr, this->fVACount * sizeof(GrVertexAttrib)) ||
         this->fStencilSettings != that.fStencilSettings ||
         this->fDrawFace != that.fDrawFace) {
@@ skipping 19 matching lines @@
     SkASSERT(this->numFragmentStages() == that.numFragmentStages());
     for (int i = 0; i < this->numFragmentStages(); i++) {
 
         if (this->getFragmentStage(i) != that.getFragmentStage(i)) {
             return false;
         }
     }
     return true;
 }