#include "GrInvariantOutput.h"
#include "SkGr.h"
#include "effects/GrConstColorProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#if SK_SUPPORT_GPU
-class GrGLPerlinNoise2 : public GrGLFragmentProcessor {
+class GrGLPerlinNoise2 : public GrGLSLFragmentProcessor {
public:
GrGLPerlinNoise2(const GrProcessor&);
virtual ~GrGLPerlinNoise2() {}
GrGLSLProgramDataManager::UniformHandle fBaseFrequencyUni;
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
/////////////////////////////////////////////////////////////////////
const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GrGLPerlinNoise2(*this);
}
/////////////////////////////////////////////////////////////////////
-class GrGLImprovedPerlinNoise : public GrGLFragmentProcessor {
+class GrGLImprovedPerlinNoise : public GrGLSLFragmentProcessor {
public:
GrGLImprovedPerlinNoise(const GrProcessor&);
virtual ~GrGLImprovedPerlinNoise() {}
GrGLSLProgramDataManager::UniformHandle fBaseFrequencyUni;
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
/////////////////////////////////////////////////////////////////////
const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GrGLImprovedPerlinNoise(*this);
}
#include "GrFragmentProcessor.h"
#include "GrCoordTransform.h"
#include "effects/GrXfermodeFragmentProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
this->initClassID<DCFP>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override {
- class DCGLFP : public GrGLFragmentProcessor {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+ class DCGLFP : public GrGLSLFragmentProcessor {
void emitCode(EmitArgs& args) override {
GrGLSLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder();
fpb->codeAppendf("vec2 c = %s;", fpb->ensureFSCoords2D(args.fCoords, 0).c_str());
'<(skia_src_path)/gpu/gl/GrGLAssembleInterface.cpp',
'<(skia_src_path)/gpu/gl/GrGLAssembleInterface.h',
- '<(skia_src_path)/gpu/gl/GrGLSLBlend.cpp',
- '<(skia_src_path)/gpu/gl/GrGLSLBlend.h',
'<(skia_src_path)/gpu/gl/GrGLBufferImpl.cpp',
'<(skia_src_path)/gpu/gl/GrGLBufferImpl.h',
'<(skia_src_path)/gpu/gl/GrGLCaps.cpp',
'<(skia_src_path)/gpu/gl/GrGLGpu.h',
'<(skia_src_path)/gpu/gl/GrGLGpuProgramCache.cpp',
'<(skia_src_path)/gpu/gl/GrGLExtensions.cpp',
- '<(skia_src_path)/gpu/gl/GrGLFragmentProcessor.cpp',
- '<(skia_src_path)/gpu/gl/GrGLFragmentProcessor.h',
'<(skia_src_path)/gpu/gl/GrGLIndexBuffer.cpp',
'<(skia_src_path)/gpu/gl/GrGLIndexBuffer.h',
'<(skia_src_path)/gpu/gl/GrGLInterface.cpp',
'<(skia_src_path)/gpu/glsl/GrGLSL.cpp',
'<(skia_src_path)/gpu/glsl/GrGLSL.h',
'<(skia_src_path)/gpu/glsl/GrGLSL_impl.h',
+ '<(skia_src_path)/gpu/glsl/GrGLSLBlend.cpp',
+ '<(skia_src_path)/gpu/glsl/GrGLSLBlend.h',
'<(skia_src_path)/gpu/glsl/GrGLSLCaps.cpp',
'<(skia_src_path)/gpu/glsl/GrGLSLCaps.h',
+ '<(skia_src_path)/gpu/glsl/GrGLSLFragmentProcessor.cpp',
+ '<(skia_src_path)/gpu/glsl/GrGLSLFragmentProcessor.h',
'<(skia_src_path)/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp',
'<(skia_src_path)/gpu/glsl/GrGLSLFragmentShaderBuilder.h',
'<(skia_src_path)/gpu/glsl/GrGLSLGeometryShaderBuilder.cpp',
'<(skia_src_path)/gpu/glsl/GrGLSLShaderBuilder.h',
'<(skia_src_path)/gpu/glsl/GrGLSLShaderVar.h',
'<(skia_src_path)/gpu/glsl/GrGLSLTextureSampler.h',
+ '<(skia_src_path)/gpu/glsl/GrGLSLUtil.cpp',
+ '<(skia_src_path)/gpu/glsl/GrGLSLUtil.h',
'<(skia_src_path)/gpu/glsl/GrGLSLVertexShaderBuilder.cpp',
'<(skia_src_path)/gpu/glsl/GrGLSLVertexShaderBuilder.h',
class GrCoordTransform;
class GrGLSLCaps;
-class GrGLFragmentProcessor;
+class GrGLSLFragmentProcessor;
class GrInvariantOutput;
class GrProcessorKeyBuilder;
~GrFragmentProcessor() override;
- GrGLFragmentProcessor* createGLInstance() const;
+ GrGLSLFragmentProcessor* createGLInstance() const;
void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
this->onGetGLProcessorKey(caps, b);
/** Returns a new instance of the appropriate *GL* implementation class
for the given GrFragmentProcessor; caller is responsible for deleting
the object. */
- virtual GrGLFragmentProcessor* onCreateGLInstance() const = 0;
+ virtual GrGLSLFragmentProcessor* onCreateGLInstance() const = 0;
/** Implemented using GLFragmentProcessor::GenKey as described in this class's comment. */
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
this->initClassID<GrConstColorProcessor>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
#include "GrCoordTransform.h"
#include "GrFragmentProcessor.h"
#include "GrTextureAccess.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
this->initClassID<LightingFP>();
}
- class LightingGLFP : public GrGLFragmentProcessor {
+ class LightingGLFP : public GrGLSLFragmentProcessor {
public:
LightingGLFP() {
fLightDir.fX = 10000.0f;
const SkVector& invNormRotation() const { return fInvNormRotation; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override { return new LightingGLFP; }
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override { return new LightingGLFP; }
bool onIsEqual(const GrFragmentProcessor& proc) const override {
const LightingFP& lightingFP = proc.cast<LightingFP>();
#include "GrContext.h"
#include "GrTextureProvider.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
-class GrGLCircleBlurFragmentProcessor : public GrGLFragmentProcessor {
+class GrGLCircleBlurFragmentProcessor : public GrGLSLFragmentProcessor {
public:
GrGLCircleBlurFragmentProcessor(const GrProcessor&) {}
void emitCode(EmitArgs&) override;
private:
GrGLSLProgramDataManager::UniformHandle fDataUniform;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
void GrGLCircleBlurFragmentProcessor::emitCode(EmitArgs& args) {
this->setWillReadFragmentPosition();
}
-GrGLFragmentProcessor* GrCircleBlurFragmentProcessor::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrCircleBlurFragmentProcessor::onCreateGLInstance() const {
return new GrGLCircleBlurFragmentProcessor(*this);
}
GrCircleBlurFragmentProcessor(const SkRect& circle, float sigma,
float offset, GrTexture* blurProfile);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
#include "SkGr.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
this->addTextureAccess(&fMaskTextureAccess);
}
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
typedef GrFragmentProcessor INHERITED;
};
-class GrGLAlphaThresholdEffect : public GrGLFragmentProcessor {
+class GrGLAlphaThresholdEffect : public GrGLSLFragmentProcessor {
public:
GrGLAlphaThresholdEffect(const GrFragmentProcessor&) {}
GrGLSLProgramDataManager::UniformHandle fInnerThresholdVar;
GrGLSLProgramDataManager::UniformHandle fOuterThresholdVar;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
void GrGLAlphaThresholdEffect::emitCode(EmitArgs& args) {
GrGLAlphaThresholdEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* AlphaThresholdEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* AlphaThresholdEffect::onCreateGLInstance() const {
return new GrGLAlphaThresholdEffect(*this);
}
#include "GrInvariantOutput.h"
#include "GrProcessor.h"
#include "GrTexture.h"
-#include "gl/GrGLCaps.h"
-#include "gl/GrGLFragmentProcessor.h"
#include "gl/GrGLXferProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
}
}
-class GLArithmeticFP : public GrGLFragmentProcessor {
+class GLArithmeticFP : public GrGLSLFragmentProcessor {
public:
GLArithmeticFP(const GrArithmeticFP& arithmeticFP)
: fEnforcePMColor(arithmeticFP.enforcePMColor()) {}
GrGLSLProgramDataManager::UniformHandle fKUni;
bool fEnforcePMColor;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
GLArithmeticFP::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrArithmeticFP::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrArithmeticFP::onCreateGLInstance() const {
return new GLArithmeticFP(*this);
}
bool enforcePMColor() const { return fEnforcePMColor; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
#include "SkGrPixelRef.h"
#include "SkDraw.h"
#include "effects/GrSimpleTextureEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
GrSLPrecision fPrecision);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
typedef GrFragmentProcessor INHERITED;
};
-class GrGLRectBlurEffect : public GrGLFragmentProcessor {
+class GrGLRectBlurEffect : public GrGLSLFragmentProcessor {
public:
GrGLRectBlurEffect(const GrProcessor&, GrSLPrecision precision)
: fPrecision(precision) {
UniformHandle fProfileSizeUniform;
GrSLPrecision fPrecision;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
void OutputRectBlurProfileLookup(GrGLSLFragmentBuilder* fsBuilder,
GrGLRectBlurEffect::GenKey(fPrecision, b);
}
-GrGLFragmentProcessor* GrRectBlurEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrRectBlurEffect::onCreateGLInstance() const {
return new GrGLRectBlurEffect(*this, fPrecision);
}
float getSigma() const { return fSigma; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture);
//////////////////////////////////////////////////////////////////////////////
-class GrGLRRectBlurEffect : public GrGLFragmentProcessor {
+class GrGLRRectBlurEffect : public GrGLSLFragmentProcessor {
public:
GrGLRRectBlurEffect(const GrProcessor&) {}
GrGLSLProgramDataManager::UniformHandle fProxyRectUniform;
GrGLSLProgramDataManager::UniformHandle fCornerRadiusUniform;
GrGLSLProgramDataManager::UniformHandle fBlurRadiusUniform;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
void GrGLRRectBlurEffect::emitCode(EmitArgs& args) {
GrGLRRectBlurEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrRRectBlurEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrRRectBlurEffect::onCreateGLInstance() const {
return new GrGLRRectBlurEffect(*this);
}
#include "GrInvariantOutput.h"
#include "GrTexturePriv.h"
#include "SkGr.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
void onComputeInvariantOutput(GrInvariantOutput*) const override;
- class GLProcessor : public GrGLFragmentProcessor {
+ class GLProcessor : public GrGLSLFragmentProcessor {
public:
GLProcessor(const GrProcessor&);
virtual ~GLProcessor();
GrGLSLProgramDataManager::UniformHandle fColorCubeSizeUni;
GrGLSLProgramDataManager::UniformHandle fColorCubeInvSizeUni;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
private:
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override;
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
GLProcessor::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrColorCubeEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrColorCubeEffect::onCreateGLInstance() const {
return new GLProcessor(*this);
}
#if SK_SUPPORT_GPU
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
- class GLProcessor : public GrGLFragmentProcessor {
+ class GLProcessor : public GrGLSLFragmentProcessor {
public:
// this class always generates the same code.
static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {}
GrGLSLProgramDataManager::UniformHandle fMatrixHandle;
GrGLSLProgramDataManager::UniformHandle fVectorHandle;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
private:
this->initClassID<ColorMatrixEffect>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override { return new GLProcessor(*this); }
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override { return new GLProcessor(*this); }
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
#include "GrCoordTransform.h"
#include "GrInvariantOutput.h"
#include "effects/GrTextureDomain.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
///////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU
-class GrGLDisplacementMapEffect : public GrGLFragmentProcessor {
+class GrGLDisplacementMapEffect : public GrGLSLFragmentProcessor {
public:
GrGLDisplacementMapEffect(const GrProcessor&);
virtual ~GrGLDisplacementMapEffect();
GrGLSLProgramDataManager::UniformHandle fScaleUni;
GrTextureDomain::GLDomain fGLDomain;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
const GrTextureDomain& domain() const { return fDomain; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GrGLDisplacementMapEffect(*this);
}
#include "GrInvariantOutput.h"
#include "GrPaint.h"
#include "effects/GrSingleTextureEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
SkScalar kd() const { return fKD; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
const char* name() const override { return "SpecularLighting"; }
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
SkScalar ks() const { return fKS; }
SkScalar shininess() const { return fShininess; }
}
-class GrGLLightingEffect : public GrGLFragmentProcessor {
+class GrGLLightingEffect : public GrGLSLFragmentProcessor {
public:
GrGLLightingEffect(const GrProcessor&);
virtual ~GrGLLightingEffect();
virtual void emitLightFunc(GrGLSLFPBuilder*, SkString* funcName) = 0;
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
UniformHandle fImageIncrementUni;
UniformHandle fSurfaceScaleUni;
GrGLDiffuseLightingEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrDiffuseLightingEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrDiffuseLightingEffect::onCreateGLInstance() const {
return new GrGLDiffuseLightingEffect(*this);
}
GrGLSpecularLightingEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrSpecularLightingEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrSpecularLightingEffect::onCreateGLInstance() const {
return new GrGLSpecularLightingEffect(*this);
}
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrInvariantOutput.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#endif
const char* name() const override { return "Luminance-to-Alpha"; }
- class GLProcessor : public GrGLFragmentProcessor {
+ class GLProcessor : public GrGLSLFragmentProcessor {
public:
GLProcessor(const GrProcessor&) {}
}
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
private:
this->initClassID<LumaColorFilterEffect>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override { return new GLProcessor(*this); }
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override { return new GLProcessor(*this); }
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
#if SK_SUPPORT_GPU
#include "GrInvariantOutput.h"
#include "effects/GrSingleTextureEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLTexture.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
this->initClassID<GrMagnifierEffect>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
// For brevity
typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
-class GrGLMagnifierEffect : public GrGLFragmentProcessor {
+class GrGLMagnifierEffect : public GrGLSLFragmentProcessor {
public:
GrGLMagnifierEffect(const GrProcessor&);
UniformHandle fInvInsetVar;
UniformHandle fBoundsVar;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLMagnifierEffect::GrGLMagnifierEffect(const GrProcessor&) {
GrGLMagnifierEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrMagnifierEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrMagnifierEffect::onCreateGLInstance() const {
return new GrGLMagnifierEffect(*this);
}
#include "GrInvariantOutput.h"
#include "GrTexture.h"
#include "effects/Gr1DKernelEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
float fRange[2];
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
///////////////////////////////////////////////////////////////////////////////
-class GrGLMorphologyEffect : public GrGLFragmentProcessor {
+class GrGLMorphologyEffect : public GrGLSLFragmentProcessor {
public:
GrGLMorphologyEffect(const GrProcessor&);
GrGLSLProgramDataManager::UniformHandle fPixelSizeUni;
GrGLSLProgramDataManager::UniformHandle fRangeUni;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLMorphologyEffect::GrGLMorphologyEffect(const GrProcessor& proc) {
GrGLMorphologyEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrMorphologyEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrMorphologyEffect::onCreateGLInstance() const {
return new GrGLMorphologyEffect(*this);
}
bool GrMorphologyEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
#include "GrInvariantOutput.h"
#include "SkGr.h"
#include "effects/GrConstColorProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#if SK_SUPPORT_GPU
-class GrGLPerlinNoise : public GrGLFragmentProcessor {
+class GrGLPerlinNoise : public GrGLSLFragmentProcessor {
public:
GrGLPerlinNoise(const GrProcessor&);
virtual ~GrGLPerlinNoise() {}
GrGLSLProgramDataManager::UniformHandle fBaseFrequencyUni;
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
/////////////////////////////////////////////////////////////////////
const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GrGLPerlinNoise(*this);
}
#include "GrInvariantOutput.h"
#include "SkGr.h"
#include "effects/GrTextureStripAtlas.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
int atlasRow() const { return fRow; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
typedef GrFragmentProcessor INHERITED;
};
-class GLColorTableEffect : public GrGLFragmentProcessor {
+class GLColorTableEffect : public GrGLSLFragmentProcessor {
public:
GLColorTableEffect(const GrProcessor&);
private:
UniformHandle fRGBAYValuesUni;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GLColorTableEffect::GLColorTableEffect(const GrProcessor&) {
GLColorTableEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* ColorTableEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* ColorTableEffect::onCreateGLInstance() const {
return new GLColorTableEffect(*this);
}
#include "GrCoordTransform.h"
#include "GrFragmentProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLProgramDataManager.h"
class GrInvariantOutput;
///////////////////////////////////////////////////////////////////////////////
// Base class for GL gradient effects
-class GrGLGradientEffect : public GrGLFragmentProcessor {
+class GrGLGradientEffect : public GrGLSLFragmentProcessor {
public:
GrGLGradientEffect();
virtual ~GrGLGradientEffect();
GrGLSLProgramDataManager::UniformHandle fColorMidUni;
GrGLSLProgramDataManager::UniformHandle fColorEndUni;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
#endif
this->initClassID<GrLinearGradient>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GrGLLinearGradient(*this);
}
this->initClassID<GrRadialGradient>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GrGLRadialGradient(*this);
}
this->initClassID<GrSweepGradient>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GrGLSweepGradient(*this);
}
SkScalar radius() const { return fRadius0; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
GLEdge2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* Edge2PtConicalEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* Edge2PtConicalEffect::onCreateGLInstance() const {
return new GLEdge2PtConicalEffect(*this);
}
SkScalar focal() const { return fFocalX; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
GLFocalOutside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* FocalOutside2PtConicalEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* FocalOutside2PtConicalEffect::onCreateGLInstance() const {
return new GLFocalOutside2PtConicalEffect(*this);
}
typedef GLFocalInside2PtConicalEffect GLProcessor;
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
GLFocalInside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* FocalInside2PtConicalEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* FocalInside2PtConicalEffect::onCreateGLInstance() const {
return new GLFocalInside2PtConicalEffect(*this);
}
SkScalar C() const { return fInfo.fC; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override;
GLCircleInside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircleInside2PtConicalEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* CircleInside2PtConicalEffect::onCreateGLInstance() const {
return new GLCircleInside2PtConicalEffect(*this);
}
bool isFlipped() const { return fIsFlipped; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
GLCircleOutside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircleOutside2PtConicalEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* CircleOutside2PtConicalEffect::onCreateGLInstance() const {
return new GLCircleOutside2PtConicalEffect(*this);
}
#include "GrInvariantOutput.h"
#include "gl/GrGLGeometryProcessor.h"
-#include "gl/GrGLUtil.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLVertexShaderBuilder.h"
+#include "glsl/GrGLSLUtil.h"
/*
* The default Geometry Processor simply takes position and multiplies it by the uniform view
if (!dgp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dgp.viewMatrix())) {
fViewMatrix = dgp.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
#include "GrFragmentProcessor.h"
#include "GrCoordTransform.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
return true;
}
-GrGLFragmentProcessor* GrFragmentProcessor::createGLInstance() const {
- GrGLFragmentProcessor* glFragProc = this->onCreateGLInstance();
+GrGLSLFragmentProcessor* GrFragmentProcessor::createGLInstance() const {
+ GrGLSLFragmentProcessor* glFragProc = this->onCreateGLInstance();
glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
for (int i = 0; i < fChildProcessors.count(); ++i) {
glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLInstance();
const char* name() const override { return "Premultiply"; }
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override {
- class GLFP : public GrGLFragmentProcessor {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+ class GLFP : public GrGLSLFragmentProcessor {
public:
GLFP() {}
const char* name() const override { return "Replace Color"; }
- GrGLFragmentProcessor* onCreateGLInstance() const override {
- class GLFP : public GrGLFragmentProcessor {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+ class GLFP : public GrGLSLFragmentProcessor {
public:
GLFP() : fHaveSetColor(false) {}
void emitCode(EmitArgs& args) override {
const char* name() const override { return "Series"; }
- GrGLFragmentProcessor* onCreateGLInstance() const override {
- class GLFP : public GrGLFragmentProcessor {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+ class GLFP : public GrGLSLFragmentProcessor {
public:
GLFP() {}
void emitCode(EmitArgs& args) override {
#include "SkTLazy.h"
#include "batches/GrVertexBatch.h"
#include "effects/GrRRectEffect.h"
-#include "gl/GrGLUtil.h"
#include "gl/GrGLGeometryProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "glsl/GrGLSLVertexShaderBuilder.h"
+#include "glsl/GrGLSLUtil.h"
// TODO(joshualitt) - Break this file up during GrBatch post implementation cleanup
if (!dee.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dee.viewMatrix())) {
fViewMatrix = dee.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
#include "GrBezierEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
#include "gl/GrGLGeometryProcessor.h"
-#include "gl/GrGLUtil.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLUtil.h"
class GrGLConicEffect : public GrGLGeometryProcessor {
public:
if (!ce.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(ce.viewMatrix())) {
fViewMatrix = ce.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
if (!qe.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(qe.viewMatrix())) {
fViewMatrix = qe.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
if (!ce.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(ce.viewMatrix())) {
fViewMatrix = ce.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
};
-class GrGLBicubicEffect : public GrGLFragmentProcessor {
+class GrGLBicubicEffect : public GrGLSLFragmentProcessor {
public:
GrGLBicubicEffect(const GrProcessor&);
UniformHandle fImageIncrementUni;
GrTextureDomain::GLDomain fDomain;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLBicubicEffect::GrGLBicubicEffect(const GrProcessor&) {
GrGLBicubicEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrBicubicEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrBicubicEffect::onCreateGLInstance() const {
return new GrGLBicubicEffect(*this);
}
#include "GrSingleTextureEffect.h"
#include "GrTextureDomain.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
class GrGLBicubicEffect;
class GrInvariantOutput;
GrBicubicEffect(GrTexture*, const SkScalar coefficients[16], const SkMatrix &matrix,
const SkRect& domain);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
#include "GrBitmapTextGeoProc.h"
#include "GrInvariantOutput.h"
#include "GrTexture.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLTexture.h"
#include "gl/GrGLGeometryProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "GrInvariantOutput.h"
#include "GrSimpleTextureEffect.h"
#include "SkMatrix.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
-class GrGLConfigConversionEffect : public GrGLFragmentProcessor {
+class GrGLConfigConversionEffect : public GrGLSLFragmentProcessor {
public:
GrGLConfigConversionEffect(const GrProcessor& processor) {
const GrConfigConversionEffect& configConversionEffect =
bool fSwapRedAndBlue;
GrConfigConversionEffect::PMConversion fPMConversion;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLConfigConversionEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrConfigConversionEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrConfigConversionEffect::onCreateGLInstance() const {
return new GrGLConfigConversionEffect(*this);
}
PMConversion pmConversion,
const SkMatrix& matrix);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
*/
#include "effects/GrConstColorProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
-class GLConstColorProcessor : public GrGLFragmentProcessor {
+class GLConstColorProcessor : public GrGLSLFragmentProcessor {
public:
GLConstColorProcessor() : fPrevColor(GrColor_ILLEGAL) {}
GrGLSLProgramDataManager::UniformHandle fColorUniform;
GrColor fPrevColor;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
b->add32(fMode);
}
-GrGLFragmentProcessor* GrConstColorProcessor::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrConstColorProcessor::onCreateGLInstance() const {
return new GLConstColorProcessor;
}
#include "GrConvexPolyEffect.h"
#include "GrInvariantOutput.h"
#include "SkPathPriv.h"
-#include "gl/GrGLContext.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
this->setWillReadFragmentPosition();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
bool onIsEqual(const GrFragmentProcessor& other) const override {
const AARectEffect& aare = other.cast<AARectEffect>();
//////////////////////////////////////////////////////////////////////////////
-class GLAARectEffect : public GrGLFragmentProcessor {
+class GLAARectEffect : public GrGLSLFragmentProcessor {
public:
GLAARectEffect(const GrProcessor&);
private:
GrGLSLProgramDataManager::UniformHandle fRectUniform;
SkRect fPrevRect;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GLAARectEffect::GLAARectEffect(const GrProcessor& effect) {
GLAARectEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* AARectEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* AARectEffect::onCreateGLInstance() const {
return new GLAARectEffect(*this);
}
//////////////////////////////////////////////////////////////////////////////
-class GrGLConvexPolyEffect : public GrGLFragmentProcessor {
+class GrGLConvexPolyEffect : public GrGLSLFragmentProcessor {
public:
GrGLConvexPolyEffect(const GrProcessor&);
private:
GrGLSLProgramDataManager::UniformHandle fEdgeUniform;
SkScalar fPrevEdges[3 * GrConvexPolyEffect::kMaxEdges];
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLConvexPolyEffect::GrGLConvexPolyEffect(const GrProcessor&) {
GrGLConvexPolyEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrConvexPolyEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrConvexPolyEffect::onCreateGLInstance() const {
return new GrGLConvexPolyEffect(*this);
}
private:
GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[]);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
*/
#include "GrConvolutionEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLTexture.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
// For brevity
typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
-class GrGLConvolutionEffect : public GrGLFragmentProcessor {
+class GrGLConvolutionEffect : public GrGLSLFragmentProcessor {
public:
GrGLConvolutionEffect(const GrProcessor&);
UniformHandle fImageIncrementUni;
UniformHandle fBoundsUni;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLConvolutionEffect::GrGLConvolutionEffect(const GrProcessor& processor) {
GrGLConvolutionEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrConvolutionEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrConvolutionEffect::onCreateGLInstance() const {
return new GrGLConvolutionEffect(*this);
}
bool useBounds,
float bounds[2]);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
#include "GrTexture.h"
#include "GrTextureAccess.h"
#include "SkXfermode.h"
-#include "gl/GrGLCaps.h"
-#include "gl/GrGLGpu.h"
-#include "gl/GrGLSLBlend.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLProgramDataManager.h"
+#include "gl/GrGLXferProcessor.h"
+#include "glsl/GrGLSLBlend.h"
#include "glsl/GrGLSLCaps.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "SkGr.h"
#include "batches/GrVertexBatch.h"
#include "gl/GrGLGeometryProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "SkDistanceFieldGen.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLTexture.h"
#include "gl/GrGLGeometryProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "glsl/GrGLSLVertexShaderBuilder.h"
+#include "glsl/GrGLSLUtil.h"
// Assuming a radius of a little less than the diagonal of the fragment
#define SK_DistanceFieldAAFactor "0.65"
if (!dfa8gp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dfa8gp.viewMatrix())) {
fViewMatrix = dfa8gp.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
if (!dfpgp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dfpgp.viewMatrix())) {
fViewMatrix = dfpgp.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
if (!dflcd.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dflcd.viewMatrix())) {
fViewMatrix = dflcd.viewMatrix();
float viewMatrix[3 * 3];
- GrGLGetMatrix<3>(viewMatrix, fViewMatrix);
+ GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "SkRect.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
this->setWillReadFragmentPosition();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
//////////////////////////////////////////////////////////////////////////////
-class GLDitherEffect : public GrGLFragmentProcessor {
+class GLDitherEffect : public GrGLSLFragmentProcessor {
public:
GLDitherEffect(const GrProcessor&);
virtual void emitCode(EmitArgs& args) override;
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GLDitherEffect::GLDitherEffect(const GrProcessor&) {
GLDitherEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* DitherEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* DitherEffect::onCreateGLInstance() const {
return new GLDitherEffect(*this);
}
* found in the LICENSE file.
*/
#include "GrMatrixConvolutionEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLTexture.h"
-#include "gl/builders/GrGLProgramBuilder.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
+#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
-class GrGLMatrixConvolutionEffect : public GrGLFragmentProcessor {
+class GrGLMatrixConvolutionEffect : public GrGLSLFragmentProcessor {
public:
GrGLMatrixConvolutionEffect(const GrProcessor&);
virtual void emitCode(EmitArgs&) override;
UniformHandle fBiasUni;
GrTextureDomain::GLDomain fDomain;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLMatrixConvolutionEffect::GrGLMatrixConvolutionEffect(const GrProcessor& processor) {
void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) {
const GrTextureDomain& domain = args.fFp.cast<GrMatrixConvolutionEffect>().domain();
- fImageIncrementUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+ fImageIncrementUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, kDefault_GrSLPrecision,
"ImageIncrement");
- fKernelUni = args.fBuilder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
+ fKernelUni = args.fBuilder->addUniformArray(GrGLSLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, kDefault_GrSLPrecision,
"Kernel",
fKernelSize.width() * fKernelSize.height());
- fKernelOffsetUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+ fKernelOffsetUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, kDefault_GrSLPrecision, "KernelOffset");
- fGainUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+ fGainUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, kDefault_GrSLPrecision, "Gain");
- fBiasUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+ fBiasUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, kDefault_GrSLPrecision, "Bias");
const char* kernelOffset = args.fBuilder->getUniformCStr(fKernelOffsetUni);
GrGLMatrixConvolutionEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrMatrixConvolutionEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrMatrixConvolutionEffect::onCreateGLInstance() const {
return new GrGLMatrixConvolutionEffect(*this);
}
GrTextureDomain::Mode tileMode,
bool convolveAlpha);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "SkRect.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
private:
CircleEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
//////////////////////////////////////////////////////////////////////////////
-class GLCircleEffect : public GrGLFragmentProcessor {
+class GLCircleEffect : public GrGLSLFragmentProcessor {
public:
GLCircleEffect(const GrProcessor&);
SkPoint fPrevCenter;
SkScalar fPrevRadius;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GLCircleEffect::GLCircleEffect(const GrProcessor&) {
GLCircleEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircleEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* CircleEffect::onCreateGLInstance() const {
return new GLCircleEffect(*this);
}
private:
EllipseEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx, SkScalar ry);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
//////////////////////////////////////////////////////////////////////////////
-class GLEllipseEffect : public GrGLFragmentProcessor {
+class GLEllipseEffect : public GrGLSLFragmentProcessor {
public:
GLEllipseEffect(const GrProcessor&);
SkPoint fPrevCenter;
SkVector fPrevRadii;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GLEllipseEffect::GLEllipseEffect(const GrProcessor& effect) {
GLEllipseEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* EllipseEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* EllipseEffect::onCreateGLInstance() const {
return new GLEllipseEffect(*this);
}
#include "GrProcOptInfo.h"
#include "GrTypes.h"
#include "GrXferProcessor.h"
-#include "gl/GrGLSLBlend.h"
#include "gl/GrGLXferProcessor.h"
+#include "glsl/GrGLSLBlend.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "GrInvariantOutput.h"
#include "GrOvalEffect.h"
#include "SkRRect.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
private:
CircularRRectEffect(GrPrimitiveEdgeType, uint32_t circularCornerFlags, const SkRRect&);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
//////////////////////////////////////////////////////////////////////////////
-class GLCircularRRectEffect : public GrGLFragmentProcessor {
+class GLCircularRRectEffect : public GrGLSLFragmentProcessor {
public:
GLCircularRRectEffect(const GrProcessor&);
GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
GrGLSLProgramDataManager::UniformHandle fRadiusPlusHalfUniform;
SkRRect fPrevRRect;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GLCircularRRectEffect::GLCircularRRectEffect(const GrProcessor& ) {
GLCircularRRectEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircularRRectEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* CircularRRectEffect::onCreateGLInstance() const {
return new GLCircularRRectEffect(*this);
}
private:
EllipticalRRectEffect(GrPrimitiveEdgeType, const SkRRect&);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
//////////////////////////////////////////////////////////////////////////////
-class GLEllipticalRRectEffect : public GrGLFragmentProcessor {
+class GLEllipticalRRectEffect : public GrGLSLFragmentProcessor {
public:
GLEllipticalRRectEffect(const GrProcessor&);
GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
GrGLSLProgramDataManager::UniformHandle fInvRadiiSqdUniform;
SkRRect fPrevRRect;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrProcessor& effect) {
GLEllipticalRRectEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* EllipticalRRectEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* EllipticalRRectEffect::onCreateGLInstance() const {
return new GLEllipticalRRectEffect(*this);
}
#include "GrSimpleTextureEffect.h"
#include "GrInvariantOutput.h"
#include "GrTexture.h"
-#include "gl/GrGLCaps.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLTexture.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
-class GrGLSimpleTextureEffect : public GrGLFragmentProcessor {
+class GrGLSimpleTextureEffect : public GrGLSLFragmentProcessor {
public:
GrGLSimpleTextureEffect(const GrProcessor&) {}
}
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
GrGLSimpleTextureEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrSimpleTextureEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrSimpleTextureEffect::onCreateGLInstance() const {
return new GrGLSimpleTextureEffect(*this);
}
this->initClassID<GrSimpleTextureEffect>();
}
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
#include "GrInvariantOutput.h"
#include "GrSimpleTextureEffect.h"
#include "SkFloatingPoint.h"
-#include "gl/GrGLContext.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "glsl/GrGLSLTextureSampler.h"
//////////////////////////////////////////////////////////////////////////////
-class GrGLTextureDomainEffect : public GrGLFragmentProcessor {
+class GrGLTextureDomainEffect : public GrGLSLFragmentProcessor {
public:
GrGLTextureDomainEffect(const GrProcessor&);
private:
GrTextureDomain::GLDomain fGLDomain;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
GrGLTextureDomainEffect::GrGLTextureDomainEffect(const GrProcessor&) {
GrGLTextureDomainEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrTextureDomainEffect::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* GrTextureDomainEffect::onCreateGLInstance() const {
return new GrGLTextureDomainEffect(*this);
}
#define GrTextureDomainEffect_DEFINED
#include "GrSingleTextureEffect.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLProgramDataManager.h"
class GrGLProgramBuilder;
}
/**
- * A GrGLFragmentProcessor subclass that corresponds to a GrProcessor subclass that uses
+ * A GrGLSLFragmentProcessor subclass that corresponds to a GrProcessor subclass that uses
* GrTextureDomain should include this helper. It generates the texture domain GLSL, produces
* the part of the effect key that reflects the texture domain code, and performs the uniform
* uploads necessary for texture domains.
}
/**
- * Call this from GrGLFragmentProcessor::emitCode() to sample the texture W.R.T. the domain
- * and mode.
+ * Call this from GrGLSLFragmentProcessor::emitCode() to sample the texture W.R.T. the
+ * domain and mode.
*
* @param outcolor name of vec4 variable to hold the sampled color.
* @param inCoords name of vec2 variable containing the coords to be used with the domain.
const char* inModulateColor = nullptr);
/**
- * Call this from GrGLFragmentProcessor::setData() to upload uniforms necessary for the
+ * Call this from GrGLSLFragmentProcessor::setData() to upload uniforms necessary for the
* texture domain. The rectangle is automatically adjusted to account for the texture's
* origin.
*/
};
/**
- * GrGLFragmentProcessor::GenKey() must call this and include the returned value in it's
+ * GrGLSLFragmentProcessor::GenKey() must call this and include the returned value in it's
* computed key. The returned will be limited to the lower kDomainKeyBits bits.
*/
static uint32_t DomainKey(const GrTextureDomain& domain) {
GrTextureParams::FilterMode,
GrCoordSet);
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
#include "GrFragmentProcessor.h"
#include "effects/GrConstColorProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLSLBlend.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
+#include "glsl/GrGLSLBlend.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "SkGrPriv.h"
}
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
SkXfermode::Mode fMode;
/////////////////////////////////////////////////////////////////////
-class GLComposeTwoFragmentProcessor : public GrGLFragmentProcessor {
+class GLComposeTwoFragmentProcessor : public GrGLSLFragmentProcessor {
public:
GLComposeTwoFragmentProcessor(const GrProcessor& processor) {}
void emitCode(EmitArgs&) override;
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
/////////////////////////////////////////////////////////////////////
return new ComposeTwoFragmentProcessor(fpA, fpB, mode);
}
-GrGLFragmentProcessor* ComposeTwoFragmentProcessor::onCreateGLInstance() const{
+GrGLSLFragmentProcessor* ComposeTwoFragmentProcessor::onCreateGLInstance() const{
return new GLComposeTwoFragmentProcessor(*this);
}
}
private:
- GrGLFragmentProcessor* onCreateGLInstance() const override;
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override;
SkXfermode::Mode fMode;
Child fChild;
//////////////////////////////////////////////////////////////////////////////
-class GLComposeOneFragmentProcessor : public GrGLFragmentProcessor {
+class GLComposeOneFragmentProcessor : public GrGLSLFragmentProcessor {
public:
GLComposeOneFragmentProcessor(const GrProcessor& processor) {}
}
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
/////////////////////////////////////////////////////////////////////
return new ComposeOneFragmentProcessor(dst, mode, child);
}
-GrGLFragmentProcessor* ComposeOneFragmentProcessor::onCreateGLInstance() const {
+GrGLSLFragmentProcessor* ComposeOneFragmentProcessor::onCreateGLInstance() const {
return new GLComposeOneFragmentProcessor(*this);
}
#include "GrCoordTransform.h"
#include "GrInvariantOutput.h"
#include "GrProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
#include "glsl/GrGLSLProgramDataManager.h"
return fColorSpace;
}
- class GLProcessor : public GrGLFragmentProcessor {
+ class GLProcessor : public GrGLSLFragmentProcessor {
public:
static const float kJPEGConversionMatrix[16];
static const float kRec601ConversionMatrix[16];
private:
GrGLSLProgramDataManager::UniformHandle fMatrixUni;
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
private:
this->addTextureAccess(&fVAccess);
}
- GrGLFragmentProcessor* onCreateGLInstance() const override { return new GLProcessor(*this); }
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override { return new GLProcessor(*this); }
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
#include "builders/GrGLProgramBuilder.h"
#include "GrProcessor.h"
-#include "GrGLFragmentProcessor.h"
#include "GrGLPathRendering.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "SkRTConf.h"
#include "SkTSearch.h"
#include "SkRefCnt.h"
#include "GrPathRendering.h"
#include "GrStencil.h"
-#include "gl/GrGLProgram.h"
#include "gl/GrGLTypes.h"
+#include "glsl/GrGLSLUtil.h"
class GrGLNameAllocator;
class GrGLGpu;
0, 0, 1);
}
combined.preConcat(fViewMatrix);
- GrGLGetMatrix<Size>(destMatrix, combined);
+ GrGLSLGetMatrix<Size>(destMatrix, combined);
}
};
GrGLGpu* gpu();
#include "GrPathProcessor.h"
#include "GrPipeline.h"
#include "GrXferProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "SkXfermode.h"
#define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
*/
#include "GrGLProgramDesc.h"
-#include "GrGLFragmentProcessor.h"
#include "GrProcessor.h"
#include "GrGLGpu.h"
#include "GrPipeline.h"
#include "SkChecksum.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
/**
return GrGLGetRendererFromString((const char*) v);
}
-template<> void GrGLGetMatrix<3>(float* dest, const SkMatrix& src) {
- GR_STATIC_ASSERT(sizeof(float) == sizeof (GrGLfloat));
- // Col 0
- dest[0] = SkScalarToFloat(src[SkMatrix::kMScaleX]);
- dest[1] = SkScalarToFloat(src[SkMatrix::kMSkewY]);
- dest[2] = SkScalarToFloat(src[SkMatrix::kMPersp0]);
-
- // Col 1
- dest[3] = SkScalarToFloat(src[SkMatrix::kMSkewX]);
- dest[4] = SkScalarToFloat(src[SkMatrix::kMScaleY]);
- dest[5] = SkScalarToFloat(src[SkMatrix::kMPersp1]);
-
- // Col 2
- dest[6] = SkScalarToFloat(src[SkMatrix::kMTransX]);
- dest[7] = SkScalarToFloat(src[SkMatrix::kMTransY]);
- dest[8] = SkScalarToFloat(src[SkMatrix::kMPersp2]);
-}
-
-template<> void GrGLGetMatrix<4>(float* dest, const SkMatrix& src) {
- GR_STATIC_ASSERT(sizeof(float) == sizeof (GrGLfloat));
- // Col 0
- dest[0] = SkScalarToFloat(src[SkMatrix::kMScaleX]);
- dest[1] = SkScalarToFloat(src[SkMatrix::kMSkewY]);
- dest[2] = 0;
- dest[3] = SkScalarToFloat(src[SkMatrix::kMPersp0]);
-
- // Col 1
- dest[4] = SkScalarToFloat(src[SkMatrix::kMSkewX]);
- dest[5] = SkScalarToFloat(src[SkMatrix::kMScaleY]);
- dest[6] = 0;
- dest[7] = SkScalarToFloat(src[SkMatrix::kMPersp1]);
-
- // Col 2
- dest[8] = 0;
- dest[9] = 0;
- dest[10] = 1;
- dest[11] = 0;
-
- // Col 3
- dest[12] = SkScalarToFloat(src[SkMatrix::kMTransX]);
- dest[13] = SkScalarToFloat(src[SkMatrix::kMTransY]);
- dest[14] = 0;
- dest[15] = SkScalarToFloat(src[SkMatrix::kMPersp2]);
-}
-
GrGLenum GrToGLStencilFunc(GrStencilFunc basicFunc) {
static const GrGLenum gTable[] = {
GR_GL_ALWAYS, // kAlways_StencilFunc
void GrGLClearErr(const GrGLInterface* gl);
-/**
- * Helper for converting SkMatrix to a column-major GL float array
- */
-template<int MatrixSize> void GrGLGetMatrix(float* dest, const SkMatrix& src);
-
////////////////////////////////////////////////////////////////////////////////
/**
#include "GrTexture.h"
#include "SkRTConf.h"
#include "SkTraceEvent.h"
-#include "gl/GrGLFragmentProcessor.h"
#include "gl/GrGLGeometryProcessor.h"
#include "gl/GrGLGpu.h"
#include "gl/GrGLProgram.h"
#include "gl/GrGLXferProcessor.h"
#include "gl/builders/GrGLShaderStringBuilder.h"
#include "glsl/GrGLSLCaps.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLProgramDataManager.h"
#include "glsl/GrGLSLTextureSampler.h"
SkSTArray<4, GrGLSLTextureSampler> samplers(fp.numTextures());
this->emitSamplers(fp, &samplers, ifp);
- GrGLFragmentProcessor::EmitArgs args(this, fp, outColor, inColor, fOutCoords[index], samplers);
+ GrGLSLFragmentProcessor::EmitArgs args(this,
+ fp,
+ outColor,
+ inColor,
+ fOutCoords[index],
+ samplers);
ifp->fGLProc->emitCode(args);
// We have to check that effects and the code they emit are consistent, ie if an effect
typedef GrGLInstalledProc<GrGLPrimitiveProcessor> GrGLInstalledGeoProc;
typedef GrGLInstalledProc<GrGLXferProcessor> GrGLInstalledXferProc;
-typedef GrGLInstalledProc<GrGLFragmentProcessor> GrGLInstalledFragProc;
+typedef GrGLInstalledProc<GrGLSLFragmentProcessor> GrGLInstalledFragProc;
struct GrGLInstalledFragProcs : public SkRefCnt {
virtual ~GrGLInstalledFragProcs();
* found in the LICENSE file.
*/
-#include "GrGLFragmentProcessor.h"
+#include "GrGLSLFragmentProcessor.h"
#include "GrFragmentProcessor.h"
#include "GrProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
-void GrGLFragmentProcessor::setData(const GrGLSLProgramDataManager& pdman,
- const GrFragmentProcessor& processor) {
+void GrGLSLFragmentProcessor::setData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& processor) {
this->onSetData(pdman, processor);
SkASSERT(fChildProcessors.count() == processor.numChildProcessors());
for (int i = 0; i < fChildProcessors.count(); ++i) {
}
}
-void GrGLFragmentProcessor::emitChild(int childIndex, const char* inputColor, EmitArgs& args) {
+void GrGLSLFragmentProcessor::emitChild(int childIndex, const char* inputColor, EmitArgs& args) {
this->internalEmitChild(childIndex, inputColor, args.fOutputColor, args);
}
-void GrGLFragmentProcessor::emitChild(int childIndex, const char* inputColor,
+void GrGLSLFragmentProcessor::emitChild(int childIndex, const char* inputColor,
SkString* outputColor, EmitArgs& args) {
SkASSERT(outputColor);
this->internalEmitChild(childIndex, inputColor, outputColor->c_str(), args);
}
-void GrGLFragmentProcessor::internalEmitChild(int childIndex, const char* inputColor,
- const char* outputColor, EmitArgs& args) {
+void GrGLSLFragmentProcessor::internalEmitChild(int childIndex, const char* inputColor,
+ const char* outputColor, EmitArgs& args) {
GrGLSLFragmentBuilder* fb = args.fBuilder->getFragmentShaderBuilder();
fb->onBeforeChildProcEmitCode(); // call first so mangleString is updated
* found in the LICENSE file.
*/
-#ifndef GrGLFragmentProcessor_DEFINED
-#define GrGLFragmentProcessor_DEFINED
+#ifndef GrGLSLFragmentProcessor_DEFINED
+#define GrGLSLFragmentProcessor_DEFINED
#include "glsl/GrGLSLProcessorTypes.h"
#include "glsl/GrGLSLProgramDataManager.h"
class GrGLSLFPBuilder;
class GrGLSLCaps;
-class GrGLFragmentProcessor {
+class GrGLSLFragmentProcessor {
public:
- GrGLFragmentProcessor() {}
+ GrGLSLFragmentProcessor() {}
- virtual ~GrGLFragmentProcessor() {
+ virtual ~GrGLSLFragmentProcessor() {
for (int i = 0; i < fChildProcessors.count(); ++i) {
delete fChildProcessors[i];
}
int numChildProcessors() const { return fChildProcessors.count(); }
- GrGLFragmentProcessor* childProcessor(int index) const {
+ GrGLSLFragmentProcessor* childProcessor(int index) const {
return fChildProcessors[index];
}
void emitChild(int childIndex, const char* inputColor, EmitArgs& parentArgs);
protected:
- /** A GrGLFragmentProcessor instance can be reused with any GrFragmentProcessor that produces
+ /** A GrGLSLFragmentProcessor instance can be reused with any GrFragmentProcessor that produces
the same stage key; this function reads data from a GrFragmentProcessor and uploads any
uniform variables required by the shaders created in emitCode(). The GrFragmentProcessor
- parameter is guaranteed to be of the same type that created this GrGLFragmentProcessor and
- to have an identical processor key as the one that created this GrGLFragmentProcessor. */
+ parameter is guaranteed to be of the same type that created this GrGLSLFragmentProcessor and
+ to have an identical processor key as the one that created this GrGLSLFragmentProcessor. */
// TODO update this to pass in GrFragmentProcessor
virtual void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) {}
private:
void internalEmitChild(int, const char*, const char*, EmitArgs&);
- SkTArray<GrGLFragmentProcessor*, true> fChildProcessors;
+ SkTArray<GrGLSLFragmentProcessor*, true> fChildProcessors;
friend class GrFragmentProcessor;
};
--- /dev/null
+/*
+* Copyright 2015 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#include "GrGLSLUtil.h"
+#include "SkMatrix.h"
+
+template<> void GrGLSLGetMatrix<3>(float* dest, const SkMatrix& src) {
+ // Col 0
+ dest[0] = SkScalarToFloat(src[SkMatrix::kMScaleX]);
+ dest[1] = SkScalarToFloat(src[SkMatrix::kMSkewY]);
+ dest[2] = SkScalarToFloat(src[SkMatrix::kMPersp0]);
+
+ // Col 1
+ dest[3] = SkScalarToFloat(src[SkMatrix::kMSkewX]);
+ dest[4] = SkScalarToFloat(src[SkMatrix::kMScaleY]);
+ dest[5] = SkScalarToFloat(src[SkMatrix::kMPersp1]);
+
+ // Col 2
+ dest[6] = SkScalarToFloat(src[SkMatrix::kMTransX]);
+ dest[7] = SkScalarToFloat(src[SkMatrix::kMTransY]);
+ dest[8] = SkScalarToFloat(src[SkMatrix::kMPersp2]);
+}
+
+template<> void GrGLSLGetMatrix<4>(float* dest, const SkMatrix& src) {
+ // Col 0
+ dest[0] = SkScalarToFloat(src[SkMatrix::kMScaleX]);
+ dest[1] = SkScalarToFloat(src[SkMatrix::kMSkewY]);
+ dest[2] = 0;
+ dest[3] = SkScalarToFloat(src[SkMatrix::kMPersp0]);
+
+ // Col 1
+ dest[4] = SkScalarToFloat(src[SkMatrix::kMSkewX]);
+ dest[5] = SkScalarToFloat(src[SkMatrix::kMScaleY]);
+ dest[6] = 0;
+ dest[7] = SkScalarToFloat(src[SkMatrix::kMPersp1]);
+
+ // Col 2
+ dest[8] = 0;
+ dest[9] = 0;
+ dest[10] = 1;
+ dest[11] = 0;
+
+ // Col 3
+ dest[12] = SkScalarToFloat(src[SkMatrix::kMTransX]);
+ dest[13] = SkScalarToFloat(src[SkMatrix::kMTransY]);
+ dest[14] = 0;
+ dest[15] = SkScalarToFloat(src[SkMatrix::kMPersp2]);
+}
--- /dev/null
+/*
+* Copyright 2015 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef GrGLSLUtil_DEFINED
+#define GrGLSLUtil_DEFINED
+
+class SkMatrix;
+
+/**
+ * Helper for converting SkMatrix to a column-major float array. We assume that all GLSL backends
+ * use a column major representation for matrices.
+ */
+template<int MatrixSize> void GrGLSLGetMatrix(float* dest, const SkMatrix& src);
+
+#endif
#include "effects/GrPorterDuffXferProcessor.h"
#include "effects/GrXfermodeFragmentProcessor.h"
-#include "gl/GrGLFragmentProcessor.h"
#include "gl/GrGLGpu.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLProgramBuilder.h"
*/
static const uint32_t kMaxKeySize = 1024;
-class GLBigKeyProcessor : public GrGLFragmentProcessor {
+class GLBigKeyProcessor : public GrGLSLFragmentProcessor {
public:
GLBigKeyProcessor(const GrProcessor&) {}
}
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
class BigKeyProcessor : public GrFragmentProcessor {
const char* name() const override { return "Big Ole Key"; }
- GrGLFragmentProcessor* onCreateGLInstance() const override {
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override {
return new GLBigKeyProcessor(*this);
}
const char* name() const override { return "Block Input"; }
- GrGLFragmentProcessor* onCreateGLInstance() const override { return new GLFP; }
+ GrGLSLFragmentProcessor* onCreateGLInstance() const override { return new GLFP; }
private:
- class GLFP : public GrGLFragmentProcessor {
+ class GLFP : public GrGLSLFragmentProcessor {
public:
void emitCode(EmitArgs& args) override {
this->emitChild(0, nullptr, args);
}
private:
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLSLFragmentProcessor INHERITED;
};
BlockInputFragmentProcessor(const GrFragmentProcessor* child) {