cleaning up geometry handling in gpu

src/gpu/GrGpu.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 GrGpu_DEFINED
 #define GrGpu_DEFINED
 
@@ skipping 356 matching lines @@
      * Takes the current active set of markers and stores them for later use. Any current marker
      * in the active set is removed from the active set and the targets remove function is called.
      * These functions do not work as a stack so you cannot call save a second time before calling
      * restore. Also, it is assumed that when restore is called the current active set of markers
      * is empty. When the stored markers are added back into the active set, the targets add marker
      * is called.
      */
     void saveActiveTraceMarkers();
     void restoreActiveTraceMarkers();
 
-    /**
-     * Query to find out if the vertex or index source is reserved.
-     */
-    bool hasReservedVerticesOrIndices() const {
-        return GrDrawTarget::kReserved_GeometrySrcType == this->getGeomSrc().fVertexSrc ||
-               GrDrawTarget::kReserved_GeometrySrcType == this->getGeomSrc().fIndexSrc;
-    }
-
     // Called to determine whether an onCopySurface call would succeed or not. This is useful for
     // proxy subclasses to test whether the copy would succeed without executing it yet. Derived
     // classes must keep this consistent with their implementation of onCopySurface(). The inputs
     // are the same as onCopySurface(), i.e. srcRect and dstPoint are clipped to be inside the src
     // and dst bounds.
     virtual bool canCopySurface(GrSurface* dst,
                                 GrSurface* src,
                                 const SkIRect& srcRect,
                                 const SkIPoint& dstPoint) = 0;
 
@@ skipping 18 matching lines @@
 
     /**
      * Sets source of index data for the next indexed draw. Data does not have
      * to be in the buffer until drawIndexed.
      *
      * @param buffer index buffer containing indices. Must be unlocked
      *               before indexed draw call.
      */
     void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
 
-    /**
-     * Resets vertex source. Drawing from reset vertices is illegal. Set vertex
-     * source to reserved, array, or buffer before next draw. May be able to free
-     * up temporary storage allocated by setVertexSourceToArray or
-     * reserveVertexSpace.
-     */
-    void resetVertexSource();
-
-    /**
-     * Resets index source. Indexed Drawing from reset indices is illegal. Set
-     * index source to reserved, array, or buffer before next indexed draw. May
-     * be able to free up temporary storage allocated by setIndexSourceToArray
-     * or reserveIndexSpace.
-     */
-    void resetIndexSource();
-
-    /**
-     * Pushes and resets the vertex/index sources. Any reserved vertex / index
-     * data is finalized (i.e. cannot be updated after the matching pop but can
-     * be drawn from). Must be balanced by a pop.
-     */
-    void pushGeometrySource();
-
-    /**
-     * Pops the vertex / index sources from the matching push.
-     */
-    void popGeometrySource();
-
 protected:
     DrawType PrimTypeToDrawType(GrPrimitiveType type) {
         switch (type) {
             case kTriangles_GrPrimitiveType:
             case kTriangleStrip_GrPrimitiveType:
             case kTriangleFan_GrPrimitiveType:
                 return kDrawTriangles_DrawType;
             case kPoints_GrPrimitiveType:
                 return kDrawPoints_DrawType;
             case kLines_GrPrimitiveType:
             case kLineStrip_GrPrimitiveType:
                 return kDrawLines_DrawType;
             default:
                 SkFAIL("Unexpected primitive type");
                 return kDrawTriangles_DrawType;
         }
     }
 
     // Functions used to map clip-respecting stencil tests into normal
     // stencil funcs supported by GPUs.
     static GrStencilFunc ConvertStencilFunc(bool stencilInClip,
                                             GrStencilFunc func);
     static void ConvertStencilFuncAndMask(GrStencilFunc func,
                                           bool clipInStencil,
                                           unsigned int clipBit,
                                           unsigned int userBits,
                                           unsigned int* ref,
                                           unsigned int* mask);
 
-    // subclasses must call this in their destructors to ensure all vertex
-    // and index sources have been released (including those held by
-    // pushGeometrySource())
-    void releaseGeometry();
+    struct GeometrySrcState {
+        GeometrySrcState() : fVertexBuffer(NULL), fIndexBuffer(NULL), fVertexSize(0) {}
+        const GrVertexBuffer*   fVertexBuffer;
+        const GrIndexBuffer*    fIndexBuffer;
+        size_t                  fVertexSize;
+    };
 
     // accessors for derived classes
