blob: 0e9392a717a4ad7684c9ee1ccc06efda9d9bf8a5 [file] [log] [blame]
joshualittb0a8a372014-09-23 09:50:21 -07001/*
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
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "include/core/SkTypes.h"
Hal Canary6f6961e2017-01-31 13:50:44 -050012
13#if GR_TEST_UTILS
14
Mike Kleinc0bd9f92019-04-23 12:05:21 -050015#include "include/private/SkTArray.h"
16#include "src/gpu/GrTestUtils.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040017#include "src/gpu/GrTextureProxy.h"
joshualittb0a8a372014-09-23 09:50:21 -070018
19class SkMatrix;
bsalomon4b91f762015-05-19 09:29:46 -070020class GrCaps;
joshualitt0067ff52015-07-08 14:26:19 -070021class GrContext;
Robert Phillips1afd4cd2018-01-08 13:40:32 -050022class GrProxyProvider;
Brian Osman11052242016-10-27 14:47:55 -040023class GrRenderTargetContext;
bsalomon506c8022015-09-14 13:16:26 -070024struct GrProcessorTestData;
Mike Reedd4706732016-11-15 16:44:34 -050025class GrTexture;
Brian Salomona1633922017-01-09 11:46:10 -050026class GrXPFactory;
Brian Salomon1c053642017-07-24 10:16:19 -040027class GrGeometryProcessor;
joshualittb0a8a372014-09-23 09:50:21 -070028
29namespace GrProcessorUnitTest {
bsalomon506c8022015-09-14 13:16:26 -070030
joshualittb0a8a372014-09-23 09:50:21 -070031// Used to access the dummy textures in TestCreate procs.
32enum {
33 kSkiaPMTextureIdx = 0,
34 kAlphaTextureIdx = 1,
35};
36
bsalomon506c8022015-09-14 13:16:26 -070037/** This allows parent FPs to implement a test create with known leaf children in order to avoid
38creating an unbounded FP tree which may overflow various shader limits. */
Brian Salomonaff329b2017-08-11 09:40:37 -040039std::unique_ptr<GrFragmentProcessor> MakeChildFP(GrProcessorTestData*);
bsalomon506c8022015-09-14 13:16:26 -070040
joshualitt2e3b3e32014-12-09 13:31:14 -080041}
42
joshualitt0067ff52015-07-08 14:26:19 -070043/*
44 * GrProcessorTestData is an argument struct to TestCreate functions
45 * fTextures are valid textures that can optionally be used to construct
Brian Salomon0bbecb22016-11-17 11:38:22 -050046 * TextureSampler. The first texture has config kSkia8888_GrPixelConfig and the second has
joshualitt0067ff52015-07-08 14:26:19 -070047 * kAlpha_8_GrPixelConfig. TestCreate functions are also free to create additional textures using
48 * the GrContext.
49 */
50struct GrProcessorTestData {
51 GrProcessorTestData(SkRandom* random,
52 GrContext* context,
Brian Osman11052242016-10-27 14:47:55 -040053 const GrRenderTargetContext* renderTargetContext,
Robert Phillipse78b7252017-04-06 07:59:41 -040054 sk_sp<GrTextureProxy> proxies[2])
Robert Phillipsdbc8eeb2017-02-21 10:04:31 -050055 : fRandom(random)
56 , fRenderTargetContext(renderTargetContext)
57 , fContext(context) {
Robert Phillipsbb581ce2017-05-29 15:05:15 -040058 SkASSERT(proxies[0] && proxies[1]);
Robert Phillipse78b7252017-04-06 07:59:41 -040059 fProxies[0] = proxies[0];
60 fProxies[1] = proxies[1];
joshualitt0067ff52015-07-08 14:26:19 -070061 }
62 SkRandom* fRandom;
Brian Osman11052242016-10-27 14:47:55 -040063 const GrRenderTargetContext* fRenderTargetContext;
Robert Phillips757914d2017-01-25 15:48:30 -050064
65 GrContext* context() { return fContext; }
Robert Phillips296b1cc2017-03-15 10:42:12 -040066 GrResourceProvider* resourceProvider();
Robert Phillips1afd4cd2018-01-08 13:40:32 -050067 GrProxyProvider* proxyProvider();
Robert Phillips296b1cc2017-03-15 10:42:12 -040068 const GrCaps* caps();
Robert Phillips63c67462017-02-15 14:19:01 -050069 sk_sp<GrTextureProxy> textureProxy(int index) { return fProxies[index]; }
Robert Phillips757914d2017-01-25 15:48:30 -050070
71private:
Robert Phillipsdbc8eeb2017-02-21 10:04:31 -050072 GrContext* fContext;
Robert Phillips63c67462017-02-15 14:19:01 -050073 sk_sp<GrTextureProxy> fProxies[2];
joshualitt0067ff52015-07-08 14:26:19 -070074};
75
joshualittb0a8a372014-09-23 09:50:21 -070076class GrProcessor;
77class GrTexture;
78
Brian Salomon1c053642017-07-24 10:16:19 -040079template <class ProcessorSmartPtr>
80class GrProcessorTestFactory : private SkNoncopyable {
joshualittb0a8a372014-09-23 09:50:21 -070081public:
Brian Salomon1c053642017-07-24 10:16:19 -040082 using Processor = typename ProcessorSmartPtr::element_type;
83 using MakeProc = ProcessorSmartPtr (*)(GrProcessorTestData*);
joshualittb0a8a372014-09-23 09:50:21 -070084
bungeman06ca8ec2016-06-09 08:01:03 -070085 GrProcessorTestFactory(MakeProc makeProc) {
86 fMakeProc = makeProc;
joshualittb0a8a372014-09-23 09:50:21 -070087 GetFactories()->push_back(this);
88 }
89
bsalomonb5b60322015-09-14 12:26:33 -070090 /** Pick a random factory function and create a processor. */
Brian Salomon1c053642017-07-24 10:16:19 -040091 static ProcessorSmartPtr Make(GrProcessorTestData* data) {
joshualitt9e87fa72014-10-09 13:12:35 -070092 VerifyFactoryCount();
Ben Wagnerf1344ac2019-05-10 15:01:53 -040093 if (GetFactories()->count() == 0) {
94 return nullptr;
95 }
joshualitt0067ff52015-07-08 14:26:19 -070096 uint32_t idx = data->fRandom->nextRangeU(0, GetFactories()->count() - 1);
bungeman06ca8ec2016-06-09 08:01:03 -070097 return MakeIdx(idx, data);
bsalomonb5b60322015-09-14 12:26:33 -070098 }
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. */
Brian Salomon94e0b112017-07-28 16:02:46 -0400104 static ProcessorSmartPtr MakeIdx(int idx, GrProcessorTestData* data) {
Ben Wagnerf1344ac2019-05-10 15:01:53 -0400105 SkASSERT(idx < GetFactories()->count());
Brian Salomon1c053642017-07-24 10:16:19 -0400106 GrProcessorTestFactory<ProcessorSmartPtr>* factory = (*GetFactories())[idx];
107 ProcessorSmartPtr processor = factory->fMakeProc(data);
Brian Salomona1633922017-01-09 11:46:10 -0500108 SkASSERT(processor);
109 return processor;
joshualittb0a8a372014-09-23 09:50:21 -0700110 }
111
Brian Salomona1633922017-01-09 11:46:10 -0500112private:
113 /**
joshualitt9e87fa72014-10-09 13:12:35 -0700114 * A test function which verifies the count of factories.
115 */
116 static void VerifyFactoryCount();
117
bungeman06ca8ec2016-06-09 08:01:03 -0700118 MakeProc fMakeProc;
joshualittb0a8a372014-09-23 09:50:21 -0700119
Brian Salomon1c053642017-07-24 10:16:19 -0400120 static SkTArray<GrProcessorTestFactory<ProcessorSmartPtr>*, true>* GetFactories();
joshualittb0a8a372014-09-23 09:50:21 -0700121};
122
Brian Salomonaff329b2017-08-11 09:40:37 -0400123using GrFragmentProcessorTestFactory = GrProcessorTestFactory<std::unique_ptr<GrFragmentProcessor>>;
Brian Salomon1c053642017-07-24 10:16:19 -0400124using GrGeometryProcessorTestFactory = GrProcessorTestFactory<sk_sp<GrGeometryProcessor>>;
125
Brian Salomona1633922017-01-09 11:46:10 -0500126class GrXPFactoryTestFactory : private SkNoncopyable {
127public:
128 using GetFn = const GrXPFactory*(GrProcessorTestData*);
129
130 GrXPFactoryTestFactory(GetFn* getProc) : fGetProc(getProc) { GetFactories()->push_back(this); }
131
132 static const GrXPFactory* Get(GrProcessorTestData* data) {
133 VerifyFactoryCount();
Ben Wagnerf1344ac2019-05-10 15:01:53 -0400134 if (GetFactories()->count() == 0) {
135 return nullptr;
136 }
Brian Salomona1633922017-01-09 11:46:10 -0500137 uint32_t idx = data->fRandom->nextRangeU(0, GetFactories()->count() - 1);
138 const GrXPFactory* xpf = (*GetFactories())[idx]->fGetProc(data);
139 SkASSERT(xpf);
140 return xpf;
141 }
142
143private:
144 static void VerifyFactoryCount();
145
146 GetFn* fGetProc;
147 static SkTArray<GrXPFactoryTestFactory*, true>* GetFactories();
148};
149
Ben Wagnerf1344ac2019-05-10 15:01:53 -0400150#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
151
joshualittb0a8a372014-09-23 09:50:21 -0700152/** GrProcessor subclasses should insert this macro in their declaration to be included in the
153 * program generation unit test.
154 */
Brian Salomon1c053642017-07-24 10:16:19 -0400155#define GR_DECLARE_GEOMETRY_PROCESSOR_TEST \
156 static GrGeometryProcessorTestFactory gTestFactory SK_UNUSED; \
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400157 static sk_sp<GrGeometryProcessor> TestCreate(GrProcessorTestData*);
joshualittb0a8a372014-09-23 09:50:21 -0700158
Brian Salomon1c053642017-07-24 10:16:19 -0400159#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
160 static GrFragmentProcessorTestFactory gTestFactory SK_UNUSED; \
Brian Salomonaff329b2017-08-11 09:40:37 -0400161 static std::unique_ptr<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
joshualittb0a8a372014-09-23 09:50:21 -0700162
egdanielc2304142014-12-11 13:15:13 -0800163#define GR_DECLARE_XP_FACTORY_TEST \
Brian Salomona1633922017-01-09 11:46:10 -0500164 static GrXPFactoryTestFactory gTestFactory SK_UNUSED; \
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400165 static const GrXPFactory* TestGet(GrProcessorTestData*);
egdanielc2304142014-12-11 13:15:13 -0800166
joshualittb0a8a372014-09-23 09:50:21 -0700167/** GrProcessor subclasses should insert this macro in their implementation file. They must then
168 * also implement this static function:
joshualitt0067ff52015-07-08 14:26:19 -0700169 * GrProcessor* TestCreate(GrProcessorTestData*);
joshualittb0a8a372014-09-23 09:50:21 -0700170 */
Brian Salomon1c053642017-07-24 10:16:19 -0400171#define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Effect) \
172 GrFragmentProcessorTestFactory Effect::gTestFactory(Effect::TestCreate)
Brian Salomon003312a2017-01-09 16:00:33 +0000173
Brian Salomon1c053642017-07-24 10:16:19 -0400174#define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(Effect) \
175 GrGeometryProcessorTestFactory Effect::gTestFactory(Effect::TestCreate)
Brian Salomona1633922017-01-09 11:46:10 -0500176
177#define GR_DEFINE_XP_FACTORY_TEST(Factory) \
178 GrXPFactoryTestFactory Factory::gTestFactory(Factory::TestGet)
joshualittb0a8a372014-09-23 09:50:21 -0700179
180#else // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
181
182// The unit test relies on static initializers. Just declare the TestCreate function so that
183// its definitions will compile.
184#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
Brian Salomonaff329b2017-08-11 09:40:37 -0400185 static std::unique_ptr<GrFragmentProcessor> TestCreate(GrProcessorTestData*);
joshualittb0a8a372014-09-23 09:50:21 -0700186#define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(X)
187
188// The unit test relies on static initializers. Just declare the TestCreate function so that
189// its definitions will compile.
190#define GR_DECLARE_GEOMETRY_PROCESSOR_TEST \
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400191 static sk_sp<GrGeometryProcessor> TestCreate(GrProcessorTestData*);
joshualittb0a8a372014-09-23 09:50:21 -0700192#define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(X)
193
Brian Salomona1633922017-01-09 11:46:10 -0500194// The unit test relies on static initializers. Just declare the TestGet function so that
195// its definitions will compile.
196#define GR_DECLARE_XP_FACTORY_TEST \
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400197 const GrXPFactory* TestGet(GrProcessorTestData*);
Brian Salomona1633922017-01-09 11:46:10 -0500198#define GR_DEFINE_XP_FACTORY_TEST(X)
199
Hal Canary6f6961e2017-01-31 13:50:44 -0500200#endif // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
201#else // GR_TEST_UTILS
202 #define GR_DECLARE_GEOMETRY_PROCESSOR_TEST
203 #define GR_DECLARE_FRAGMENT_PROCESSOR_TEST
204 #define GR_DECLARE_XP_FACTORY_TEST
205 #define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(...)
206 #define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(...)
207 #define GR_DEFINE_XP_FACTORY_TEST(...)
208 #define GR_DECLARE_FRAGMENT_PROCESSOR_TEST
209 #define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(...)
210 #define GR_DECLARE_GEOMETRY_PROCESSOR_TEST
211 #define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(...)
212 #define GR_DECLARE_XP_FACTORY_TEST
213 #define GR_DEFINE_XP_FACTORY_TEST(...)
214#endif // GR_TEST_UTILS
215#endif // GrProcessorUnitTest_DEFINED