OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2015 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 WrappedBenchmark_DEFINED | |
9 #define WrappedBenchmark_DEFINED | |
10 | |
11 #include "Benchmark.h" | |
12 #include "SkSurface.h" | |
13 #include "GrContext.h" | |
14 #include "GrDrawContext.h" | |
15 #include "GrRenderTarget.h" | |
16 | |
17 // Wrap some other benchmark to allow specialization to either | |
18 // cpu or gpu backends. The derived class will override 'setupOffScreen' | |
19 // to create an offscreen surface in which the actual rendering will occur. | |
20 class WrappedBenchmark : public Benchmark { | |
21 public: | |
22 // Takes ownership of caller's ref on `bench`. | |
23 explicit WrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark* ben
ch) | |
24 : fSurfaceProps(surfaceProps) | |
25 , fBench(bench) {} | |
26 | |
27 const SkSurfaceProps& surfaceProps() const { return fSurfaceProps; } | |
28 | |
29 const char* onGetName() override { return fBench->getName(); } | |
30 const char* onGetUniqueName() override { return fBench->getUniqueName(); } | |
31 | |
32 void onDelayedSetup() override { fBench->delayedSetup(); } | |
33 void onPerCanvasPreDraw(SkCanvas* canvas) override { | |
34 this->setupOffScreen(canvas); | |
35 fOffScreen->getCanvas()->clear(SK_ColorWHITE); | |
36 fBench->perCanvasPreDraw(fOffScreen->getCanvas()); | |
37 } | |
38 void onPreDraw(SkCanvas* canvas) override { | |
39 SkASSERT(fOffScreen); | |
40 fBench->preDraw(fOffScreen->getCanvas()); | |
41 } | |
42 void onPostDraw(SkCanvas* canvas) override { | |
43 SkASSERT(fOffScreen); | |
44 fBench->postDraw(fOffScreen->getCanvas()); | |
45 } | |
46 void onPerCanvasPostDraw(SkCanvas* canvas) override { | |
47 SkASSERT(fOffScreen); | |
48 fBench->perCanvasPostDraw(fOffScreen->getCanvas()); | |
49 } | |
50 | |
51 void onDraw(int loops, SkCanvas* canvas) override { | |
52 SkASSERT(fOffScreen); | |
53 fBench->draw(loops, fOffScreen->getCanvas()); | |
54 this->blitToScreen(canvas); | |
55 } | |
56 | |
57 virtual SkIPoint onGetSize() override { return fBench->getSize(); } | |
58 | |
59 protected: | |
60 virtual void setupOffScreen(SkCanvas*)=0; | |
61 | |
62 void blitToScreen(SkCanvas* canvas) { | |
63 int w = SkTMin(fBench->getSize().fX, fOffScreen->width()); | |
64 int h = SkTMin(fBench->getSize().fY, fOffScreen->width()); | |
65 this->onBlitToScreen(canvas, w, h); | |
66 } | |
67 | |
68 virtual void onBlitToScreen(SkCanvas* canvas, int w, int h) = 0; | |
69 | |
70 SkSurfaceProps fSurfaceProps; | |
71 sk_sp<SkSurface> fOffScreen; | |
72 SkAutoTUnref<Benchmark> fBench; | |
73 }; | |
74 | |
75 // Create a raster surface for off screen rendering | |
76 class CpuWrappedBenchmark : public WrappedBenchmark { | |
77 public: | |
78 explicit CpuWrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark*
bench) | |
79 : INHERITED(surfaceProps, bench) {} | |
80 | |
81 private: | |
82 void setupOffScreen(SkCanvas* canvas) override { | |
83 fOffScreen = SkSurface::MakeRaster(canvas->imageInfo(), &this->surfacePr
ops()); | |
84 } | |
85 | |
86 void onBlitToScreen(SkCanvas* canvas, int w, int h) override { | |
87 sk_sp<SkImage> image(fOffScreen->makeImageSnapshot()); | |
88 SkPaint blitPaint; | |
89 blitPaint.setXfermodeMode(SkXfermode::kSrc_Mode); | |
90 canvas->drawImageRect(image.get(), SkIRect::MakeWH(w, h), | |
91 SkRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h))
, &blitPaint); | |
92 } | |
93 | |
94 typedef WrappedBenchmark INHERITED; | |
95 }; | |
96 | |
97 // Create an MSAA & NVPR-enabled GPU backend | |
98 class GpuWrappedBenchmark : public WrappedBenchmark { | |
99 public: | |
100 explicit GpuWrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark*
bench, | |
101 int numSamples) | |
102 : INHERITED(surfaceProps, bench) | |
103 , fNumSamples(numSamples) {} | |
104 | |
105 private: | |
106 void setupOffScreen(SkCanvas* canvas) override { | |
107 fOffScreen = SkSurface::MakeRenderTarget(canvas->getGrContext(), | |
108 SkBudgeted::kNo, | |
109 canvas->imageInfo(), | |
110 fNumSamples, | |
111 &this->surfaceProps()); | |
112 } | |
113 | |
114 void onBlitToScreen(SkCanvas* canvas, int w, int h) override { | |
115 // We call copySurface directly on the underlying GPU surfaces for a mor
e efficient blit. | |
116 GrDrawContext* dstDC = canvas->internal_private_accessTopLayerDrawContex
t(); | |
117 SkASSERT(dstDC); | |
118 | |
119 GrDrawContext* srcDC = | |
120 fOffScreen->getCanvas()->internal_private_accessTopL
ayerDrawContext(); | |
121 SkASSERT(srcDC); | |
122 GrRenderTarget* src = srcDC->accessRenderTarget(); | |
123 SkASSERT(src); | |
124 | |
125 SkASSERT(canvas->getGrContext() == fOffScreen->getCanvas()->getGrContext
()); | |
126 | |
127 dstDC->copySurface(src, SkIRect::MakeWH(w, h), SkIPoint::Make(0, 0)); | |
128 } | |
129 | |
130 int fNumSamples; | |
131 typedef WrappedBenchmark INHERITED; | |
132 }; | |
133 | |
134 #endif //WrappedBenchmark_DEFINED | |
OLD | NEW |