-    const GrDrawTarget::GeometrySrcState& getGeomSrc() const { return fGeoSrcStateStack.back(); }
+    const GeometrySrcState& getGeomSrc() const { return fGeoSrcState; }
 
     // it is preferable to call this rather than getGeomSrc()->fVertexSize because of the assert.
     size_t getVertexSize() const {
         // the vertex layout is only valid if a vertex source has been specified.
-        SkASSERT(this->getGeomSrc().fVertexSrc != GrDrawTarget::kNone_GeometrySrcType);
+        SkASSERT(this->getGeomSrc().fVertexBuffer);
         return this->getGeomSrc().fVertexSize;
     }
 
     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 
     GrContext::GPUStats         fGPUStats;
 
     struct GeometryPoolState {

[bsalomon, 2014/11/07 20:04:31]

delete?

         const GrVertexBuffer* fPoolVertexBuffer;
         int                   fPoolStartVertex;
 
         const GrIndexBuffer*  fPoolIndexBuffer;
         int                   fPoolStartIndex;
     };
-    const GeometryPoolState& getGeomPoolState() {
-        return fGeomPoolStateStack.back();
-    }
-
-    // Helpers for setting up geometry state
-    void finalizeReservedVertices();
-    void finalizeReservedIndices();
 
     SkAutoTDelete<GrPathRendering> fPathRendering;
 
     // Subclass must initialize this in its constructor.
     SkAutoTUnref<const GrDrawTargetCaps> fCaps;
 
 private:
-    // GrDrawTarget overrides
-    virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices);
-    virtual bool onReserveIndexSpace(int indexCount, void** indices);
-    virtual void releaseReservedVertexSpace();
-    virtual void releaseReservedIndexSpace();
-    virtual void geometrySourceWillPush();
-    virtual void geometrySourceWillPop(const GrDrawTarget::GeometrySrcState& restoredState);
-
     // called when the 3D context state is unknown. Subclass should emit any
     // assumed 3D context state and dirty any state cache.
     virtual void onResetContext(uint32_t resetBits) = 0;
 
     // overridden by backend-specific derived class to create objects.
     virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc,
                                        const void* srcData,
                                        size_t rowBytes) = 0;
     virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
                                                  const void* srcData) = 0;
@@ skipping 69 matching lines @@
                              int count,
                              const float transforms[],
                              GrDrawTarget::PathTransformType,
                              const GrClipMaskManager::ScissorState&,
                              const GrStencilSettings&,
                              const GrDeviceCoordTexture*);
 
     virtual void didAddGpuTraceMarker() = 0;
     virtual void didRemoveGpuTraceMarker() = 0;
 
-
-    // readies the pools to provide vertex/index data.
-    void prepareVertexPool();
-    void prepareIndexPool();
-
     void resetContext() {
         this->onResetContext(fResetBits);
         fResetBits = 0;
         ++fResetTimestamp;
     }
 
     void handleDirtyContext() {
         if (fResetBits) {
             this->resetContext();
         }
     }
 
-    // called when setting a new vert/idx source to unref prev vb/ib
-    void releasePreviousVertexSource();
-    void releasePreviousIndexSource();
-
-    enum {
-        kPreallocGeoSrcStateStackCnt = 4,
-    };
-    SkSTArray<kPreallocGeoSrcStateStackCnt, GrDrawTarget::GeometrySrcState, true> fGeoSrcStateStack;
-
-    enum {
-        kPreallocGeomPoolStateStackCnt = 4,
-    };
-    SkSTArray<kPreallocGeomPoolStateStackCnt, GeometryPoolState, true>  fGeomPoolStateStack;
+    GeometrySrcState                                                    fGeoSrcState;
     ResetTimestamp                                                      fResetTimestamp;
     uint32_t                                                            fResetBits;
-    GrVertexBufferAllocPool*                                            fVertexPool;
-    GrIndexBufferAllocPool*                                             fIndexPool;
-    // counts number of uses of vertex/index pool in the geometry stack
-    int                                                                 fVertexPoolUseCnt;
-    int                                                                 fIndexPoolUseCnt;
     // these are mutable so they can be created on-demand
     mutable GrIndexBuffer*                                              fQuadIndexBuffer;
-    GrDrawState                                                     fDefaultDrawState;
+    GrDrawState                                                         fDefaultDrawState;
     GrDrawState*                                                        fDrawState;
     // To keep track that we always have at least as many debug marker adds as removes
     int                                                                 fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                    fActiveTraceMarkers;
     GrTraceMarkerSet                                                    fStoredTraceMarkers;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     // TODO fix this
     friend class GrInOrderDrawBuffer;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif