1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrMorphologyEffect.h"
#include "gl/GrGLProgramStage.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLTexture.h"
#include "GrProgramStageFactory.h"
///////////////////////////////////////////////////////////////////////////////
class GrGLMorphologyEffect : public GrGLProgramStage {
public:
GrGLMorphologyEffect (const GrProgramStageFactory& factory,
const GrCustomStage& stage);
virtual void setupVariables(GrGLShaderBuilder* builder) SK_OVERRIDE;
virtual void emitVS(GrGLShaderBuilder* state,
const char* vertexCoords) SK_OVERRIDE;
virtual void emitFS(GrGLShaderBuilder* state,
const char* outputColor,
const char* inputColor,
const char* samplerName) SK_OVERRIDE;
static inline StageKey GenKey(const GrCustomStage& s, const GrGLCaps& caps);
virtual void setData(const GrGLUniformManager&,
const GrCustomStage&,
const GrRenderTarget*,
int stageNum) SK_OVERRIDE;
private:
int width() const { return GrMorphologyEffect::WidthFromRadius(fRadius); }
int fRadius;
GrMorphologyEffect::MorphologyType fType;
GrGLUniformManager::UniformHandle fImageIncrementUni;
typedef GrGLProgramStage INHERITED;
};
GrGLMorphologyEffect ::GrGLMorphologyEffect(const GrProgramStageFactory& factory,
const GrCustomStage& stage)
: GrGLProgramStage(factory)
, fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle) {
const GrMorphologyEffect& m = static_cast<const GrMorphologyEffect&>(stage);
fRadius = m.radius();
fType = m.type();
}
void GrGLMorphologyEffect::setupVariables(GrGLShaderBuilder* builder) {
fImageIncrementUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType |
GrGLShaderBuilder::kVertex_ShaderType,
kVec2f_GrSLType, "ImageIncrement");
}
void GrGLMorphologyEffect::emitVS(GrGLShaderBuilder* builder,
const char* vertexCoords) {
SkString* code = &builder->fVSCode;
const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
code->appendf("\t\t%s -= vec2(%d, %d) * %s;\n", vertexCoords, fRadius, fRadius, imgInc);
}
void GrGLMorphologyEffect ::emitFS(GrGLShaderBuilder* builder,
const char* outputColor,
const char* inputColor,
const char* samplerName) {
SkString* code = &builder->fFSCode;
const char* func;
switch (fType) {
case GrContext::kErode_MorphologyType:
code->appendf("\t\tvec4 value = vec4(1, 1, 1, 1);\n");
func = "min";
break;
case GrContext::kDilate_MorphologyType:
code->appendf("\t\tvec4 value = vec4(0, 0, 0, 0);\n");
func = "max";
break;
default:
GrCrash("Unexpected type");
func = ""; // suppress warning
break;
}
const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
code->appendf("\t\tvec2 coord = %s;\n", builder->fSampleCoords.c_str());
code->appendf("\t\tfor (int i = 0; i < %d; i++) {\n", this->width());
code->appendf("\t\t\tvalue = %s(value, ", func);
builder->emitTextureLookup(samplerName, "coord");
code->appendf(");\n");
code->appendf("\t\t\tcoord += %s;\n", imgInc);
code->appendf("\t\t}\n");
code->appendf("\t\t%s = value%s;\n", outputColor, builder->fModulate.c_str());
}
GrGLProgramStage::StageKey GrGLMorphologyEffect::GenKey(const GrCustomStage& s,
const GrGLCaps& caps) {
const GrMorphologyEffect& m = static_cast<const GrMorphologyEffect&>(s);
StageKey key = static_cast<StageKey>(m.radius());
key |= (m.type() << 8);
return key;
}
void GrGLMorphologyEffect ::setData(const GrGLUniformManager& uman,
const GrCustomStage& data,
const GrRenderTarget*,
int stageNum) {
const Gr1DKernelEffect& kern =
static_cast<const Gr1DKernelEffect&>(data);
GrGLTexture& texture =
*static_cast<GrGLTexture*>(data.texture(0));
// the code we generated was for a specific kernel radius
GrAssert(kern.radius() == fRadius);
float imageIncrement[2] = { 0 };
switch (kern.direction()) {
case Gr1DKernelEffect::kX_Direction:
imageIncrement[0] = 1.0f / texture.width();
break;
case Gr1DKernelEffect::kY_Direction:
imageIncrement[1] = 1.0f / texture.height();
break;
default:
GrCrash("Unknown filter direction.");
}
uman.set2fv(fImageIncrementUni, 0, 1, imageIncrement);
}
///////////////////////////////////////////////////////////////////////////////
GrMorphologyEffect::GrMorphologyEffect(GrTexture* texture,
Direction direction,
int radius,
MorphologyType type)
: Gr1DKernelEffect(texture, direction, radius)
, fType(type) {
}
GrMorphologyEffect::~GrMorphologyEffect() {
}
const GrProgramStageFactory& GrMorphologyEffect::getFactory() const {
return GrTProgramStageFactory<GrMorphologyEffect>::getInstance();
}
bool GrMorphologyEffect::isEqual(const GrCustomStage& sBase) const {
const GrMorphologyEffect& s =
static_cast<const GrMorphologyEffect&>(sBase);
return (INHERITED::isEqual(sBase) &&
this->radius() == s.radius() &&
this->direction() == s.direction() &&
this->type() == s.type());
}
|
