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 GrProcessorUnitTest_DEFINED
9 #define GrProcessorUnitTest_DEFINED
10 
11 #include "SkTypes.h"
12 
13 #if GR_TEST_UTILS
14 
15 #include "../private/GrTextureProxy.h"
16 #include "../private/SkTArray.h"
17 #include "GrTestUtils.h"
18 
19 class SkMatrix;
20 class GrCaps;
21 class GrContext;
22 class GrProxyProvider;
23 class GrRenderTargetContext;
24 struct GrProcessorTestData;
25 class GrTexture;
26 class GrXPFactory;
27 class GrGeometryProcessor;
28 
29 namespace GrProcessorUnitTest {
30 
31 // Used to access the dummy textures in TestCreate procs.
32 enum {
33     kSkiaPMTextureIdx = 0,
34     kAlphaTextureIdx = 1,
35 };
36 
37 /** This allows parent FPs to implement a test create with known leaf children in order to avoid
38 creating an unbounded FP tree which may overflow various shader limits. */
39 std::unique_ptr<GrFragmentProcessor> MakeChildFP(GrProcessorTestData*);
40 
41 }
42 
43 /*
44  * GrProcessorTestData is an argument struct to TestCreate functions
45  * fTextures are valid textures that can optionally be used to construct
46  * TextureSampler. The first texture has config kSkia8888_GrPixelConfig and the second has
47  * kAlpha_8_GrPixelConfig. TestCreate functions are also free to create additional textures using
48  * the GrContext.
49  */
50 struct GrProcessorTestData {
51     GrProcessorTestData(SkRandom* random,
52                         GrContext* context,
53                         const GrRenderTargetContext* renderTargetContext,
54                         sk_sp<GrTextureProxy> proxies[2])
55             : fRandom(random)
56             , fRenderTargetContext(renderTargetContext)
57             , fContext(context) {
58         SkASSERT(proxies[0] && proxies[1]);
59         fProxies[0] = proxies[0];
60         fProxies[1] = proxies[1];
61     }
62     SkRandom* fRandom;
63     const GrRenderTargetContext* fRenderTargetContext;
64 
65     GrContext* context() { return fContext; }
66     GrResourceProvider* resourceProvider();
67     GrProxyProvider* proxyProvider();
68     const GrCaps* caps();
69     sk_sp<GrTextureProxy> textureProxy(int index) { return fProxies[index]; }
70 
71 private:
72     GrContext* fContext;
73     sk_sp<GrTextureProxy> fProxies[2];
74 };
75 
76 #if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
77 
78 class GrProcessor;
79 class GrTexture;
80 
81 template <class ProcessorSmartPtr>
82 class GrProcessorTestFactory : private SkNoncopyable {
83 public:
84     using Processor = typename ProcessorSmartPtr::element_type;
85     using MakeProc = ProcessorSmartPtr (*)(GrProcessorTestData*);
86 
87     GrProcessorTestFactory(MakeProc makeProc) {
88         fMakeProc = makeProc;
89         GetFactories()->push_back(this);
90     }
91 
92     /** Pick a random factory function and create a processor.  */
93     static ProcessorSmartPtr Make(GrProcessorTestData* data) {
94         VerifyFactoryCount();
95         SkASSERT(GetFactories()->count());
96         uint32_t idx = data->fRandom->nextRangeU(0, GetFactories()->count() - 1);
97         return MakeIdx(idx, data);
98     }
99 
100     /** Number of registered factory functions */
101     static int Count() { return GetFactories()->count(); }
102 
103     /** Use factory function at Index idx to create a processor. */
104     static ProcessorSmartPtr MakeIdx(int idx, GrProcessorTestData* data) {
105         GrProcessorTestFactory<ProcessorSmartPtr>* factory = (*GetFactories())[idx];
106         ProcessorSmartPtr processor = factory->fMakeProc(data);
107         SkASSERT(processor);
108         return processor;
109     }
110 
111 private:
112     /**
113      * A test function which verifies the count of factories.
114      */
115     static void VerifyFactoryCount();
116 
117     MakeProc fMakeProc;
118 
119     static SkTArray<GrProcessorTestFactory<ProcessorSmartPtr>*, true>* GetFactories();
120 };
121 
122 using GrFragmentProcessorTestFactory = GrProcessorTestFactory<std::unique_ptr<GrFragmentProcessor>>;
123 using GrGeometryProcessorTestFactory = GrProcessorTestFactory<sk_sp<GrGeometryProcessor>>;
124 
125 class GrXPFactoryTestFactory : private SkNoncopyable {
126 public:
127     using GetFn = const GrXPFactory*(GrProcessorTestData*);
128 
129     GrXPFactoryTestFactory(GetFn* getProc) : fGetProc(getProc) { GetFactories()->push_back(this); }
130 
131     static const GrXPFactory* Get(GrProcessorTestData* data) {
132         VerifyFactoryCount();
133         SkASSERT(GetFactories()->count());
134         uint32_t idx = data->fRandom->nextRangeU(0, GetFactories()->count() - 1);
135         const GrXPFactory* xpf = (*GetFactories())[idx]->fGetProc(data);
136         SkASSERT(xpf);
137         return xpf;
138     }
139 
140 private:
141     static void VerifyFactoryCount();
142 
143     GetFn* fGetProc;
144     static SkTArray<GrXPFactoryTestFactory*, true>* GetFactories();
145 };
146 
147 /** GrProcessor subclasses should insert this macro in their declaration to be included in the
148  *  program generation unit test.
149  */
150 #define GR_DECLARE_GEOMETRY_PROCESSOR_TEST                        \
151     static GrGeometryProcessorTestFactory gTestFactory SK_UNUSED; \
152     static sk_sp<GrGeometryProcessor> TestCreate(GrProcessorTestData*);
153 
154 #define GR_DECLARE_FRAGMENT_PROCESSOR_TEST                        \
155     static GrFragmentProcessorTestFactory gTestFactory SK_UNUSED; \
156     static std::unique_ptr<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
157 
158 #define GR_DECLARE_XP_FACTORY_TEST                                                                 \
159     static GrXPFactoryTestFactory gTestFactory SK_UNUSED;                                          \
160     static const GrXPFactory* TestGet(GrProcessorTestData*);
161 
162 /** GrProcessor subclasses should insert this macro in their implementation file. They must then
163  *  also implement this static function:
164  *      GrProcessor* TestCreate(GrProcessorTestData*);
165  */
166 #define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Effect) \
167     GrFragmentProcessorTestFactory Effect::gTestFactory(Effect::TestCreate)
168 
169 #define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(Effect) \
170     GrGeometryProcessorTestFactory Effect::gTestFactory(Effect::TestCreate)
171 
172 #define GR_DEFINE_XP_FACTORY_TEST(Factory)                                                         \
173     GrXPFactoryTestFactory Factory::gTestFactory(Factory::TestGet)
174 
175 #else // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
176 
177 // The unit test relies on static initializers. Just declare the TestCreate function so that
178 // its definitions will compile.
179 #define GR_DECLARE_FRAGMENT_PROCESSOR_TEST                                                         \
180     static std::unique_ptr<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
181 #define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(X)
182 
183 // The unit test relies on static initializers. Just declare the TestCreate function so that
184 // its definitions will compile.
185 #define GR_DECLARE_GEOMETRY_PROCESSOR_TEST                                                         \
186     static sk_sp<GrGeometryProcessor> TestCreate(GrProcessorTestData*);
187 #define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(X)
188 
189 // The unit test relies on static initializers. Just declare the TestGet function so that
190 // its definitions will compile.
191 #define GR_DECLARE_XP_FACTORY_TEST                                                                 \
192     const GrXPFactory* TestGet(GrProcessorTestData*);
193 #define GR_DEFINE_XP_FACTORY_TEST(X)
194 
195 #endif  // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
196 #else   // GR_TEST_UTILS
197     #define GR_DECLARE_GEOMETRY_PROCESSOR_TEST
198     #define GR_DECLARE_FRAGMENT_PROCESSOR_TEST
199     #define GR_DECLARE_XP_FACTORY_TEST
200     #define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(...)
201     #define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(...)
202     #define GR_DEFINE_XP_FACTORY_TEST(...)
203     #define GR_DECLARE_FRAGMENT_PROCESSOR_TEST
204     #define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(...)
205     #define GR_DECLARE_GEOMETRY_PROCESSOR_TEST
206     #define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(...)
207     #define GR_DECLARE_XP_FACTORY_TEST
208     #define GR_DEFINE_XP_FACTORY_TEST(...)
209 #endif  // GR_TEST_UTILS
210 #endif  // GrProcessorUnitTest_DEFINED
211