#include "GrContext.h"
#include "GrDrawState.h"
#include "GrDrawTargetCaps.h"
-#include "GrEffect.h"
+#include "GrProcessor.h"
#include "GrPathUtils.h"
-#include "GrTBackendEffectFactory.h"
+#include "GrTBackendProcessorFactory.h"
#include "SkString.h"
#include "SkStrokeRec.h"
#include "SkTraceEvent.h"
-#include "gl/GrGLEffect.h"
+#include "gl/builders/GrGLProgramBuilder.h"
+#include "gl/GrGLProcessor.h"
#include "gl/GrGLSL.h"
-#include "gl/GrGLVertexEffect.h"
+#include "gl/GrGLGeometryProcessor.h"
-#include "effects/GrVertexEffect.h"
+#include "GrGeometryProcessor.h"
GrAAConvexPathRenderer::GrAAConvexPathRenderer() {
}
* Requires shader derivative instruction support.
*/
-class QuadEdgeEffect : public GrVertexEffect {
+class QuadEdgeEffect : public GrGeometryProcessor {
public:
- static GrEffectRef* Create() {
- GR_CREATE_STATIC_EFFECT(gQuadEdgeEffect, QuadEdgeEffect, ());
+ static GrGeometryProcessor* Create() {
+ GR_CREATE_STATIC_PROCESSOR(gQuadEdgeEffect, QuadEdgeEffect, ());
gQuadEdgeEffect->ref();
return gQuadEdgeEffect;
}
static const char* Name() { return "QuadEdge"; }
- virtual void getConstantColorComponents(GrColor* color,
- uint32_t* validFlags) const SK_OVERRIDE {
- *validFlags = 0;
- }
+ const GrShaderVar& inQuadEdge() const { return fInQuadEdge; }
- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendEffectFactory<QuadEdgeEffect>::getInstance();
+ virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
+ return GrTBackendGeometryProcessorFactory<QuadEdgeEffect>::getInstance();
}
- class GLEffect : public GrGLVertexEffect {
+ class GLProcessor : public GrGLGeometryProcessor {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
+ GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&)
: INHERITED (factory) {}
- virtual void emitCode(GrGLFullShaderBuilder* builder,
- const GrDrawEffect& drawEffect,
- EffectKey key,
- const char* outputColor,
- const char* inputColor,
- const TransformedCoordsArray&,
- const TextureSamplerArray& samplers) SK_OVERRIDE {
- const char *vsName, *fsName;
- const SkString* attrName =
- builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
- builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n");
-
- SkAssertResult(builder->enableFeature(
- GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
- builder->addVarying(kVec4f_GrSLType, "QuadEdge", &vsName, &fsName);
+ virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
+ GrGLVertToFrag v(kVec4f_GrSLType);
+ args.fPB->addVarying("QuadEdge", &v);
+
+ GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
+
+ SkAssertResult(fsBuilder->enableFeature(
+ GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
+ fsBuilder->codeAppendf("float edgeAlpha;");
// keep the derivative instructions outside the conditional
- builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
- builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
- builder->fsCodeAppendf("\t\tif (%s.z > 0.0 && %s.w > 0.0) {\n", fsName, fsName);
+ fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn());
+ fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn());
+ fsBuilder->codeAppendf("if (%s.z > 0.0 && %s.w > 0.0) {", v.fsIn(), v.fsIn());
// today we know z and w are in device space. We could use derivatives
- builder->fsCodeAppendf("\t\t\tedgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);\n", fsName,
- fsName);
- builder->fsCodeAppendf ("\t\t} else {\n");
- builder->fsCodeAppendf("\t\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
- "\t\t\t 2.0*%s.x*duvdy.x - duvdy.y);\n",
- fsName, fsName);
- builder->fsCodeAppendf("\t\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName,
- fsName);
- builder->fsCodeAppendf("\t\t\tedgeAlpha = "
- "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);\n\t\t}\n");
-
-
- builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
- (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
-
- builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str());
+ fsBuilder->codeAppendf("edgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);", v.fsIn(),
+ v.fsIn());
+ fsBuilder->codeAppendf ("} else {");
+ fsBuilder->codeAppendf("vec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,"
+ " 2.0*%s.x*duvdy.x - duvdy.y);",
+ v.fsIn(), v.fsIn());
+ fsBuilder->codeAppendf("edgeAlpha = (%s.x*%s.x - %s.y);", v.fsIn(), v.fsIn(),
+ v.fsIn());
+ fsBuilder->codeAppendf("edgeAlpha = "
+ "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);}");
+
+
+ fsBuilder->codeAppendf("%s = %s;", args.fOutput,
+ (GrGLSLExpr4(args.fInput) * GrGLSLExpr1("edgeAlpha")).c_str());
+
+ const GrShaderVar& inQuadEdge = args.fGP.cast<QuadEdgeEffect>().inQuadEdge();
+ GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
+ vsBuilder->codeAppendf("\t%s = %s;\n", v.vsOut(), inQuadEdge.c_str());
}
- static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
- return 0x0;
- }
+ static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*) {}
- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE {}
private:
- typedef GrGLVertexEffect INHERITED;
+ typedef GrGLGeometryProcessor INHERITED;
};
private:
- QuadEdgeEffect() {
- this->addVertexAttrib(kVec4f_GrSLType);
+ QuadEdgeEffect()
+ : fInQuadEdge(this->addVertexAttrib(GrShaderVar("inQuadEdge",
+ kVec4f_GrSLType,
+ GrShaderVar::kAttribute_TypeModifier))) {
}
- virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
+ virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
return true;
}
- GR_DECLARE_EFFECT_TEST;
+ virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
+ inout->mulByUnknownAlpha();
+ }
+
+ const GrShaderVar& fInQuadEdge;
+
+ GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
- typedef GrVertexEffect INHERITED;
+ typedef GrFragmentProcessor INHERITED;
};
-GR_DEFINE_EFFECT_TEST(QuadEdgeEffect);
+GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect);
-GrEffectRef* QuadEdgeEffect::TestCreate(SkRandom* random,
- GrContext*,
- const GrDrawTargetCaps& caps,
- GrTexture*[]) {
+GrGeometryProcessor* QuadEdgeEffect::TestCreate(SkRandom* random,
+ GrContext*,
+ const GrDrawTargetCaps& caps,
+ GrTexture*[]) {
// Doesn't work without derivative instructions.
return caps.shaderDerivativeSupport() ? QuadEdgeEffect::Create() : NULL;
}
// position + edge
extern const GrVertexAttrib gPathAttribs[] = {
{kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding},
- {kVec4f_GrVertexAttribType, sizeof(SkPoint), kEffect_GrVertexAttribBinding}
+ {kVec4f_GrVertexAttribType, sizeof(SkPoint), kGeometryProcessor_GrVertexAttribBinding}
};
};
// Our computed verts should all be within one pixel of the segment control points.
devBounds.outset(SK_Scalar1, SK_Scalar1);
- drawState->setVertexAttribs<gPathAttribs>(SK_ARRAY_COUNT(gPathAttribs));
+ drawState->setVertexAttribs<gPathAttribs>(SK_ARRAY_COUNT(gPathAttribs), sizeof(QuadVertex));
- static const int kEdgeAttrIndex = 1;
- GrEffectRef* quadEffect = QuadEdgeEffect::Create();
- drawState->addCoverageEffect(quadEffect, kEdgeAttrIndex)->unref();
+ GrGeometryProcessor* quadProcessor = QuadEdgeEffect::Create();
+ drawState->setGeometryProcessor(quadProcessor)->unref();
GrDrawTarget::AutoReleaseGeometry arg(target, vCount, iCount);
if (!arg.succeeded()) {
return false;
}
- SkASSERT(sizeof(QuadVertex) == drawState->getVertexSize());
verts = reinterpret_cast<QuadVertex*>(arg.vertices());
idxs = reinterpret_cast<uint16_t*>(arg.indices());