OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright 2016 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 #include "SkNormalBevelSource.h" |
| 9 |
| 10 #include "SkNormalSource.h" |
| 11 #include "SkPoint3.h" |
| 12 #include "SkReadBuffer.h" |
| 13 #include "SkWriteBuffer.h" |
| 14 |
| 15 #if SK_SUPPORT_GPU |
| 16 #include "GrInvariantOutput.h" |
| 17 #include "glsl/GrGLSLFragmentProcessor.h" |
| 18 #include "glsl/GrGLSLFragmentShaderBuilder.h" |
| 19 #include "SkGr.h" |
| 20 |
| 21 class NormalBevelFP : public GrFragmentProcessor { |
| 22 public: |
| 23 NormalBevelFP(SkNormalSource::BevelType type, SkScalar width, SkScalar heigh
t) |
| 24 : fType(type) |
| 25 , fWidth(width) |
| 26 , fHeight(height) { |
| 27 this->initClassID<NormalBevelFP>(); |
| 28 } |
| 29 |
| 30 class GLSLNormalBevelFP : public GrGLSLFragmentProcessor { |
| 31 public: |
| 32 GLSLNormalBevelFP() { |
| 33 fPrevWidth = SkFloatToScalar(0.0f); |
| 34 fPrevHeight = SkFloatToScalar(0.0f); |
| 35 } |
| 36 |
| 37 void emitCode(EmitArgs& args) override { |
| 38 GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder; |
| 39 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; |
| 40 |
| 41 const char* widthUniName = nullptr; |
| 42 fWidthUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloa
t_GrSLType, |
| 43 kDefault_GrSLPrecision, "Width", &widthUniName); |
| 44 |
| 45 const char* heightUniName = nullptr; |
| 46 fHeightUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kFlo
at_GrSLType, |
| 47 kDefault_GrSLPrecision, "Height", &heightUniName); |
| 48 |
| 49 fragBuilder->codeAppendf("%s = vec4(0, 0, 1, 0);", args.fOutputColor
); |
| 50 } |
| 51 |
| 52 static void GenKey(const GrProcessor& proc, const GrGLSLCaps&, |
| 53 GrProcessorKeyBuilder* b) { |
| 54 const NormalBevelFP& fp = proc.cast<NormalBevelFP>(); |
| 55 b->add32(static_cast<int>(fp.fType)); |
| 56 } |
| 57 |
| 58 protected: |
| 59 void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor&
proc) override { |
| 60 const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>(); |
| 61 |
| 62 if (fPrevWidth != normalBevelFP.fWidth) { |
| 63 pdman.set1f(fWidthUni, normalBevelFP.fWidth); |
| 64 fPrevWidth = normalBevelFP.fWidth; |
| 65 } |
| 66 if (fPrevHeight != normalBevelFP.fHeight) { |
| 67 pdman.set1f(fHeightUni, normalBevelFP.fHeight); |
| 68 fPrevHeight = normalBevelFP.fHeight; |
| 69 } |
| 70 } |
| 71 |
| 72 private: |
| 73 SkScalar fPrevWidth; |
| 74 GrGLSLProgramDataManager::UniformHandle fWidthUni; |
| 75 |
| 76 SkScalar fPrevHeight; |
| 77 GrGLSLProgramDataManager::UniformHandle fHeightUni; |
| 78 }; |
| 79 |
| 80 void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b)
const override { |
| 81 GLSLNormalBevelFP::GenKey(*this, caps, b); |
| 82 } |
| 83 |
| 84 const char* name() const override { return "NormalBevelFP"; } |
| 85 |
| 86 void onComputeInvariantOutput(GrInvariantOutput* inout) const override { |
| 87 inout->setToUnknown(GrInvariantOutput::ReadInput::kWillNot_ReadInput); |
| 88 } |
| 89 |
| 90 private: |
| 91 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new
GLSLNormalBevelFP; } |
| 92 |
| 93 bool onIsEqual(const GrFragmentProcessor& proc) const override { |
| 94 const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>(); |
| 95 return fType == normalBevelFP.fType && |
| 96 fWidth == normalBevelFP.fWidth && |
| 97 fHeight == normalBevelFP.fHeight; |
| 98 } |
| 99 |
| 100 SkNormalSource::BevelType fType; |
| 101 SkScalar fWidth; |
| 102 SkScalar fHeight; |
| 103 }; |
| 104 |
| 105 sk_sp<GrFragmentProcessor> SkNormalBevelSourceImpl::asFragmentProcessor( |
| 106 const SkShader::AsFPArgs&) const { |
| 107 |
| 108 return sk_make_sp<NormalBevelFP>(fType, fWidth, fHeight); |
| 109 } |
| 110 |
| 111 #endif // SK_SUPPORT_GPU |
| 112 |
| 113 //////////////////////////////////////////////////////////////////////////// |
| 114 |
| 115 SkNormalBevelSourceImpl::Provider::Provider() {} |
| 116 |
| 117 SkNormalBevelSourceImpl::Provider::~Provider() {} |
| 118 |
| 119 SkNormalSource::Provider* SkNormalBevelSourceImpl::asProvider(const SkShader::Co
ntextRec &rec, |
| 120 void *storage) const
{ |
| 121 return new (storage) Provider(); |
| 122 } |
| 123 |
| 124 size_t SkNormalBevelSourceImpl::providerSize(const SkShader::ContextRec&) const
{ |
| 125 return sizeof(Provider); |
| 126 } |
| 127 |
| 128 void SkNormalBevelSourceImpl::Provider::fillScanLine(int x, int y, SkPoint3 outp
ut[], |
| 129 int count) const { |
| 130 for (int i = 0; i < count; i++) { |
| 131 output[i] = {0.0f, 0.0f, 1.0f}; |
| 132 } |
| 133 } |
| 134 |
| 135 //////////////////////////////////////////////////////////////////////////////// |
| 136 |
| 137 sk_sp<SkFlattenable> SkNormalBevelSourceImpl::CreateProc(SkReadBuffer& buf) { |
| 138 |
| 139 auto type = static_cast<SkNormalSource::BevelType>(buf.readInt()); |
| 140 SkScalar width = buf.readScalar(); |
| 141 SkScalar height = buf.readScalar(); |
| 142 |
| 143 return sk_make_sp<SkNormalBevelSourceImpl>(type, width, height); |
| 144 } |
| 145 |
| 146 void SkNormalBevelSourceImpl::flatten(SkWriteBuffer& buf) const { |
| 147 this->INHERITED::flatten(buf); |
| 148 |
| 149 buf.writeInt(static_cast<int>(fType)); |
| 150 buf.writeScalar(fWidth); |
| 151 buf.writeScalar(fHeight); |
| 152 } |
| 153 |
| 154 //////////////////////////////////////////////////////////////////////////// |
| 155 |
| 156 sk_sp<SkNormalSource> SkNormalSource::MakeBevel(BevelType type, SkScalar width,
SkScalar height) { |
| 157 /* TODO make sure this checks are tolerant enough to account for loss of con
version when GPUs |
| 158 use 16-bit float types. We don't want to assume stuff is non-zero on the
GPU and be wrong.*/ |
| 159 SkASSERT(width > 0.0f && !SkScalarNearlyZero(width)); |
| 160 if (SkScalarNearlyZero(height)) { |
| 161 return SkNormalSource::MakeFlat(); |
| 162 } |
| 163 |
| 164 return sk_make_sp<SkNormalBevelSourceImpl>(type, width, height); |
| 165 } |
OLD | NEW |