gm.h 9.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232
  1. /*
  2. * Copyright 2011 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. #ifndef skiagm_DEFINED
  8. #define skiagm_DEFINED
  9. #include "include/core/SkColor.h"
  10. #include "include/core/SkScalar.h"
  11. #include "include/core/SkSize.h"
  12. #include "include/core/SkString.h"
  13. #include "include/core/SkTypes.h"
  14. #include "include/private/SkMacros.h"
  15. #include "tools/Registry.h"
  16. class GrContext;
  17. class GrRenderTargetContext;
  18. class SkCanvas;
  19. class SkMetaData;
  20. struct GrContextOptions;
  21. #define DEF_GM(code) \
  22. static skiagm::GM* SK_MACRO_APPEND_LINE(F_)(void*) { code; } \
  23. static skiagm::GMRegistry SK_MACRO_APPEND_LINE(R_)(SK_MACRO_APPEND_LINE(F_));
  24. // A Simple GM is a rendering test that does not store state between rendering calls or make use of
  25. // the onOnceBeforeDraw() virtual; it consists of:
  26. // * A name.
  27. // * Prefered width and height.
  28. // * Optionally, a background color (default is white).
  29. // * A standalone function pointer that implements its onDraw method.
  30. #define DEF_SIMPLE_GM(NAME, CANVAS, W, H) \
  31. DEF_SIMPLE_GM_BG_NAME(NAME, CANVAS, W, H, SK_ColorWHITE, SkString(#NAME))
  32. #define DEF_SIMPLE_GM_BG(NAME, CANVAS, W, H, BGCOLOR) \
  33. DEF_SIMPLE_GM_BG_NAME(NAME, CANVAS, W, H, BGCOLOR, SkString(#NAME))
  34. #define DEF_SIMPLE_GM_BG_NAME(NAME, CANVAS, W, H, BGCOLOR, NAME_STR) \
  35. static void SK_MACRO_CONCAT(NAME,_GM_inner)(SkCanvas*); \
  36. DEF_SIMPLE_GM_BG_NAME_CAN_FAIL(NAME, CANVAS,, W, H, BGCOLOR, NAME_STR) { \
  37. SK_MACRO_CONCAT(NAME,_GM_inner)(CANVAS); \
  38. return skiagm::DrawResult::kOk; \
  39. } \
  40. void SK_MACRO_CONCAT(NAME,_GM_inner)(SkCanvas* CANVAS)
  41. #define DEF_SIMPLE_GM_CAN_FAIL(NAME, CANVAS, ERR_MSG, W, H) \
  42. DEF_SIMPLE_GM_BG_NAME_CAN_FAIL(NAME, CANVAS, ERR_MSG, W, H, SK_ColorWHITE, SkString(#NAME))
  43. #define DEF_SIMPLE_GM_BG_CAN_FAIL(NAME, CANVAS, ERR_MSG, W, H, BGCOLOR) \
  44. DEF_SIMPLE_GM_BG_NAME_CAN_FAIL(NAME, CANVAS, ERR_MSG, W, H, BGCOLOR, SkString(#NAME))
  45. #define DEF_SIMPLE_GM_BG_NAME_CAN_FAIL(NAME, CANVAS, ERR_MSG, W, H, BGCOLOR, NAME_STR) \
  46. static skiagm::DrawResult SK_MACRO_CONCAT(NAME,_GM)(SkCanvas*, SkString*); \
  47. DEF_GM(return new skiagm::SimpleGM(BGCOLOR, NAME_STR, {W,H}, SK_MACRO_CONCAT(NAME,_GM));) \
  48. skiagm::DrawResult SK_MACRO_CONCAT(NAME,_GM)(SkCanvas* CANVAS, SkString* ERR_MSG)
  49. // A Simple GpuGM makes direct GPU calls. Its onDraw hook that includes GPU objects as params, and
  50. // is only invoked on GPU configs. Non-GPU configs automatically draw a GPU-only message and abort.
  51. #define DEF_SIMPLE_GPU_GM(NAME, GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS, W, H) \
  52. DEF_SIMPLE_GPU_GM_BG(NAME, GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS, W, H, SK_ColorWHITE)
  53. #define DEF_SIMPLE_GPU_GM_BG(NAME, GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS, W, H, BGCOLOR) \
  54. static void SK_MACRO_CONCAT(NAME,_GM_inner)(GrContext*, GrRenderTargetContext*, SkCanvas*); \
  55. DEF_SIMPLE_GPU_GM_BG_CAN_FAIL(NAME, GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS,, W, H, \
  56. BGCOLOR) { \
  57. SK_MACRO_CONCAT(NAME,_GM_inner)(GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS); \
  58. return skiagm::DrawResult::kOk; \
  59. } \
  60. void SK_MACRO_CONCAT(NAME,_GM_inner)( \
  61. GrContext* GR_CONTEXT, GrRenderTargetContext* RENDER_TARGET_CONTEXT, SkCanvas* CANVAS)
  62. #define DEF_SIMPLE_GPU_GM_CAN_FAIL(NAME, GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS, ERR_MSG, W, H) \
  63. DEF_SIMPLE_GPU_GM_BG_CAN_FAIL(NAME, GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS, \
  64. ERR_MSG, W, H, SK_ColorWHITE)
  65. #define DEF_SIMPLE_GPU_GM_BG_CAN_FAIL(NAME, GR_CONTEXT, RENDER_TARGET_CONTEXT, CANVAS, ERR_MSG, W, \
  66. H, BGCOLOR) \
  67. static skiagm::DrawResult SK_MACRO_CONCAT(NAME,_GM)( \
  68. GrContext*, GrRenderTargetContext*, SkCanvas*, SkString*); \
  69. DEF_GM(return new skiagm::SimpleGpuGM(BGCOLOR, SkString(#NAME), {W,H}, \
  70. SK_MACRO_CONCAT(NAME,_GM));) \
  71. skiagm::DrawResult SK_MACRO_CONCAT(NAME,_GM)( \
  72. GrContext* GR_CONTEXT, GrRenderTargetContext* RENDER_TARGET_CONTEXT, SkCanvas* CANVAS, \
  73. SkString* ERR_MSG)
  74. namespace skiagm {
  75. enum class DrawResult {
  76. kOk, // Test drew successfully.
  77. kFail, // Test failed to draw.
  78. kSkip // Test is not applicable in this context and should be skipped.
  79. };
  80. class GM {
  81. public:
  82. using DrawResult = skiagm::DrawResult;
  83. GM(SkColor backgroundColor = SK_ColorWHITE);
  84. virtual ~GM();
  85. enum Mode {
  86. kGM_Mode,
  87. kSample_Mode,
  88. kBench_Mode,
  89. };
  90. void setMode(Mode mode) { fMode = mode; }
  91. Mode getMode() const { return fMode; }
  92. static constexpr char kErrorMsg_DrawSkippedGpuOnly[] = "This test is for GPU configs only.";
  93. DrawResult draw(SkCanvas* canvas) {
  94. SkString errorMsg;
  95. return this->draw(canvas, &errorMsg);
  96. }
  97. DrawResult draw(SkCanvas*, SkString* errorMsg);
  98. void drawBackground(SkCanvas*);
  99. DrawResult drawContent(SkCanvas* canvas) {
  100. SkString errorMsg;
  101. return this->drawContent(canvas, &errorMsg);
  102. }
  103. DrawResult drawContent(SkCanvas*, SkString* errorMsg);
  104. SkISize getISize() { return this->onISize(); }
  105. const char* getName();
  106. virtual bool runAsBench() const;
  107. SkScalar width() {
  108. return SkIntToScalar(this->getISize().width());
  109. }
  110. SkScalar height() {
  111. return SkIntToScalar(this->getISize().height());
  112. }
  113. SkColor getBGColor() const { return fBGColor; }
  114. void setBGColor(SkColor);
  115. // helper: fill a rect in the specified color based on the GM's getISize bounds.
  116. void drawSizeBounds(SkCanvas*, SkColor);
  117. bool isCanvasDeferred() const { return fCanvasIsDeferred; }
  118. void setCanvasIsDeferred(bool isDeferred) {
  119. fCanvasIsDeferred = isDeferred;
  120. }
  121. bool animate(double /*nanos*/);
  122. virtual bool onChar(SkUnichar);
  123. bool getControls(SkMetaData* controls) { return this->onGetControls(controls); }
  124. void setControls(const SkMetaData& controls) { this->onSetControls(controls); }
  125. virtual void modifyGrContextOptions(GrContextOptions*);
  126. protected:
  127. virtual void onOnceBeforeDraw();
  128. virtual DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg);
  129. virtual void onDraw(SkCanvas*);
  130. virtual SkISize onISize() = 0;
  131. virtual SkString onShortName() = 0;
  132. virtual bool onAnimate(double /*nanos*/);
  133. virtual bool onGetControls(SkMetaData*);
  134. virtual void onSetControls(const SkMetaData&);
  135. private:
  136. Mode fMode;
  137. SkString fShortName;
  138. SkColor fBGColor;
  139. bool fCanvasIsDeferred; // work-around problem in srcmode.cpp
  140. bool fHaveCalledOnceBeforeDraw;
  141. };
  142. typedef GM*(*GMFactory)(void*) ;
  143. typedef sk_tools::Registry<GMFactory> GMRegistry;
  144. // A GpuGM replaces the onDraw method with one that also accepts GPU objects alongside the
  145. // SkCanvas. Its onDraw is only invoked on GPU configs; on non-GPU configs it will automatically
  146. // draw a GPU-only message and abort.
  147. class GpuGM : public GM {
  148. public:
  149. GpuGM(SkColor backgroundColor = SK_ColorWHITE) : GM(backgroundColor) {}
  150. private:
  151. using GM::onDraw;
  152. DrawResult onDraw(SkCanvas*, SkString* errorMsg) final;
  153. virtual DrawResult onDraw(GrContext* ctx, GrRenderTargetContext* rtc, SkCanvas* canvas,
  154. SkString* errorMsg);
  155. virtual void onDraw(GrContext*, GrRenderTargetContext*, SkCanvas*);
  156. };
  157. // SimpleGM is intended for basic GMs that can define their entire implementation inside a
  158. // single "draw" function pointer.
  159. class SimpleGM : public GM {
  160. public:
  161. using DrawProc = DrawResult(*)(SkCanvas*, SkString*);
  162. SimpleGM(SkColor bgColor, const SkString& name, const SkISize& size, DrawProc drawProc)
  163. : GM(bgColor), fName(name), fSize(size), fDrawProc(drawProc) {}
  164. private:
  165. SkISize onISize() override;
  166. SkString onShortName() override;
  167. DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg) override;
  168. const SkString fName;
  169. const SkISize fSize;
  170. const DrawProc fDrawProc;
  171. };
  172. class SimpleGpuGM : public GpuGM {
  173. public:
  174. using DrawProc = DrawResult(*)(GrContext*, GrRenderTargetContext*, SkCanvas*, SkString*);
  175. SimpleGpuGM(SkColor bgColor, const SkString& name, const SkISize& size, DrawProc drawProc)
  176. : GpuGM(bgColor), fName(name), fSize(size), fDrawProc(drawProc) {}
  177. private:
  178. SkISize onISize() override;
  179. SkString onShortName() override;
  180. DrawResult onDraw(GrContext* ctx, GrRenderTargetContext* rtc, SkCanvas* canvas,
  181. SkString* errorMsg) override;
  182. const SkString fName;
  183. const SkISize fSize;
  184. const DrawProc fDrawProc;
  185. };
  186. }
  187. void MarkGMGood(SkCanvas*, SkScalar x, SkScalar y);
  188. void MarkGMBad (SkCanvas*, SkScalar x, SkScalar y);
  189. #endif