Improve GrInOrderDrawBuffer::Cmd encapsulation

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 88 matching lines @@
     // allocated space, and leave enough for 50% growth over last time.
     if (3 * buffer->count() < buffer->reserved() && buffer->reserved() > minReserve) {
         int reserve = SkTMax(minReserve, buffer->count() * 3 / 2);
         buffer->reset();
         buffer->setReserve(reserve);
     } else {
         buffer->rewind();
     }
 }
 
-enum {
-    kTraceCmdBit = 0x80,
-    kCmdMask = 0x7f,
-};
-
-static inline uint8_t add_trace_bit(uint8_t cmd) { return cmd | kTraceCmdBit; }
-
-static inline uint8_t strip_trace_bit(uint8_t cmd) { return cmd & kCmdMask; }
-
-static inline bool cmd_has_trace_marker(uint8_t cmd) { return SkToBool(cmd & kTraceCmdBit); }
-
 void GrInOrderDrawBuffer::onDrawRect(GrPipelineBuilder* pipelineBuilder,
                                      GrColor color,
                                      const SkMatrix& viewMatrix,
                                      const SkRect& rect,
                                      const SkRect* localRect,
                                      const SkMatrix* localMatrix) {
     GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder);
 
     // Go to device coords to allow batching across matrix changes
     SkMatrix invert = SkMatrix::I();
@@ skipping 68 matching lines @@
 
     // we only attempt to concat the case when reserved verts are used with a client-specified index
     // buffer. To make this work with client-specified VBs we'd need to know if the VB was updated
     // between draws.
     if (kReserved_GeometrySrcType != geomSrc.fVertexSrc ||
         kBuffer_GeometrySrcType != geomSrc.fIndexSrc) {
         return 0;
     }
     // Check if there is a draw info that is compatible that uses the same VB from the pool and
     // the same IB
-    if (kDraw_Cmd != strip_trace_bit(fCmdBuffer.back().fType)) {
+    if (Cmd::kDraw_Cmd != fCmdBuffer.back().type()) {
         return 0;
     }
 
     Draw* draw = static_cast<Draw*>(&fCmdBuffer.back());
 
     if (!draw->fInfo.isInstanced() ||
         draw->fInfo.primitiveType() != info.primitiveType() ||
         draw->fInfo.verticesPerInstance() != info.verticesPerInstance() ||
         draw->fInfo.indicesPerInstance() != info.indicesPerInstance() ||
         draw->fInfo.vertexBuffer() != info.vertexBuffer() ||
         draw->fInfo.indexBuffer() != geomSrc.fIndexBuffer) {
         return 0;
     }
     if (draw->fInfo.startVertex() + draw->fInfo.vertexCount() != info.startVertex()) {
         return 0;
     }
 
     // how many instances can be concat'ed onto draw given the size of the index buffer
     int instancesToConcat = this->indexCountInCurrentSource() / info.indicesPerInstance();
     instancesToConcat -= draw->fInfo.instanceCount();
     instancesToConcat = SkTMin(instancesToConcat, info.instanceCount());
 
     draw->fInfo.adjustInstanceCount(instancesToConcat);
 
     // update last fGpuCmdMarkers to include any additional trace markers that have been added
     if (this->getActiveTraceMarkers().count() > 0) {
-        if (cmd_has_trace_marker(draw->fType)) {
+        if (draw->isTraced()) {
             fGpuCmdMarkers.back().addSet(this->getActiveTraceMarkers());
         } else {
             fGpuCmdMarkers.push_back(this->getActiveTraceMarkers());
-            draw->fType = add_trace_bit(draw->fType);
+            draw->makeTraced();
         }
     }
 
     return instancesToConcat;
 }
 
 void GrInOrderDrawBuffer::onDraw(const GrGeometryProcessor* gp,
                                  const DrawInfo& info,
                                  const PipelineInfo& pipelineInfo) {
     SkASSERT(info.vertexBuffer() && (!info.isIndexed() || info.indexBuffer()));
@@ skipping 18 matching lines @@
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawBatch(GrBatch* batch,
                                       const PipelineInfo& pipelineInfo) {
     if (!this->setupPipelineAndShouldDraw(batch, pipelineInfo)) {
         return;
     }
 
     // Check if there is a Batch Draw we can batch with
-    if (kDrawBatch_Cmd != strip_trace_bit(fCmdBuffer.back().fType)) {
+    if (Cmd::kDrawBatch_Cmd != fCmdBuffer.back().type()) {
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch));
         return;
     }
 
     DrawBatch* draw = static_cast<DrawBatch*>(&fCmdBuffer.back());
     if (draw->fBatch->combineIfPossible(batch)) {
         return;
     } else {
         this->closeBatch();
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch));
@@ skipping 55 matching lines @@
         // Add padding to the index buffer so the indices are aligned properly.
         fPathIndexBuffer.append(indexBytes - misalign);
     }
 
     char* savedIndices = fPathIndexBuffer.append(count * indexBytes,
                                                  reinterpret_cast<const char*>(indices));
     float* savedTransforms = fPathTransformBuffer.append(
                                  count * GrPathRendering::PathTransformSize(transformType),
                                  transformValues);
 
