Implement texel buffers

include/gpu/GrProcessor.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrProcessor_DEFINED
 #define GrProcessor_DEFINED
 
 #include "GrColor.h"
 #include "GrProcessorUnitTest.h"
 #include "GrProgramElement.h"
 #include "GrTextureAccess.h"
+#include "GrBufferAccess.h"
 #include "SkMath.h"
 #include "SkString.h"
 
 class GrContext;
 class GrCoordTransform;
 class GrInvariantOutput;
 
 /**
  * Used by processors to build their keys. It incorporates each per-processor key into a larger
  * shader key.
@@ skipping 47 matching lines @@
 
     int numTextures() const { return fTextureAccesses.count(); }
 
     /** Returns the access pattern for the texture at index. index must be valid according to
         numTextures(). */
     const GrTextureAccess& textureAccess(int index) const { return *fTextureAccesses[index]; }
 
     /** Shortcut for textureAccess(index).texture(); */
     GrTexture* texture(int index) const { return this->textureAccess(index).getTexture(); }
 
+    int numBuffers() const { return fBufferAccesses.count(); }
+
+    /** Returns the access pattern for the buffer at index. index must be valid according to
+        numBuffers(). */
+    const GrBufferAccess& bufferAccess(int index) const {
+        return *fBufferAccesses[index];
+    }
+
     /**
      * Platform specific built-in features that a processor can request for the fragment shader.
      */
     enum RequiredFeatures {
         kNone_RequiredFeatures             = 0,
         kFragmentPosition_RequiredFeature  = 1 << 0,
         kSampleLocations_RequiredFeature   = 1 << 1
     };
 
     GR_DECL_BITFIELD_OPS_FRIENDS(RequiredFeatures);
@@ skipping 14 matching lines @@
       * Helper for down-casting to a GrProcessor subclass
       */
     template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
 
     uint32_t classID() const { SkASSERT(kIllegalProcessorClassID != fClassID); return fClassID; }
 
 protected:
     GrProcessor() : fClassID(kIllegalProcessorClassID), fRequiredFeatures(kNone_RequiredFeatures) {}
 
     /**
-     * Subclasses call this from their constructor to register GrTextureAccesses. The processor
-     * subclass manages the lifetime of the accesses (this function only stores a pointer). The
-     * GrTextureAccess is typically a member field of the GrProcessor subclass. This must only be
-     * called from the constructor because GrProcessors are immutable.
+     * Subclasses call these from their constructor to register sampler sources. The processor
+     * subclass manages the lifetime of the objects (these functions only store pointers). The
+     * GrTextureAccess and/or GrBufferAccess instances are typically member fields of the
+     * GrProcessor subclass. These must only be called from the constructor because GrProcessors
+     * are immutable.
      */
     virtual void addTextureAccess(const GrTextureAccess* textureAccess);
+    virtual void addBufferAccess(const GrBufferAccess* bufferAccess);
 
-    bool hasSameTextureAccesses(const GrProcessor&) const;
+    bool hasSameSamplers(const GrProcessor&) const;
 
     /**
      * If the prcoessor will generate code that uses platform specific built-in features, then it
      * must call these methods from its constructor. Otherwise, requests to use these features will
      * be denied.
      */
     void setWillReadFragmentPosition() { fRequiredFeatures |= kFragmentPosition_RequiredFeature; }
     void setWillUseSampleLocations() { fRequiredFeatures |= kSampleLocations_RequiredFeature; }
 
     void combineRequiredFeatures(const GrProcessor& other) {
         fRequiredFeatures |= other.fRequiredFeatures;
     }
 
     template <typename PROC_SUBCLASS> void initClassID() {
          static uint32_t kClassID = GenClassID();
          fClassID = kClassID;
     }
 
     uint32_t fClassID;
     SkSTArray<4, const GrTextureAccess*, true>   fTextureAccesses;
+    SkSTArray<2, const GrBufferAccess*, true>    fBufferAccesses;
 
 private:
     static uint32_t GenClassID() {
         // fCurrProcessorClassID has been initialized to kIllegalProcessorClassID. The
         // atomic inc returns the old value not the incremented value. So we add
         // 1 to the returned value.
         uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrProcessorClassID)) + 1;
         if (!id) {
             SkFAIL("This should never wrap as it should only be called once for each GrProcessor "
                    "subclass.");
         }
         return id;
     }
 
     enum {
         kIllegalProcessorClassID = 0,
     };
     static int32_t gCurrProcessorClassID;
 
     RequiredFeatures fRequiredFeatures;
 
     typedef GrProgramElement INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrProcessor::RequiredFeatures);
 
 #endif