Home | History | Annotate | Download | only in gpu 
      1 /*
      2  * Copyright 2012 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #ifndef GrProcessor_DEFINED
      9 #define GrProcessor_DEFINED
     10 
     11 #include "GrColor.h"
     12 #include "GrProcessorUnitTest.h"
     13 #include "GrProgramElement.h"
     14 #include "GrTextureAccess.h"
     15 #include "SkMath.h"
     16 #include "SkString.h"
     17 
     18 class GrContext;
     19 class GrCoordTransform;
     20 class GrInvariantOutput;
     21 
     22 /**
     23  * Used by processors to build their keys. It incorporates each per-processor key into a larger
     24  * shader key.
     25  */
     26 class GrProcessorKeyBuilder {
     27 public:
     28     GrProcessorKeyBuilder(SkTArray<unsigned char, true>* data) : fData(data), fCount(0) {
     29         SkASSERT(0 == fData->count() % sizeof(uint32_t));
     30     }
     31 
     32     void add32(uint32_t v) {
     33         ++fCount;
     34         fData->push_back_n(4, reinterpret_cast<uint8_t*>(&v));
     35     }
     36 
     37     /** Inserts count uint32_ts into the key. The returned pointer is only valid until the next
     38         add*() call. */
     39     uint32_t* SK_WARN_UNUSED_RESULT add32n(int count) {
     40         SkASSERT(count > 0);
     41         fCount += count;
     42         return reinterpret_cast<uint32_t*>(fData->push_back_n(4 * count));
     43     }
     44 
     45     size_t size() const { return sizeof(uint32_t) * fCount; }
     46 
     47 private:
     48     SkTArray<uint8_t, true>* fData; // unowned ptr to the larger key.
     49     int fCount;                     // number of uint32_ts added to fData by the processor.
     50 };
     51 
     52 /** Provides custom shader code to the Ganesh shading pipeline. GrProcessor objects *must* be
     53     immutable: after being constructed, their fields may not change.
     54 
     55     Dynamically allocated GrProcessors are managed by a per-thread memory pool. The ref count of an
     56     processor must reach 0 before the thread terminates and the pool is destroyed.
     57  */
     58 class GrProcessor : public GrProgramElement {
     59 public:
     60     virtual ~GrProcessor();
     61 
     62     /** Human-meaningful string to identify this prcoessor; may be embedded
     63         in generated shader code. */
     64     virtual const char* name() const = 0;
     65 
     66     // Human-readable dump of all information
     67     virtual SkString dumpInfo() const {
     68         SkString str;
     69         str.appendf("Missing data");
     70         return str;
     71     }
     72 
     73     int numTextures() const { return fTextureAccesses.count(); }
     74 
     75     /** Returns the access pattern for the texture at index. index must be valid according to
     76         numTextures(). */
     77     const GrTextureAccess& textureAccess(int index) const { return *fTextureAccesses[index]; }
     78 
     79     /** Shortcut for textureAccess(index).texture(); */
     80     GrTexture* texture(int index) const { return this->textureAccess(index).getTexture(); }
     81 
     82     /** Will this processor read the fragment position? */
     83     bool willReadFragmentPosition() const { return fWillReadFragmentPosition; }
     84 
     85     void* operator new(size_t size);
     86     void operator delete(void* target);
     87 
     88     void* operator new(size_t size, void* placement) {
     89         return ::operator new(size, placement);
     90     }
     91     void operator delete(void* target, void* placement) {
     92         ::operator delete(target, placement);
     93     }
     94 
     95     /**
     96       * Helper for down-casting to a GrProcessor subclass
     97       */
     98     template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
     99 
    100     uint32_t classID() const { SkASSERT(kIllegalProcessorClassID != fClassID); return fClassID; }
    101 
    102 protected:
    103     GrProcessor() : fClassID(kIllegalProcessorClassID), fWillReadFragmentPosition(false) {}
    104 
    105     /**
    106      * Subclasses call this from their constructor to register GrTextureAccesses. The processor
    107      * subclass manages the lifetime of the accesses (this function only stores a pointer). The
    108      * GrTextureAccess is typically a member field of the GrProcessor subclass. This must only be
    109      * called from the constructor because GrProcessors are immutable.
    110      */
    111     virtual void addTextureAccess(const GrTextureAccess* textureAccess);
    112 
    113     bool hasSameTextureAccesses(const GrProcessor&) const;
    114 
    115     /**
    116      * If the prcoessor will generate a backend-specific processor that will read the fragment
    117      * position in the FS then it must call this method from its constructor. Otherwise, the
    118      * request to access the fragment position will be denied.
    119      */
    120     void setWillReadFragmentPosition() { fWillReadFragmentPosition = true; }
    121 
    122     template <typename PROC_SUBCLASS> void initClassID() {
    123          static uint32_t kClassID = GenClassID();
    124          fClassID = kClassID;
    125     }
    126 
    127     uint32_t fClassID;
    128     SkSTArray<4, const GrTextureAccess*, true>   fTextureAccesses;
    129 
    130 private:
    131     static uint32_t GenClassID() {
    132         // fCurrProcessorClassID has been initialized to kIllegalProcessorClassID. The
    133         // atomic inc returns the old value not the incremented value. So we add
    134         // 1 to the returned value.
    135         uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrProcessorClassID)) + 1;
    136         if (!id) {
    137             SkFAIL("This should never wrap as it should only be called once for each GrProcessor "
    138                    "subclass.");
    139         }
    140         return id;
    141     }
    142 
    143     enum {
    144         kIllegalProcessorClassID = 0,
    145     };
    146     static int32_t gCurrProcessorClassID;
    147 
    148     bool                                         fWillReadFragmentPosition;
    149 
    150     typedef GrProgramElement INHERITED;
    151 };
    152 
    153 #endif
    154