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 | |
bsalomon@google.com | 8ea78d8 | 2012-10-24 20:11:30 +0000 | [diff] [blame] | 8 | #ifndef GrEffect_DEFINED |
| 9 | #define GrEffect_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" |
bsalomon@google.com | 6f261be | 2012-10-24 19:07:10 +0000 | [diff] [blame] | 12 | #include "GrEffectUnitTest.h" |
bsalomon | 9574098 | 2014-09-04 13:12:37 -0700 | [diff] [blame] | 13 | #include "GrProgramElement.h" |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 14 | #include "GrShaderVar.h" |
bsalomon@google.com | 047696c | 2012-09-11 13:29:29 +0000 | [diff] [blame] | 15 | #include "GrTextureAccess.h" |
commit-bot@chromium.org | ff6ea26 | 2013-03-12 12:26:08 +0000 | [diff] [blame] | 16 | #include "GrTypesPriv.h" |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 17 | #include "SkString.h" |
tomhudson@google.com | 07eecdc | 2012-04-20 18:35:38 +0000 | [diff] [blame] | 18 | |
bsalomon@google.com | 2eaaefd | 2012-10-29 19:51:22 +0000 | [diff] [blame] | 19 | class GrBackendEffectFactory; |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 20 | class GrContext; |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 21 | class GrCoordTransform; |
bsalomon | 9574098 | 2014-09-04 13:12:37 -0700 | [diff] [blame] | 22 | |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 23 | /** Provides custom vertex shader, fragment shader, uniform data for a particular stage of the |
| 24 | Ganesh shading pipeline. |
bsalomon@google.com | 289efe0 | 2012-05-21 20:57:59 +0000 | [diff] [blame] | 25 | Subclasses must have a function that produces a human-readable name: |
| 26 | static const char* Name(); |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 27 | GrEffect objects *must* be immutable: after being constructed, their fields may not change. |
bsalomon@google.com | 0ac6af4 | 2013-01-16 15:16:18 +0000 | [diff] [blame] | 28 | |
bsalomon | 97b9ab7 | 2014-07-08 06:52:35 -0700 | [diff] [blame] | 29 | Dynamically allocated GrEffects are managed by a per-thread memory pool. The ref count of an |
| 30 | effect must reach 0 before the thread terminates and the pool is destroyed. To create a static |
| 31 | effect use the macro GR_CREATE_STATIC_EFFECT declared below. |
bsalomon@google.com | 289efe0 | 2012-05-21 20:57:59 +0000 | [diff] [blame] | 32 | */ |
bsalomon | 9574098 | 2014-09-04 13:12:37 -0700 | [diff] [blame] | 33 | class GrEffect : public GrProgramElement { |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 34 | public: |
bsalomon@google.com | a469c28 | 2012-10-24 18:28:34 +0000 | [diff] [blame] | 35 | SK_DECLARE_INST_COUNT(GrEffect) |
robertphillips@google.com | 15e9d3e | 2012-06-21 20:25:03 +0000 | [diff] [blame] | 36 | |
bsalomon@google.com | a469c28 | 2012-10-24 18:28:34 +0000 | [diff] [blame] | 37 | virtual ~GrEffect(); |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 38 | |
bsalomon@google.com | 371e105 | 2013-01-11 21:08:55 +0000 | [diff] [blame] | 39 | /** |
bsalomon@google.com | 371e105 | 2013-01-11 21:08:55 +0000 | [diff] [blame] | 40 | * This function is used to perform optimizations. When called the color and validFlags params |
bsalomon@google.com | b8eb2e8 | 2013-03-28 13:46:42 +0000 | [diff] [blame] | 41 | * indicate whether the input components to this effect in the FS will have known values. |
| 42 | * validFlags is a bitfield of GrColorComponentFlags. The function updates both params to |
| 43 | * indicate known values of its output. A component of the color param only has meaning if the |
| 44 | * corresponding bit in validFlags is set. |
bsalomon@google.com | 371e105 | 2013-01-11 21:08:55 +0000 | [diff] [blame] | 45 | */ |
| 46 | virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const = 0; |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 47 | |
commit-bot@chromium.org | a34995e | 2013-10-23 05:42:03 +0000 | [diff] [blame] | 48 | /** Will this effect read the source color value? */ |
| 49 | bool willUseInputColor() const { return fWillUseInputColor; } |
| 50 | |
bsalomon@google.com | 422e81a | 2012-10-25 14:11:03 +0000 | [diff] [blame] | 51 | /** This object, besides creating back-end-specific helper objects, is used for run-time-type- |
| 52 | identification. The factory should be an instance of templated class, |
bsalomon@google.com | 396e61f | 2012-10-25 19:00:29 +0000 | [diff] [blame] | 53 | GrTBackendEffectFactory. It is templated on the subclass of GrEffect. The subclass must have |
bsalomon@google.com | 422e81a | 2012-10-25 14:11:03 +0000 | [diff] [blame] | 54 | a nested type (or typedef) named GLEffect which will be the subclass of GrGLEffect created |
| 55 | by the factory. |
bsalomon@google.com | ae4f96a | 2012-05-18 19:54:48 +0000 | [diff] [blame] | 56 | |
| 57 | Example: |
bsalomon@google.com | 8ea78d8 | 2012-10-24 20:11:30 +0000 | [diff] [blame] | 58 | class MyCustomEffect : public GrEffect { |
bsalomon@google.com | ae4f96a | 2012-05-18 19:54:48 +0000 | [diff] [blame] | 59 | ... |
bsalomon@google.com | 396e61f | 2012-10-25 19:00:29 +0000 | [diff] [blame] | 60 | virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { |
| 61 | return GrTBackendEffectFactory<MyCustomEffect>::getInstance(); |
bsalomon@google.com | ae4f96a | 2012-05-18 19:54:48 +0000 | [diff] [blame] | 62 | } |
| 63 | ... |
| 64 | }; |
| 65 | */ |
bsalomon@google.com | 396e61f | 2012-10-25 19:00:29 +0000 | [diff] [blame] | 66 | virtual const GrBackendEffectFactory& getFactory() const = 0; |
tomhudson@google.com | b88bbd2 | 2012-05-01 12:48:07 +0000 | [diff] [blame] | 67 | |
bsalomon@google.com | 68b58c9 | 2013-01-17 16:50:08 +0000 | [diff] [blame] | 68 | /** Returns true if this and other effect conservatively draw identically. It can only return |
| 69 | true when the two effects are of the same subclass (i.e. they return the same object from |
| 70 | from getFactory()). |
tomhudson@google.com | 1dcfa1f | 2012-07-09 18:21:28 +0000 | [diff] [blame] | 71 | |
bsalomon@google.com | 68b58c9 | 2013-01-17 16:50:08 +0000 | [diff] [blame] | 72 | A return value of true from isEqual() should not be used to test whether the effects would |
bsalomon | 63e99f7 | 2014-07-21 08:03:14 -0700 | [diff] [blame] | 73 | generate the same shader code. To test for identical code generation use the effects' keys |
| 74 | computed by the GrBackendEffectFactory. |
tomhudson@google.com | d0c1a06 | 2012-07-12 17:23:52 +0000 | [diff] [blame] | 75 | */ |
bsalomon | 97b9ab7 | 2014-07-08 06:52:35 -0700 | [diff] [blame] | 76 | bool isEqual(const GrEffect& other) const { |
| 77 | if (&this->getFactory() != &other.getFactory()) { |
| 78 | return false; |
| 79 | } |
| 80 | bool result = this->onIsEqual(other); |
| 81 | #ifdef SK_DEBUG |
| 82 | if (result) { |
| 83 | this->assertEquality(other); |
| 84 | } |
| 85 | #endif |
| 86 | return result; |
bsalomon@google.com | 68b58c9 | 2013-01-17 16:50:08 +0000 | [diff] [blame] | 87 | } |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 88 | |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 89 | /** Human-meaningful string to identify this effect; may be embedded |
| 90 | in generated shader code. */ |
bsalomon@google.com | 2eaaefd | 2012-10-29 19:51:22 +0000 | [diff] [blame] | 91 | const char* name() const; |
bsalomon@google.com | 289efe0 | 2012-05-21 20:57:59 +0000 | [diff] [blame] | 92 | |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 93 | int numTransforms() const { return fCoordTransforms.count(); } |
| 94 | |
| 95 | /** Returns the coordinate transformation at index. index must be valid according to |
| 96 | numTransforms(). */ |
| 97 | const GrCoordTransform& coordTransform(int index) const { return *fCoordTransforms[index]; } |
| 98 | |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 99 | int numTextures() const { return fTextureAccesses.count(); } |
tomhudson@google.com | d8f856c | 2012-05-10 12:13:36 +0000 | [diff] [blame] | 100 | |
bsalomon@google.com | 6d003d1 | 2012-09-11 15:45:20 +0000 | [diff] [blame] | 101 | /** Returns the access pattern for the texture at index. index must be valid according to |
| 102 | numTextures(). */ |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 103 | const GrTextureAccess& textureAccess(int index) const { return *fTextureAccesses[index]; } |
bsalomon@google.com | 6d003d1 | 2012-09-11 15:45:20 +0000 | [diff] [blame] | 104 | |
| 105 | /** Shortcut for textureAccess(index).texture(); */ |
| 106 | GrTexture* texture(int index) const { return this->textureAccess(index).getTexture(); } |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 107 | |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 108 | /** Will this effect read the destination pixel value? */ |
commit-bot@chromium.org | 8d47ddc | 2013-05-09 14:55:46 +0000 | [diff] [blame] | 109 | bool willReadDstColor() const { return fWillReadDstColor; } |
| 110 | |
| 111 | /** Will this effect read the fragment position? */ |
| 112 | bool willReadFragmentPosition() const { return fWillReadFragmentPosition; } |
commit-bot@chromium.org | ff6ea26 | 2013-03-12 12:26:08 +0000 | [diff] [blame] | 113 | |
commit-bot@chromium.org | 234d4fb | 2013-09-30 19:55:49 +0000 | [diff] [blame] | 114 | /** Will this effect emit custom vertex shader code? |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 115 | (To set this value the effect must inherit from GrEffect.) */ |
kkinnunen | ec56e45 | 2014-08-25 22:21:16 -0700 | [diff] [blame] | 116 | bool requiresVertexShader() const { return fRequiresVertexShader; } |
commit-bot@chromium.org | 234d4fb | 2013-09-30 19:55:49 +0000 | [diff] [blame] | 117 | |
commit-bot@chromium.org | ff6ea26 | 2013-03-12 12:26:08 +0000 | [diff] [blame] | 118 | static const int kMaxVertexAttribs = 2; |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 119 | typedef SkSTArray<kMaxVertexAttribs, GrShaderVar, true> VertexAttribArray; |
| 120 | |
| 121 | const VertexAttribArray& getVertexAttribs() const { return fVertexAttribs; } |
commit-bot@chromium.org | ff6ea26 | 2013-03-12 12:26:08 +0000 | [diff] [blame] | 122 | |
tomhudson@google.com | dcba4c2 | 2012-07-24 21:36:16 +0000 | [diff] [blame] | 123 | void* operator new(size_t size); |
| 124 | void operator delete(void* target); |
| 125 | |
bsalomon@google.com | d42aca3 | 2013-04-23 15:37:27 +0000 | [diff] [blame] | 126 | void* operator new(size_t size, void* placement) { |
| 127 | return ::operator new(size, placement); |
| 128 | } |
| 129 | void operator delete(void* target, void* placement) { |
| 130 | ::operator delete(target, placement); |
| 131 | } |
| 132 | |
joshualitt | 49586be | 2014-09-16 08:21:41 -0700 | [diff] [blame] | 133 | /** |
| 134 | * Helper for down-casting to a GrEffect subclass |
| 135 | */ |
| 136 | template <typename T> const T& cast() const { return *static_cast<const T*>(this); } |
| 137 | |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 138 | protected: |
| 139 | /** |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 140 | * Subclasses call this from their constructor to register coordinate transformations. The |
| 141 | * effect subclass manages the lifetime of the transformations (this function only stores a |
| 142 | * pointer). The GrCoordTransform is typically a member field of the GrEffect subclass. When the |
| 143 | * matrix has perspective, the transformed coordinates will have 3 components. Otherwise they'll |
| 144 | * have 2. This must only be called from the constructor because GrEffects are immutable. |
| 145 | */ |
| 146 | void addCoordTransform(const GrCoordTransform* coordTransform); |
| 147 | |
| 148 | /** |
skia.committer@gmail.com | 91274b9 | 2013-03-13 07:01:04 +0000 | [diff] [blame] | 149 | * Subclasses call this from their constructor to register GrTextureAccesses. The effect |
commit-bot@chromium.org | 91a798f | 2013-09-06 15:31:06 +0000 | [diff] [blame] | 150 | * subclass manages the lifetime of the accesses (this function only stores a pointer). The |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 151 | * GrTextureAccess is typically a member field of the GrEffect subclass. This must only be |
commit-bot@chromium.org | 91a798f | 2013-09-06 15:31:06 +0000 | [diff] [blame] | 152 | * called from the constructor because GrEffects are immutable. |
bsalomon@google.com | 50db75c | 2013-01-11 13:54:30 +0000 | [diff] [blame] | 153 | */ |
| 154 | void addTextureAccess(const GrTextureAccess* textureAccess); |
| 155 | |
commit-bot@chromium.org | 234d4fb | 2013-09-30 19:55:49 +0000 | [diff] [blame] | 156 | GrEffect() |
| 157 | : fWillReadDstColor(false) |
| 158 | , fWillReadFragmentPosition(false) |
commit-bot@chromium.org | a34995e | 2013-10-23 05:42:03 +0000 | [diff] [blame] | 159 | , fWillUseInputColor(true) |
kkinnunen | ec56e45 | 2014-08-25 22:21:16 -0700 | [diff] [blame] | 160 | , fRequiresVertexShader(false) {} |
bsalomon@google.com | 0ac6af4 | 2013-01-16 15:16:18 +0000 | [diff] [blame] | 161 | |
bsalomon | 0139ae3 | 2014-07-08 10:30:37 -0700 | [diff] [blame] | 162 | /** |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 163 | * If the effect subclass will read the destination pixel value then it must call this function |
| 164 | * from its constructor. Otherwise, when its generated backend-specific effect class attempts |
| 165 | * to generate code that reads the destination pixel it will fail. |
| 166 | */ |
commit-bot@chromium.org | 8d47ddc | 2013-05-09 14:55:46 +0000 | [diff] [blame] | 167 | void setWillReadDstColor() { fWillReadDstColor = true; } |
| 168 | |
| 169 | /** |
| 170 | * If the effect will generate a backend-specific effect that will read the fragment position |
| 171 | * in the FS then it must call this method from its constructor. Otherwise, the request to |
| 172 | * access the fragment position will be denied. |
| 173 | */ |
| 174 | void setWillReadFragmentPosition() { fWillReadFragmentPosition = true; } |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 175 | |
commit-bot@chromium.org | a34995e | 2013-10-23 05:42:03 +0000 | [diff] [blame] | 176 | /** |
| 177 | * If the effect will generate a result that does not depend on the input color value then it must |
| 178 | * call this function from its constructor. Otherwise, when its generated backend-specific code |
| 179 | * might fail during variable binding due to unused variables. |
| 180 | */ |
| 181 | void setWillNotUseInputColor() { fWillUseInputColor = false; } |
| 182 | |
tomhudson@google.com | d0c1a06 | 2012-07-12 17:23:52 +0000 | [diff] [blame] | 183 | private: |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 184 | SkDEBUGCODE(void assertEquality(const GrEffect& other) const;) |
| 185 | |
bsalomon@google.com | 68b58c9 | 2013-01-17 16:50:08 +0000 | [diff] [blame] | 186 | /** Subclass implements this to support isEqual(). It will only be called if it is known that |
bsalomon@google.com | 6340a41 | 2013-01-22 19:55:59 +0000 | [diff] [blame] | 187 | the two effects are of the same subclass (i.e. they return the same object from |
| 188 | getFactory()).*/ |
bsalomon@google.com | 8a252f7 | 2013-01-22 20:35:13 +0000 | [diff] [blame] | 189 | virtual bool onIsEqual(const GrEffect& other) const = 0; |
bsalomon@google.com | 68b58c9 | 2013-01-17 16:50:08 +0000 | [diff] [blame] | 190 | |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 191 | friend class GrGeometryProcessor; // to set fRequiresVertexShader and build fVertexAttribTypes. |
bsalomon@google.com | 0ac6af4 | 2013-01-16 15:16:18 +0000 | [diff] [blame] | 192 | |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 193 | SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms; |
commit-bot@chromium.org | ff6ea26 | 2013-03-12 12:26:08 +0000 | [diff] [blame] | 194 | SkSTArray<4, const GrTextureAccess*, true> fTextureAccesses; |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 195 | VertexAttribArray fVertexAttribs; |
commit-bot@chromium.org | 8d47ddc | 2013-05-09 14:55:46 +0000 | [diff] [blame] | 196 | bool fWillReadDstColor; |
| 197 | bool fWillReadFragmentPosition; |
commit-bot@chromium.org | a34995e | 2013-10-23 05:42:03 +0000 | [diff] [blame] | 198 | bool fWillUseInputColor; |
kkinnunen | ec56e45 | 2014-08-25 22:21:16 -0700 | [diff] [blame] | 199 | bool fRequiresVertexShader; |
bsalomon@google.com | 0ac6af4 | 2013-01-16 15:16:18 +0000 | [diff] [blame] | 200 | |
bsalomon | 9574098 | 2014-09-04 13:12:37 -0700 | [diff] [blame] | 201 | typedef GrProgramElement INHERITED; |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 202 | }; |
| 203 | |
bsalomon@google.com | d42aca3 | 2013-04-23 15:37:27 +0000 | [diff] [blame] | 204 | /** |
| 205 | * This creates an effect outside of the effect memory pool. The effect's destructor will be called |
bsalomon | 97b9ab7 | 2014-07-08 06:52:35 -0700 | [diff] [blame] | 206 | * at global destruction time. NAME will be the name of the created GrEffect. |
bsalomon@google.com | d42aca3 | 2013-04-23 15:37:27 +0000 | [diff] [blame] | 207 | */ |
| 208 | #define GR_CREATE_STATIC_EFFECT(NAME, EFFECT_CLASS, ARGS) \ |
bsalomon | 97b9ab7 | 2014-07-08 06:52:35 -0700 | [diff] [blame] | 209 | static SkAlignedSStorage<sizeof(EFFECT_CLASS)> g_##NAME##_Storage; \ |
| 210 | static GrEffect* NAME SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS); \ |
| 211 | static SkAutoTDestroy<GrEffect> NAME##_ad(NAME); |
bsalomon@google.com | d42aca3 | 2013-04-23 15:37:27 +0000 | [diff] [blame] | 212 | |
tomhudson@google.com | 168e634 | 2012-04-18 17:49:20 +0000 | [diff] [blame] | 213 | #endif |