tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 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 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 8 | #ifndef GrProcessor_DEFINED |
| 9 | #define GrProcessor_DEFINED |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 10 | |
bsalomon@google.com | 371e105 | 2013-01-11 21:08:55 +0000 | [diff] [blame] | 11 | #include "GrColor.h" |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 12 | #include "GrProcessorUnitTest.h" |
bsalomon | 9574098 | 2014-09-04 13:12:37 -0700 | [diff] [blame] | 13 | #include "GrProgramElement.h" |
bsalomon@google.com | 047696c | 2012-09-11 13:29:29 +0000 | [diff] [blame] | 14 | #include "GrTextureAccess.h" |
egdaniel | 9e4d6d1 | 2014-10-15 13:49:02 -0700 | [diff] [blame] | 15 | #include "SkMath.h" |
tomhudson@google.com | 07eecdc | 2012-04-20 18:35:38 +0000 | [diff] [blame] | 16 | |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 17 | class GrContext; |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 18 | class GrCoordTransform; |
egdaniel | 605dd0f | 2014-11-12 08:35:25 -0800 | [diff] [blame] | 19 | class GrInvariantOutput; |
bsalomon | 9574098 | 2014-09-04 13:12:37 -0700 | [diff] [blame] | 20 | |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 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 | |
bsalomon | 98b33eb | 2014-10-15 11:05:26 -0700 | [diff] [blame] | 51 | /** Provides custom shader code to the Ganesh shading pipeline. GrProcessor objects *must* be |
| 52 | immutable: after being constructed, their fields may not change. |
bsalomon@google.com | 0ac6af4 | 2013-01-16 15:16:18 +0000 | [diff] [blame] | 53 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 54 | Dynamically allocated GrProcessors are managed by a per-thread memory pool. The ref count of an |
bsalomon | 98b33eb | 2014-10-15 11:05:26 -0700 | [diff] [blame] | 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 | */ |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 58 | class GrProcessor : public GrProgramElement { |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 59 | public: |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 60 | SK_DECLARE_INST_COUNT(GrProcessor) |
robertphillips@google.com | 15e9d3e | 2012-06-21 20:25:03 +0000 | [diff] [blame] | 61 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 62 | virtual ~GrProcessor(); |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 63 | |
bsalomon | 98b33eb | 2014-10-15 11:05:26 -0700 | [diff] [blame] | 64 | /** Human-meaningful string to identify this prcoessor; may be embedded |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 65 | in generated shader code. */ |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 66 | virtual const char* name() const = 0; |
bsalomon@google.com | 289efe0 | 2012-05-21 20:57:59 +0000 | [diff] [blame] | 67 | |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 68 | int numTextures() const { return fTextureAccesses.count(); } |
tomhudson@google.com | d8f856c | 2012-05-10 12:13:36 +0000 | [diff] [blame] | 69 | |
bsalomon@google.com | 6d003d1 | 2012-09-11 15:45:20 +0000 | [diff] [blame] | 70 | /** Returns the access pattern for the texture at index. index must be valid according to |
| 71 | numTextures(). */ |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 72 | const GrTextureAccess& textureAccess(int index) const { return *fTextureAccesses[index]; } |
bsalomon@google.com | 6d003d1 | 2012-09-11 15:45:20 +0000 | [diff] [blame] | 73 | |
| 74 | /** Shortcut for textureAccess(index).texture(); */ |
| 75 | GrTexture* texture(int index) const { return this->textureAccess(index).getTexture(); } |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 76 | |
bsalomon | 98b33eb | 2014-10-15 11:05:26 -0700 | [diff] [blame] | 77 | /** Will this processor read the fragment position? */ |
commit-bot@chromium.org | 8d47ddc | 2013-05-09 14:55:46 +0000 | [diff] [blame] | 78 | bool willReadFragmentPosition() const { return fWillReadFragmentPosition; } |
commit-bot@chromium.org | ff6ea26 | 2013-03-12 12:26:08 +0000 | [diff] [blame] | 79 | |
tomhudson@google.com | dcba4c2 | 2012-07-24 21:36:16 +0000 | [diff] [blame] | 80 | void* operator new(size_t size); |
| 81 | void operator delete(void* target); |
| 82 | |
bsalomon@google.com | d42aca3 | 2013-04-23 15:37:27 +0000 | [diff] [blame] | 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 | |
joshualitt | 49586be | 2014-09-16 08:21:41 -0700 | [diff] [blame] | 90 | /** |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 91 | * Helper for down-casting to a GrProcessor subclass |
joshualitt | 49586be | 2014-09-16 08:21:41 -0700 | [diff] [blame] | 92 | */ |
| 93 | template <typename T> const T& cast() const { return *static_cast<const T*>(this); } |
| 94 | |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 95 | uint32_t classID() const { SkASSERT(kIllegalProcessorClassID != fClassID); return fClassID; } |
| 96 | |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 97 | protected: |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 98 | GrProcessor() : fClassID(kIllegalProcessorClassID), fWillReadFragmentPosition(false) {} |
bsalomon | 420d7e9 | 2014-10-16 09:18:09 -0700 | [diff] [blame] | 99 | |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 100 | /** |
bsalomon | 98b33eb | 2014-10-15 11:05:26 -0700 | [diff] [blame] | 101 | * Subclasses call this from their constructor to register GrTextureAccesses. The processor |
commit-bot@chromium.org | 91a798f | 2013-09-06 15:31:06 +0000 | [diff] [blame] | 102 | * subclass manages the lifetime of the accesses (this function only stores a pointer). The |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 103 | * GrTextureAccess is typically a member field of the GrProcessor subclass. This must only be |
| 104 | * called from the constructor because GrProcessors are immutable. |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 105 | */ |
| 106 | void addTextureAccess(const GrTextureAccess* textureAccess); |
| 107 | |
bsalomon | 420d7e9 | 2014-10-16 09:18:09 -0700 | [diff] [blame] | 108 | bool hasSameTextureAccesses(const GrProcessor&) const; |
commit-bot@chromium.org | 8d47ddc | 2013-05-09 14:55:46 +0000 | [diff] [blame] | 109 | |
| 110 | /** |
bsalomon | 98b33eb | 2014-10-15 11:05:26 -0700 | [diff] [blame] | 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. |
commit-bot@chromium.org | 8d47ddc | 2013-05-09 14:55:46 +0000 | [diff] [blame] | 114 | */ |
| 115 | void setWillReadFragmentPosition() { fWillReadFragmentPosition = true; } |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 116 | |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 117 | template <typename PROC_SUBCLASS> void initClassID() { |
| 118 | static uint32_t kClassID = GenClassID(); |
| 119 | fClassID = kClassID; |
| 120 | } |
| 121 | |
| 122 | uint32_t fClassID; |
| 123 | |
bsalomon | 0e08fc1 | 2014-10-15 08:19:04 -0700 | [diff] [blame] | 124 | private: |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 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; |
bsalomon@google.com | 0ac6af4 | 2013-01-16 15:16:18 +0000 | [diff] [blame] | 141 | |
commit-bot@chromium.org | ff6ea26 | 2013-03-12 12:26:08 +0000 | [diff] [blame] | 142 | SkSTArray<4, const GrTextureAccess*, true> fTextureAccesses; |
commit-bot@chromium.org | 8d47ddc | 2013-05-09 14:55:46 +0000 | [diff] [blame] | 143 | bool fWillReadFragmentPosition; |
bsalomon@google.com | 0ac6af4 | 2013-01-16 15:16:18 +0000 | [diff] [blame] | 144 | |
bsalomon | 9574098 | 2014-09-04 13:12:37 -0700 | [diff] [blame] | 145 | typedef GrProgramElement INHERITED; |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 146 | }; |
| 147 | |
bsalomon | 98b33eb | 2014-10-15 11:05:26 -0700 | [diff] [blame] | 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 | |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 157 | #endif |