OLD | NEW |
(Empty) | |
| 1 |
| 2 /* |
| 3 * Copyright 2015 Google Inc. |
| 4 * |
| 5 * Use of this source code is governed by a BSD-style license that can be |
| 6 * found in the LICENSE file. |
| 7 */ |
| 8 |
| 9 // This test only works with the GPU backend. |
| 10 |
| 11 #include "gm.h" |
| 12 |
| 13 #if SK_SUPPORT_GPU |
| 14 |
| 15 #include "GrContext.h" |
| 16 #include "GrTest.h" |
| 17 #include "effects/GrConstColorProcessor.h" |
| 18 #include "SkGr.h" |
| 19 #include "SkGradientShader.h" |
| 20 |
| 21 namespace skiagm { |
| 22 /** |
| 23 * This GM directly exercises GrConstColorProcessor. |
| 24 */ |
| 25 class ConstColorProcessor : public GM { |
| 26 public: |
| 27 ConstColorProcessor() { |
| 28 this->setBGColor(0xFFDDDDDD); |
| 29 } |
| 30 |
| 31 protected: |
| 32 SkString onShortName() override { |
| 33 return SkString("const_color_processor"); |
| 34 } |
| 35 |
| 36 SkISize onISize() override { |
| 37 return SkISize::Make(kWidth, kHeight); |
| 38 } |
| 39 |
| 40 void onOnceBeforeDraw() override { |
| 41 SkColor colors[] = { 0xFFFF0000, 0x2000FF00, 0xFF0000FF}; |
| 42 SkPoint pts[] = { SkPoint::Make(0, 0), SkPoint::Make(kRectSize, kRectSiz
e) }; |
| 43 fShader.reset(SkGradientShader::CreateLinear(pts, colors, NULL, SK_ARRAY
_COUNT(colors), |
| 44 SkShader::kClamp_TileMode)); |
| 45 } |
| 46 |
| 47 void onDraw(SkCanvas* canvas) override { |
| 48 GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget
(); |
| 49 if (NULL == rt) { |
| 50 return; |
| 51 } |
| 52 GrContext* context = rt->getContext(); |
| 53 if (NULL == context) { |
| 54 this->drawGpuOnlyMessage(canvas); |
| 55 return; |
| 56 } |
| 57 |
| 58 static const GrColor kColors[] = { |
| 59 0xFFFFFFFF, |
| 60 0xFFFF00FF, |
| 61 0x80000000, |
| 62 0x00000000, |
| 63 }; |
| 64 |
| 65 static const SkColor kPaintColors[] = { |
| 66 0xFFFFFFFF, |
| 67 0xFFFF0000, |
| 68 0x80FF0000, |
| 69 0x00000000, |
| 70 }; |
| 71 |
| 72 static const char* kModeStrs[] { |
| 73 "kIgnore", |
| 74 "kModulateRGBA", |
| 75 "kModulateA", |
| 76 }; |
| 77 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kModeStrs) == GrConstColorProcessor::kIn
putModeCnt); |
| 78 |
| 79 SkScalar y = kPad; |
| 80 SkScalar x = kPad; |
| 81 SkScalar maxW = 0; |
| 82 for (size_t paintType = 0; paintType < SK_ARRAY_COUNT(kPaintColors) + 1;
++paintType) { |
| 83 for (size_t procColor = 0; procColor < SK_ARRAY_COUNT(kColors); ++pr
ocColor) { |
| 84 for (int m = 0; m < GrConstColorProcessor::kInputModeCnt; ++m) { |
| 85 // translate by x,y for the canvas draws and the test target
draws. |
| 86 canvas->save(); |
| 87 canvas->translate(x, y); |
| 88 const SkMatrix viewMatrix = SkMatrix::MakeTrans(x, y); |
| 89 |
| 90 // rect to draw |
| 91 SkRect renderRect = SkRect::MakeXYWH(0, 0, kRectSize, kRectS
ize); |
| 92 |
| 93 GrTestTarget tt; |
| 94 context->getTestTarget(&tt); |
| 95 if (NULL == tt.target()) { |
| 96 SkDEBUGFAIL("Couldn't get Gr test target."); |
| 97 return; |
| 98 } |
| 99 |
| 100 GrPaint grPaint; |
| 101 SkPaint skPaint; |
| 102 if (paintType >= SK_ARRAY_COUNT(kPaintColors)) { |
| 103 skPaint.setShader(fShader); |
| 104 } else { |
| 105 skPaint.setColor(kPaintColors[paintType]); |
| 106 } |
| 107 SkPaint2GrPaintShader(context, rt, skPaint, viewMatrix, fals
e, &grPaint); |
| 108 |
| 109 GrConstColorProcessor::InputMode mode = (GrConstColorProcess
or::InputMode) m; |
| 110 GrColor color = kColors[procColor]; |
| 111 SkAutoTUnref<GrFragmentProcessor> fp(GrConstColorProcessor::
Create(color, mode)); |
| 112 |
| 113 GrPipelineBuilder pipelineBuilder; |
| 114 GrClip clip; |
| 115 pipelineBuilder.setFromPaint(grPaint, rt, clip); |
| 116 pipelineBuilder.addColorProcessor(fp); |
| 117 |
| 118 tt.target()->drawSimpleRect(&pipelineBuilder, |
| 119 grPaint.getColor(), |
| 120 viewMatrix, |
| 121 renderRect); |
| 122 |
| 123 // Draw labels for the input to the processor and the proces
sor to the right of |
| 124 // the test rect. The input label appears above the processo
r label. |
| 125 SkPaint labelPaint; |
| 126 labelPaint.setAntiAlias(true); |
| 127 labelPaint.setTextSize(10.f); |
| 128 SkString inputLabel; |
| 129 inputLabel.set("Input: "); |
| 130 if (paintType >= SK_ARRAY_COUNT(kPaintColors)) { |
| 131 inputLabel.append("gradient"); |
| 132 } else { |
| 133 inputLabel.appendf("0x%08x", kPaintColors[paintType]); |
| 134 } |
| 135 SkString procLabel; |
| 136 procLabel.printf("Proc: [0x%08x, %s]", kColors[procColor], k
ModeStrs[m]); |
| 137 |
| 138 SkRect inputLabelBounds; |
| 139 // get the bounds of the text in order to position it |
| 140 labelPaint.measureText(inputLabel.c_str(), inputLabel.size()
, |
| 141 &inputLabelBounds); |
| 142 canvas->drawText(inputLabel.c_str(), inputLabel.size(), |
| 143 renderRect.fRight + kPad, |
| 144 -inputLabelBounds.fTop, labelPaint); |
| 145 // update the bounds to reflect the offset we used to draw i
t. |
| 146 inputLabelBounds.offset(renderRect.fRight + kPad, -inputLabe
lBounds.fTop); |
| 147 |
| 148 SkRect procLabelBounds; |
| 149 labelPaint.measureText(procLabel.c_str(), procLabel.size(), |
| 150 &procLabelBounds); |
| 151 canvas->drawText(procLabel.c_str(), procLabel.size(), |
| 152 renderRect.fRight + kPad, |
| 153 inputLabelBounds.fBottom + 2.f - procLabelB
ounds.fTop, |
| 154 labelPaint); |
| 155 procLabelBounds.offset(renderRect.fRight + kPad, |
| 156 inputLabelBounds.fBottom + 2.f - proc
LabelBounds.fTop); |
| 157 |
| 158 labelPaint.setStrokeWidth(0); |
| 159 labelPaint.setStyle(SkPaint::kStroke_Style); |
| 160 canvas->drawRect(renderRect, labelPaint); |
| 161 |
| 162 canvas->restore(); |
| 163 |
| 164 // update x and y for the next test case. |
| 165 SkScalar height = renderRect.height(); |
| 166 SkScalar width = SkTMax(inputLabelBounds.fRight, procLabelBo
unds.fRight); |
| 167 maxW = SkTMax(maxW, width); |
| 168 y += height + kPad; |
| 169 if (y + height > kHeight) { |
| 170 y = kPad; |
| 171 x += maxW + kPad; |
| 172 maxW = 0; |
| 173 } |
| 174 } |
| 175 } |
| 176 } |
| 177 } |
| 178 |
| 179 private: |
| 180 // Use this as a way of generating and input FP |
| 181 SkAutoTUnref<SkShader> fShader; |
| 182 |
| 183 static const SkScalar kPad; |
| 184 static const SkScalar kRectSize; |
| 185 static const int kWidth = 820; |
| 186 static const int kHeight = 500; |
| 187 |
| 188 typedef GM INHERITED; |
| 189 }; |
| 190 |
| 191 const SkScalar ConstColorProcessor::kPad = 10.f; |
| 192 const SkScalar ConstColorProcessor::kRectSize = 20.f; |
| 193 |
| 194 DEF_GM( return SkNEW(ConstColorProcessor); ) |
| 195 } |
| 196 |
| 197 #endif |
OLD | NEW |