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