-    if (kDrawPaths_Cmd == strip_trace_bit(fCmdBuffer.back().fType)) {
+    if (Cmd::kDrawPaths_Cmd == fCmdBuffer.back().type()) {
         // The previous command was also DrawPaths. Try to collapse this call into the one
         // before. Note that stenciling all the paths at once, then covering, may not be
         // equivalent to two separate draw calls if there is overlap. Blending won't work,
         // and the combined calls may also cancel each other's winding numbers in some
         // places. For now the winding numbers are only an issue if the fill is even/odd,
         // because DrawPaths is currently only used for glyphs, and glyphs in the same
         // font tend to all wind in the same direction.
         DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
         if (pathRange == previous->pathRange() &&
             indexType == previous->fIndexType &&
@@ skipping 90 matching lines @@
     currentState = NULL;
     CmdBuffer::Iter iter(fCmdBuffer);
 
     int currCmdMarker = 0;
 
     int i = 0;
     while (iter.next()) {
         i++;
         GrGpuTraceMarker newMarker("", -1);
         SkString traceString;
-        if (cmd_has_trace_marker(iter->fType)) {
+        if (iter->isTraced()) {
             traceString = fGpuCmdMarkers[currCmdMarker].toString();
             newMarker.fMarker = traceString.c_str();
             this->getGpu()->addGpuTraceMarker(&newMarker);
             ++currCmdMarker;
         }
 
         // TODO temporary hack
-        if (kDrawBatch_Cmd == strip_trace_bit(iter->fType)) {
+        if (Cmd::kDrawBatch_Cmd == iter->type()) {
             DrawBatch* db = reinterpret_cast<DrawBatch*>(iter.get());
             fBatchTarget.flushNext(db->fBatch->numberOfDraws());
             continue;
         }
 
-        bool isSetState = kSetState_Cmd == strip_trace_bit(iter->fType);
-        if (isSetState) {
+        if (Cmd::kSetState_Cmd == iter->type()) {
             SetState* ss = reinterpret_cast<SetState*>(iter.get());
 
             // TODO sometimes we have a prim proc, othertimes we have a GrBatch.  Eventually we will
             // only have GrBatch and we can delete this
             if (ss->fPrimitiveProcessor) {
                 this->getGpu()->buildProgramDesc(&ss->fDesc, *ss->fPrimitiveProcessor,
                                                  *ss->getPipeline(),
                                                  ss->fBatchTracker);
             }
             currentState = ss;
         } else {
             iter->execute(this, currentState);
         }
 
-        if (cmd_has_trace_marker(iter->fType)) {
+        if (iter->isTraced()) {
             this->getGpu()->removeGpuTraceMarker(&newMarker);
         }
     }
 
     // TODO see copious notes about hack
     fBatchTarget.postFlush();
 
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
     ++fDrawID;
 }
@@ skipping 115 matching lines @@
     } else {
         this->closeBatch();
         fPrevState = ss;
         this->recordTraceMarkersIfNecessary();
     }
     return true;
 }
 
 void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary() {
     SkASSERT(!fCmdBuffer.empty());
-    SkASSERT(!cmd_has_trace_marker(fCmdBuffer.back().fType));
+    SkASSERT(!fCmdBuffer.back().isTraced());
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
-        fCmdBuffer.back().fType = add_trace_bit(fCmdBuffer.back().fType);
+        fCmdBuffer.back().makeTraced();
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     }
 }
 
 void GrInOrderDrawBuffer::willReserveVertexAndIndexSpace(int vertexCount,
                                                          size_t vertexStride,
                                                          int indexCount) {
     this->closeBatch();
 
     this->INHERITED::willReserveVertexAndIndexSpace(vertexCount, vertexStride, indexCount);
 }