GrXferProcessor can no longer use this functionality so it is moved to a new intermediate class inherited by GrFragmentProcessor and GrPrimitiveProcessor.
Change-Id: I4f30c89bdceb2d77b602bf0646107e0780881c26
Reviewed-on: https://skia-review.googlesource.com/11202
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder* b);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fStitchDataUni;
}
void GrGLPerlinNoise2::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const GrPerlinNoise2Effect& turbulence = processor.cast<GrPerlinNoise2Effect>();
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fZUni;
}
void GrGLImprovedPerlinNoise::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const GrImprovedPerlinNoiseEffect& noise = processor.cast<GrImprovedPerlinNoiseEffect>();
GrCoordTransforms to receive a transformation of the local coordinates that map from local space
to the fragment being processed.
*/
-class GrFragmentProcessor : public GrProcessor {
+class GrFragmentProcessor : public GrResourceIOProcessor {
public:
/**
* In many instances (e.g. SkShader::asFragmentProcessor() implementations) it is desirable to
&GrFragmentProcessor::coordTransform>;
using TextureAccessIter = FPItemIter<TextureSampler,
- GrProcessor,
- &GrProcessor::numTextureSamplers,
- &GrProcessor::textureSampler>;
+ GrResourceIOProcessor,
+ &GrResourceIOProcessor::numTextureSamplers,
+ &GrResourceIOProcessor::textureSampler>;
protected:
enum OptimizationFlags : uint32_t {
called. */
void pendingIOComplete() const;
- friend class GrProcessor;
+ friend class GrResourceIOProcessor;
GrGpuResource* fResource;
mutable bool fOwnRef;
*/
class GrProcessor : public GrProgramElement<GrProcessor> {
public:
- class TextureSampler;
- class BufferAccess;
- class ImageStorageAccess;
-
- virtual ~GrProcessor();
+ virtual ~GrProcessor() = default;
/** Human-meaningful string to identify this prcoessor; may be embedded in generated shader
code. */
return str;
}
- int numTextureSamplers() const { return fTextureSamplers.count(); }
-
- /** Returns the access pattern for the texture at index. index must be valid according to
- numTextureSamplers(). */
- const TextureSampler& textureSampler(int index) const { return *fTextureSamplers[index]; }
-
- int numBuffers() const { return fBufferAccesses.count(); }
-
- /** Returns the access pattern for the buffer at index. index must be valid according to
- numBuffers(). */
- const BufferAccess& bufferAccess(int index) const { return *fBufferAccesses[index]; }
-
- int numImageStorages() const { return fImageStorageAccesses.count(); }
-
- /** Returns the access object for the image at index. index must be valid according to
- numImages(). */
- const ImageStorageAccess& imageStorageAccess(int index) const {
- return *fImageStorageAccesses[index];
- }
-
/**
* Platform specific built-in features that a processor can request for the fragment shader.
*/
GrProcessor() : fClassID(kIllegalProcessorClassID), fRequiredFeatures(kNone_RequiredFeatures) {}
/**
- * Subclasses call these from their constructor to register sampler/image sources. The processor
- * subclass manages the lifetime of the objects (these functions only store pointers). The
- * TextureSampler and/or BufferAccess instances are typically member fields of the GrProcessor
- * subclass. These must only be called from the constructor because GrProcessors are immutable.
- */
- void addTextureSampler(const TextureSampler*);
- void addBufferAccess(const BufferAccess*);
- void addImageStorageAccess(const ImageStorageAccess*);
-
- bool hasSameSamplersAndAccesses(const GrProcessor &) const;
-
- /**
* If the prcoessor will generate code that uses platform specific built-in features, then it
* must call these methods from its constructor. Otherwise, requests to use these features will
* be denied.
}
friend class GrProgramElement<GrProcessor>;
- void addPendingIOs() const;
- void removeRefs() const;
- void pendingIOComplete() const;
+ virtual void addPendingIOs() const {}
+ virtual void removeRefs() const {}
+ virtual void pendingIOComplete() const {}
enum {
kIllegalProcessorClassID = 0,
uint32_t fClassID;
RequiredFeatures fRequiredFeatures;
- SkSTArray<4, const TextureSampler*, true> fTextureSamplers;
- SkSTArray<1, const BufferAccess*, true> fBufferAccesses;
- SkSTArray<1, const ImageStorageAccess*, true> fImageStorageAccesses;
typedef GrProgramElement INHERITED;
};
GR_MAKE_BITFIELD_OPS(GrProcessor::RequiredFeatures);
+/** A GrProcessor with the ability to access textures, buffers, and image storages. */
+class GrResourceIOProcessor : public GrProcessor {
+public:
+ class TextureSampler;
+ class BufferAccess;
+ class ImageStorageAccess;
+
+ int numTextureSamplers() const { return fTextureSamplers.count(); }
+
+ /** Returns the access pattern for the texture at index. index must be valid according to
+ numTextureSamplers(). */
+ const TextureSampler& textureSampler(int index) const { return *fTextureSamplers[index]; }
+
+ int numBuffers() const { return fBufferAccesses.count(); }
+
+ /** Returns the access pattern for the buffer at index. index must be valid according to
+ numBuffers(). */
+ const BufferAccess& bufferAccess(int index) const { return *fBufferAccesses[index]; }
+
+ int numImageStorages() const { return fImageStorageAccesses.count(); }
+
+ /** Returns the access object for the image at index. index must be valid according to
+ numImages(). */
+ const ImageStorageAccess& imageStorageAccess(int index) const {
+ return *fImageStorageAccesses[index];
+ }
+
+protected:
+ GrResourceIOProcessor() = default;
+
+ /**
+ * Subclasses call these from their constructor to register sampler/image sources. The processor
+ * subclass manages the lifetime of the objects (these functions only store pointers). The
+ * TextureSampler and/or BufferAccess instances are typically member fields of the GrProcessor
+ * subclass. These must only be called from the constructor because GrProcessors are immutable.
+ */
+ void addTextureSampler(const TextureSampler*);
+ void addBufferAccess(const BufferAccess*);
+ void addImageStorageAccess(const ImageStorageAccess*);
+
+ bool hasSameSamplersAndAccesses(const GrResourceIOProcessor&) const;
+
+private:
+ friend class GrProgramElement<GrProcessor>;
+ void addPendingIOs() const override;
+ void removeRefs() const override;
+ void pendingIOComplete() const override;
+
+ SkSTArray<4, const TextureSampler*, true> fTextureSamplers;
+ SkSTArray<1, const BufferAccess*, true> fBufferAccesses;
+ SkSTArray<1, const ImageStorageAccess*, true> fImageStorageAccesses;
+
+ typedef GrProcessor INHERITED;
+};
+
/**
- * Used to represent a texture that is required by a GrProcessor. It holds a GrTexture along with
- * an associated GrSamplerParams. TextureSamplers don't perform any coord manipulation to account
- * for texture origin.
+ * Used to represent a texture that is required by a GrResourceIOProcessor. It holds a GrTexture
+ * along with an associated GrSamplerParams. TextureSamplers don't perform any coord manipulation to
+ * account for texture origin.
*/
-class GrProcessor::TextureSampler : public SkNoncopyable {
+class GrResourceIOProcessor::TextureSampler : public SkNoncopyable {
public:
/**
* Must be initialized before adding to a GrProcessor's texture access list.
};
/**
- * Used to represent a texel buffer that will be read in a GrProcessor. It holds a GrBuffer along
- * with an associated offset and texel config.
+ * Used to represent a texel buffer that will be read in a GrResourceIOProcessor. It holds a
+ * GrBuffer along with an associated offset and texel config.
*/
-class GrProcessor::BufferAccess : public SkNoncopyable {
+class GrResourceIOProcessor::BufferAccess : public SkNoncopyable {
public:
BufferAccess() = default;
BufferAccess(GrPixelConfig texelConfig, GrBuffer* buffer,
const GrGpuResourceRef* programBuffer() const { return &fBuffer;}
private:
- GrPixelConfig fTexelConfig;
- GrTGpuResourceRef<GrBuffer> fBuffer;
- GrShaderFlags fVisibility;
+ GrPixelConfig fTexelConfig;
+ GrTGpuResourceRef<GrBuffer> fBuffer;
+ GrShaderFlags fVisibility;
typedef SkNoncopyable INHERITED;
};
* Currently the format of the load/store data in the shader is inferred from the texture config,
* though it could be made explicit.
*/
-class GrProcessor::ImageStorageAccess : public SkNoncopyable {
+class GrResourceIOProcessor::ImageStorageAccess : public SkNoncopyable {
public:
ImageStorageAccess(sk_sp<GrTexture> texture, GrIOType ioType, GrSLMemoryModel, GrSLRestrict,
GrShaderFlags visibility = kFragment_GrShaderFlag);
const GrGpuResourceRef* programTexture() const { return &fTexture; }
private:
- GrTGpuResourceRef<GrTexture> fTexture;
- GrShaderFlags fVisibility;
- GrImageStorageFormat fFormat;
- GrSLMemoryModel fMemoryModel;
- GrSLRestrict fRestrict;
+ GrTGpuResourceRef<GrTexture> fTexture;
+ GrShaderFlags fVisibility;
+ GrImageStorageFormat fFormat;
+ GrSLMemoryModel fMemoryModel;
+ GrSLRestrict fRestrict;
typedef SkNoncopyable INHERITED;
};
protected:
void onSetData(const GrGLSLProgramDataManager& uniManager,
- const GrProcessor& proc) override {
+ const GrFragmentProcessor& proc) override {
const ColorMatrixEffect& cme = proc.cast<ColorMatrixEffect>();
const float* m = cme.fMatrix;
// The GL matrix is transposed from SkColorMatrix.
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& proc) override {
const LightingFP& lightingFP = proc.cast<LightingFP>();
const SkTArray<SkLights::Light>& directionalLights = lightingFP.directionalLights();
protected:
void setNormalData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) override {
+ const GrFragmentProcessor& proc) override {
const NormalBevelFP& normalBevelFP = proc.cast<NormalBevelFP>();
// Updating uniform if bevel type requires it and data has changed
}
protected:
- void setNormalData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) override {}
+ void setNormalData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override {}
};
const char* name() const override { return "NormalFlatFP"; }
protected:
void setNormalData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) override {
+ const GrFragmentProcessor& proc) override {
const NormalMapFP& normalMapFP = proc.cast<NormalMapFP>();
const SkMatrix& invCTM = normalMapFP.invCTM();
}
}
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) final override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& proc) final override {
if (!fDidIntercept) {
this->setNormalData(pdman, proc);
}
protected:
virtual void onEmitCode(EmitArgs& args) = 0;
- virtual void setNormalData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) = 0;
+ virtual void setNormalData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) = 0;
private:
bool fDidIntercept;
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& proc) override {
const RadialShadowMapFP &radialShadowMapFP = proc.cast<RadialShadowMapFP>();
const SkVector3& lightPos = radialShadowMapFP.lightPos();
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& proc) override {
const ShadowFP &shadowFP = proc.cast<ShadowFP>();
for (int i = 0; i < shadowFP.numLights(); i++) {
}
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fInnerThresholdVar;
}
void GrGLAlphaThresholdFragmentProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
const GrAlphaThresholdFragmentProcessor& atfp = proc.cast<GrAlphaThresholdFragmentProcessor>();
pdman.set1f(fInnerThresholdVar, atfp.innerThreshold());
pdman.set1f(fOuterThresholdVar, atfp.outerThreshold());
void emitCode(EmitArgs&) override;
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fDataUniform;
}
void GrCircleBlurFragmentProcessor::GLSLProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
const GrCircleBlurFragmentProcessor& cbfp = proc.cast<GrCircleBlurFragmentProcessor>();
const SkRect& circle = cbfp.fCircle;
protected:
void onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) override {
+ const GrFragmentProcessor& proc) override {
const ArithmeticFP& arith = proc.cast<ArithmeticFP>();
pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
}
static void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder* b);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
}
void GrGLRectBlurEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
const GrRectBlurEffect& rbe = proc.cast<GrRectBlurEffect>();
SkRect rect = rbe.getRect();
void emitCode(EmitArgs&) override;
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fProxyRectUniform;
}
void GrGLRRectBlurEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
const GrRRectBlurEffect& brre = proc.cast<GrRRectBlurEffect>();
const SkRRect& rrect = brre.getRRect();
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
}
void GrGLDisplacementMapEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
const GrDisplacementMapEffect& displacementMap = proc.cast<GrDisplacementMapEffect>();
GrTexture* colorTex = displacementMap.textureSampler(1).texture();
SkScalar scaleX = displacementMap.scale().fX / colorTex->width();
GLHighContrastFilterEffect(const SkHighContrastConfig& config);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
void emitCode(EmitArgs& args) override;
private:
GLHighContrastFilterEffect::GenKey(*this, caps, b);
}
-void GLHighContrastFilterEffect::onSetData(const GrGLSLProgramDataManager& pdm, const GrProcessor& proc) {
+void GLHighContrastFilterEffect::onSetData(const GrGLSLProgramDataManager& pdm,
+ const GrFragmentProcessor& proc) {
const HighContrastFilterEffect& hcfe = proc.cast<HighContrastFilterEffect>();
pdm.set1f(fContrastUni, hcfe.config().fContrast);
}
/**
* Subclasses of GrGLLightingEffect must call INHERITED::onSetData();
*/
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
virtual void emitLightFunc(GrGLSLUniformHandler*,
GrGLSLFPFragmentBuilder*,
void emitLightFunc(GrGLSLUniformHandler*, GrGLSLFPFragmentBuilder*, SkString* funcName) override;
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
typedef GrGLLightingEffect INHERITED;
void emitLightFunc(GrGLSLUniformHandler*, GrGLSLFPFragmentBuilder*, SkString* funcName) override;
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
typedef GrGLLightingEffect INHERITED;
}
void GrGLLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
const GrLightingEffect& lighting = proc.cast<GrLightingEffect>();
if (!fLight) {
fLight = lighting.light()->createGLLight();
}
void GrGLDiffuseLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
INHERITED::onSetData(pdman, proc);
const GrDiffuseLightingEffect& diffuse = proc.cast<GrDiffuseLightingEffect>();
pdman.set1f(fKDUni, diffuse.kd());
}
void GrGLSpecularLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& effect) {
+ const GrFragmentProcessor& effect) {
INHERITED::onSetData(pdman, effect);
const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>();
pdman.set1f(fKSUni, spec.ks());
}
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
UniformHandle fOffsetVar;
}
void GrGLMagnifierEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& effect) {
+ const GrFragmentProcessor& effect) {
const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>();
GrTexture* tex = zoom.textureSampler(0).texture();
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fPixelSizeUni;
}
void GrGLMorphologyEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
+ const GrFragmentProcessor& proc) {
const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
GrTexture& texture = *m.textureSampler(0).texture();
void emitCode(EmitArgs&) override;
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override {}
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override {}
private:
GrColor4f fColors[SkOverdrawColorFilter::kNumColors];
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fStitchDataUni;
}
void GrGLPerlinNoise::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const GrPerlinNoiseEffect& turbulence = processor.cast<GrPerlinNoiseEffect>();
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& proc) override {
const RRectsGaussianEdgeFP& edgeFP = proc.cast<RRectsGaussianEdgeFP>();
const SkRRect& first = edgeFP.first();
static void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*) {}
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
UniformHandle fRGBAYValuesUni;
typedef GrGLSLFragmentProcessor INHERITED;
};
-void GLColorTableEffect::onSetData(const GrGLSLProgramDataManager& pdm, const GrProcessor& proc) {
+void GLColorTableEffect::onSetData(const GrGLSLProgramDataManager& pdm,
+ const GrFragmentProcessor& proc) {
// The textures are organized in a strip where the rows are ordered a, r, g, b.
float rgbaYValues[4];
const ColorTableEffect& cte = proc.cast<ColorTableEffect>();
}
void GrGradientEffect::GLSLProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
const GrGradientEffect& e = processor.cast<GrGradientEffect>();
switch (e.getColorType()) {
}
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
protected:
/**
static void GenKey(const GrProcessor&, const GrShaderCaps& caps, GrProcessorKeyBuilder* b);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
UniformHandle fParamUni;
}
void Edge2PtConicalEffect::GLSLEdge2PtConicalProcessor::onSetData(
- const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
SkScalar radius0 = data.radius();
static void GenKey(const GrProcessor&, const GrShaderCaps& caps, GrProcessorKeyBuilder* b);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
UniformHandle fParamUni;
}
void FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor::onSetData(
- const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
static void GenKey(const GrProcessor&, const GrShaderCaps& caps, GrProcessorKeyBuilder* b);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
UniformHandle fFocalUni;
}
void FocalInside2PtConicalEffect::GLSLFocalInside2PtConicalProcessor::onSetData(
- const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();
SkScalar focal = data.focal();
static void GenKey(const GrProcessor&, const GrShaderCaps& caps, GrProcessorKeyBuilder* b);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
UniformHandle fCenterUni;
UniformHandle fParamUni;
}
void CircleInside2PtConicalEffect::GLSLCircleInside2PtConicalProcessor::onSetData(
- const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();
SkScalar centerX = data.centerX();
static void GenKey(const GrProcessor&, const GrShaderCaps& caps, GrProcessorKeyBuilder* b);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
UniformHandle fCenterUni;
UniformHandle fParamUni;
}
void CircleOutside2PtConicalEffect::GLSLCircleOutside2PtConicalProcessor::onSetData(
- const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor) {
INHERITED::onSetData(pdman, processor);
const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
private:
void onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& fp) override {
+ const GrFragmentProcessor& fp) override {
GrColor4f color = fp.cast<ReplaceInputFragmentProcessor>().fColor;
if (!fHaveSetColor || color != fPreviousColor) {
pdman.set4fv(fColorUni, 1, color.fRGBA);
static void add_dependencies_for_processor(const GrFragmentProcessor* proc, GrRenderTarget* rt) {
GrFragmentProcessor::TextureAccessIter iter(proc);
- while (const GrProcessor::TextureSampler* sampler = iter.next()) {
+ while (const GrResourceIOProcessor::TextureSampler* sampler = iter.next()) {
SkASSERT(rt->getLastOpList());
rt->getLastOpList()->addDependency(sampler->texture());
}
* GrPrimitiveProcessors must proivide seed color and coverage for the Ganesh color / coverage
* pipelines, and they must provide some notion of equality
*/
-class GrPrimitiveProcessor : public GrProcessor {
+class GrPrimitiveProcessor : public GrResourceIOProcessor {
public:
// Only the GrGeometryProcessor subclass actually has a geo shader or vertex attributes, but
// we put these calls on the base class to prevent having to cast
///////////////////////////////////////////////////////////////////////////////
-GrProcessor::~GrProcessor() {}
+void* GrProcessor::operator new(size_t size) { return MemoryPoolAccessor().pool()->allocate(size); }
-void GrProcessor::addTextureSampler(const TextureSampler* access) {
+void GrProcessor::operator delete(void* target) {
+ return MemoryPoolAccessor().pool()->release(target);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrResourceIOProcessor::addTextureSampler(const TextureSampler* access) {
fTextureSamplers.push_back(access);
}
-void GrProcessor::addBufferAccess(const BufferAccess* access) {
+void GrResourceIOProcessor::addBufferAccess(const BufferAccess* access) {
fBufferAccesses.push_back(access);
}
-void GrProcessor::addImageStorageAccess(const ImageStorageAccess* access) {
+void GrResourceIOProcessor::addImageStorageAccess(const ImageStorageAccess* access) {
fImageStorageAccesses.push_back(access);
}
-void GrProcessor::addPendingIOs() const {
+void GrResourceIOProcessor::addPendingIOs() const {
for (const auto& sampler : fTextureSamplers) {
sampler->programTexture()->markPendingIO();
}
}
}
-void GrProcessor::removeRefs() const {
+void GrResourceIOProcessor::removeRefs() const {
for (const auto& sampler : fTextureSamplers) {
sampler->programTexture()->removeRef();
}
}
}
-void GrProcessor::pendingIOComplete() const {
+void GrResourceIOProcessor::pendingIOComplete() const {
for (const auto& sampler : fTextureSamplers) {
sampler->programTexture()->pendingIOComplete();
}
}
}
-void* GrProcessor::operator new(size_t size) {
- return MemoryPoolAccessor().pool()->allocate(size);
-}
-
-void GrProcessor::operator delete(void* target) {
- return MemoryPoolAccessor().pool()->release(target);
-}
-
-bool GrProcessor::hasSameSamplersAndAccesses(const GrProcessor &that) const {
+bool GrResourceIOProcessor::hasSameSamplersAndAccesses(const GrResourceIOProcessor& that) const {
if (this->numTextureSamplers() != that.numTextureSamplers() ||
this->numBuffers() != that.numBuffers() ||
this->numImageStorages() != that.numImageStorages()) {
///////////////////////////////////////////////////////////////////////////////////////////////////
-GrProcessor::TextureSampler::TextureSampler() {}
+GrResourceIOProcessor::TextureSampler::TextureSampler() {}
-GrProcessor::TextureSampler::TextureSampler(GrTexture* texture, const GrSamplerParams& params) {
+GrResourceIOProcessor::TextureSampler::TextureSampler(GrTexture* texture,
+ const GrSamplerParams& params) {
this->reset(texture, params);
}
-GrProcessor::TextureSampler::TextureSampler(GrTexture* texture,
- GrSamplerParams::FilterMode filterMode,
- SkShader::TileMode tileXAndY,
- GrShaderFlags visibility) {
+GrResourceIOProcessor::TextureSampler::TextureSampler(GrTexture* texture,
+ GrSamplerParams::FilterMode filterMode,
+ SkShader::TileMode tileXAndY,
+ GrShaderFlags visibility) {
this->reset(texture, filterMode, tileXAndY, visibility);
}
-GrProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
- sk_sp<GrTextureProxy> proxy,
- const GrSamplerParams& params) {
+GrResourceIOProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
+ sk_sp<GrTextureProxy> proxy,
+ const GrSamplerParams& params) {
this->reset(resourceProvider, std::move(proxy), params);
}
-GrProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
- sk_sp<GrTextureProxy> proxy,
- GrSamplerParams::FilterMode filterMode,
- SkShader::TileMode tileXAndY,
- GrShaderFlags visibility) {
+GrResourceIOProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
+ sk_sp<GrTextureProxy> proxy,
+ GrSamplerParams::FilterMode filterMode,
+ SkShader::TileMode tileXAndY,
+ GrShaderFlags visibility) {
this->reset(resourceProvider, std::move(proxy), filterMode, tileXAndY, visibility);
}
-void GrProcessor::TextureSampler::reset(GrTexture* texture,
- const GrSamplerParams& params,
- GrShaderFlags visibility) {
+void GrResourceIOProcessor::TextureSampler::reset(GrTexture* texture,
+ const GrSamplerParams& params,
+ GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
fParams = params;
fVisibility = visibility;
}
-void GrProcessor::TextureSampler::reset(GrTexture* texture,
- GrSamplerParams::FilterMode filterMode,
- SkShader::TileMode tileXAndY,
- GrShaderFlags visibility) {
+void GrResourceIOProcessor::TextureSampler::reset(GrTexture* texture,
+ GrSamplerParams::FilterMode filterMode,
+ SkShader::TileMode tileXAndY,
+ GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
filterMode = SkTMin(filterMode, texture->texturePriv().highestFilterMode());
fVisibility = visibility;
}
-void GrProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
- sk_sp<GrTextureProxy> proxy,
- const GrSamplerParams& params,
- GrShaderFlags visibility) {
+void GrResourceIOProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
+ sk_sp<GrTextureProxy> proxy,
+ const GrSamplerParams& params,
+ GrShaderFlags visibility) {
// For now, end the deferral at this time. Once all the TextureSamplers are swapped over
// to taking a GrSurfaceProxy just use the IORefs on the proxy
GrTexture* texture = proxy->instantiate(resourceProvider);
fVisibility = visibility;
}
-void GrProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
- sk_sp<GrTextureProxy> proxy,
- GrSamplerParams::FilterMode filterMode,
- SkShader::TileMode tileXAndY,
- GrShaderFlags visibility) {
+void GrResourceIOProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
+ sk_sp<GrTextureProxy> proxy,
+ GrSamplerParams::FilterMode filterMode,
+ SkShader::TileMode tileXAndY,
+ GrShaderFlags visibility) {
// For now, end the deferral at this time. Once all the TextureSamplers are swapped over
// to taking a GrSurfaceProxy just use the IORefs on the proxy
GrTexture* texture = proxy->instantiate(resourceProvider);
///////////////////////////////////////////////////////////////////////////////////////////////////
-GrProcessor::ImageStorageAccess::ImageStorageAccess(sk_sp<GrTexture> texture, GrIOType ioType,
- GrSLMemoryModel memoryModel,
- GrSLRestrict restrict,
- GrShaderFlags visibility) {
+GrResourceIOProcessor::ImageStorageAccess::ImageStorageAccess(sk_sp<GrTexture> texture,
+ GrIOType ioType,
+ GrSLMemoryModel memoryModel,
+ GrSLRestrict restrict,
+ GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(texture.release(), ioType);
fMemoryModel = memoryModel;
(caps.samplerPrecision(config, visibility) << (8 + kSamplerOrImageTypeKeyBits)));
}
-static uint16_t storage_image_key(const GrProcessor::ImageStorageAccess& imageAccess) {
+static uint16_t storage_image_key(const GrResourceIOProcessor::ImageStorageAccess& imageAccess) {
GrSLType type = imageAccess.texture()->texturePriv().imageStorageType();
return image_storage_or_sampler_uniform_type_key(type) |
(int)imageAccess.format() << kSamplerOrImageTypeKeyBits;
}
-static void add_sampler_and_image_keys(GrProcessorKeyBuilder* b, const GrProcessor& proc,
+static void add_sampler_and_image_keys(GrProcessorKeyBuilder* b, const GrResourceIOProcessor& proc,
const GrShaderCaps& caps) {
int numTextureSamplers = proc.numTextureSamplers();
int numBuffers = proc.numBuffers();
uint16_t* k16 = SkTCast<uint16_t*>(b->add32n(word32Count));
int j = 0;
for (int i = 0; i < numTextureSamplers; ++i, ++j) {
- const GrProcessor::TextureSampler& sampler = proc.textureSampler(i);
+ const GrResourceIOProcessor::TextureSampler& sampler = proc.textureSampler(i);
const GrTexture* tex = sampler.texture();
k16[j] = sampler_key(tex->texturePriv().samplerType(), tex->config(), sampler.visibility(),
caps);
}
for (int i = 0; i < numBuffers; ++i, ++j) {
- const GrProcessor::BufferAccess& access = proc.bufferAccess(i);
+ const GrResourceIOProcessor::BufferAccess& access = proc.bufferAccess(i);
k16[j] = sampler_key(kBufferSampler_GrSLType, access.texelConfig(), access.visibility(),
caps);
}
* transforms, etc, for the space allotted in the meta-key. NOTE, both FPs and GPs share this
* function because it is hairy, though FPs do not have attribs, and GPs do not have transforms
*/
-static bool gen_meta_key(const GrProcessor& proc,
+static bool gen_meta_key(const GrResourceIOProcessor& proc,
const GrShaderCaps& shaderCaps,
uint32_t transformKey,
GrProcessorKeyBuilder* b) {
return true;
}
+static bool gen_meta_key(const GrXferProcessor& xp,
+ const GrShaderCaps& shaderCaps,
+ GrProcessorKeyBuilder* b) {
+ size_t processorKeySize = b->size();
+ uint32_t classID = xp.classID();
+
+ // Currently we allow 16 bits for the class id and the overall processor key size.
+ static const uint32_t kMetaKeyInvalidMask = ~((uint32_t)SK_MaxU16);
+ if ((processorKeySize | classID) & kMetaKeyInvalidMask) {
+ return false;
+ }
+
+ b->add32((classID << 16) | SkToU32(processorKeySize));
+ return true;
+}
+
static bool gen_frag_proc_and_meta_keys(const GrPrimitiveProcessor& primProc,
const GrFragmentProcessor& fp,
const GrShaderCaps& shaderCaps,
originIfDstTexture = &origin;
}
xp.getGLSLProcessorKey(shaderCaps, &b, originIfDstTexture);
- if (!gen_meta_key(xp, shaderCaps, 0, &b)) {
+ if (!gen_meta_key(xp, shaderCaps, &b)) {
desc->key().reset();
return false;
}
}
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
}
void GrGLBicubicEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
const GrBicubicEffect& bicubicEffect = processor.cast<GrBicubicEffect>();
GrTexture* texture = processor.textureSampler(0).texture();
float imageIncrement[2];
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {}
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& proc) override {}
GrBlurredEdgeFP::Mode fMode;
};
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdm, const GrProcessor& processor) override {
+ void onSetData(const GrGLSLProgramDataManager& pdm,
+ const GrFragmentProcessor& processor) override {
GrColor4f color = processor.cast<GrConstColorProcessor>().color();
// We use the "illegal" color value as an uninit sentinel. With GrColor4f, the "illegal"
// color is *really* illegal (not just unpremultiplied), so this check is simple.
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fRectUniform;
}
void GLAARectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
const AARectEffect& aare = processor.cast<AARectEffect>();
const SkRect& rect = aare.getRect();
if (rect != fPrevRect) {
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fEdgeUniform;
}
void GrGLConvexPolyEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& effect) {
+ const GrFragmentProcessor& effect) {
const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>();
size_t byteSize = 3 * cpe.getEdgeCount() * sizeof(SkScalar);
if (0 != memcmp(fPrevEdges, cpe.getEdges(), byteSize)) {
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
UniformHandle fKernelUni;
}
void GrGLConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
const GrGaussianConvolutionFragmentProcessor& conv =
processor.cast<GrGaussianConvolutionFragmentProcessor>();
GrTexture& texture = *conv.textureSampler(0).texture();
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
}
void GrGLMatrixConvolutionEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
const GrMatrixConvolutionEffect& conv = processor.cast<GrMatrixConvolutionEffect>();
GrTexture* texture = conv.textureSampler(0).texture();
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& processor) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& processor) override {
const GrNonlinearColorSpaceXformEffect& csxe =
processor.cast<GrNonlinearColorSpaceXformEffect>();
if (SkToBool(csxe.ops() & GrNonlinearColorSpaceXformEffect::kSrcTransfer_Op)) {
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fCircleUniform;
}
void GLCircleEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
const CircleEffect& ce = processor.cast<CircleEffect>();
if (ce.getRadius() != fPrevRadius || ce.getCenter() != fPrevCenter) {
SkScalar radius = ce.getRadius();
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fEllipseUniform;
}
void GLEllipseEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& effect) {
+ const GrFragmentProcessor& effect) {
const EllipseEffect& ee = effect.cast<EllipseEffect>();
if (ee.getRadii() != fPrevRadii || ee.getCenter() != fPrevCenter) {
float invRXSqd;
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
}
void GLCircularRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) {
+ const GrFragmentProcessor& processor) {
const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
const SkRRect& rrect = crre.getRRect();
if (rrect != fPrevRRect) {
static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
private:
GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
}
void GLEllipticalRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& effect) {
+ const GrFragmentProcessor& effect) {
const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
const SkRRect& rrect = erre.getRRect();
// If we're using a scale factor to work around precision issues, choose the largest radius
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& processor) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& processor) override {
const GrSimpleTextureEffect& textureEffect = processor.cast<GrSimpleTextureEffect>();
if (SkToBool(textureEffect.colorSpaceXform())) {
fColorSpaceHelper.setData(pdman, textureEffect.colorSpaceXform());
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& fp) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& fp) override {
const GrTextureDomainEffect& tde = fp.cast<GrTextureDomainEffect>();
const GrTextureDomain& domain = tde.fTextureDomain;
fGLDomain.setData(pdman, domain, tde.textureSampler(0).texture());
}
protected:
- void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& fp) override {
+ void onSetData(const GrGLSLProgramDataManager& pdman,
+ const GrFragmentProcessor& fp) override {
const GrDeviceSpaceTextureDecalFragmentProcessor& dstdfp =
fp.cast<GrDeviceSpaceTextureDecalFragmentProcessor>();
GrTexture* texture = dstdfp.textureSampler(0).texture();
protected:
void onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) override {
+ const GrFragmentProcessor& processor) override {
const YUVtoRGBEffect& yuvEffect = processor.cast<YUVtoRGBEffect>();
switch (yuvEffect.getColorSpace()) {
case kJPEG_SkYUVColorSpace:
private:
void onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& processor) override {
+ const GrFragmentProcessor& processor) override {
const RGBToYUVEffect& effect = processor.cast<RGBToYUVEffect>();
OutputChannels oc = effect.outputChannels();
if (effect.getColorSpace() != fLastColorSpace || oc != fLastOutputChannels) {
}
}
-void GrGLProgram::bindTextures(const GrProcessor& processor,
+void GrGLProgram::bindTextures(const GrResourceIOProcessor& processor,
bool allowSRGBInputs,
int* nextSamplerIdx) {
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
- const GrProcessor::TextureSampler& sampler = processor.textureSampler(i);
+ const GrResourceIOProcessor::TextureSampler& sampler = processor.textureSampler(i);
fGpu->bindTexture((*nextSamplerIdx)++, sampler.params(),
allowSRGBInputs, static_cast<GrGLTexture*>(sampler.texture()));
}
for (int i = 0; i < processor.numBuffers(); ++i) {
- const GrProcessor::BufferAccess& access = processor.bufferAccess(i);
+ const GrResourceIOProcessor::BufferAccess& access = processor.bufferAccess(i);
fGpu->bindTexelBuffer((*nextSamplerIdx)++, access.texelConfig(),
static_cast<GrGLBuffer*>(access.buffer()));
}
for (int i = 0; i < processor.numImageStorages(); ++i) {
- const GrProcessor::ImageStorageAccess& access = processor.imageStorageAccess(i);
+ const GrResourceIOProcessor::ImageStorageAccess& access = processor.imageStorageAccess(i);
fGpu->bindImageStorage((*nextSamplerIdx)++, access.ioType(),
static_cast<GrGLTexture *>(access.texture()));
}
}
-void GrGLProgram::generateMipmaps(const GrProcessor& processor,
- bool allowSRGBInputs) {
+void GrGLProgram::generateMipmaps(const GrResourceIOProcessor& processor, bool allowSRGBInputs) {
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
- const GrProcessor::TextureSampler& sampler = processor.textureSampler(i);
+ const GrResourceIOProcessor::TextureSampler& sampler = processor.textureSampler(i);
fGpu->generateMipmaps(sampler.params(), allowSRGBInputs,
static_cast<GrGLTexture*>(sampler.texture()));
}
void setRenderTargetState(const GrPrimitiveProcessor&, const GrRenderTarget*);
// Helper for setData() that binds textures and texel buffers to the appropriate texture units
- void bindTextures(const GrProcessor&, bool allowSRGBInputs, int* nextSamplerIdx);
+ void bindTextures(const GrResourceIOProcessor&, bool allowSRGBInputs, int* nextSamplerIdx);
// Helper for generateMipmaps() that ensures mipmaps are up to date
- void generateMipmaps(const GrProcessor&, bool allowSRGBInputs);
+ void generateMipmaps(const GrResourceIOProcessor&, bool allowSRGBInputs);
// these reflect the current values of uniforms (GL uniform values travel with program)
RenderTargetState fRenderTargetState;
public:
using TransformedCoordVars = BuilderInputProvider<GrShaderVar, GrFragmentProcessor,
&GrFragmentProcessor::numCoordTransforms>;
- using TextureSamplers = BuilderInputProvider<SamplerHandle, GrProcessor,
- &GrProcessor::numTextureSamplers>;
- using BufferSamplers = BuilderInputProvider<SamplerHandle, GrProcessor,
- &GrProcessor::numBuffers>;
- using ImageStorages = BuilderInputProvider<ImageStorageHandle, GrProcessor,
- &GrProcessor::numImageStorages>;
+ using TextureSamplers = BuilderInputProvider<SamplerHandle, GrResourceIOProcessor,
+ &GrResourceIOProcessor::numTextureSamplers>;
+ using BufferSamplers = BuilderInputProvider<SamplerHandle, GrResourceIOProcessor,
+ &GrResourceIOProcessor::numBuffers>;
+ using ImageStorages = BuilderInputProvider<ImageStorageHandle, GrResourceIOProcessor,
+ &GrResourceIOProcessor::numImageStorages>;
/** Called when the program stage should insert its code into the shaders. The code in each
shader will be in its own block ({}) and so locally scoped names will not collide across
uniform variables required by the shaders created in emitCode(). The GrFragmentProcessor
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&) {}
+ virtual void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) {}
private:
void internalEmitChild(int, const char*, const char*, EmitArgs&);
}
void GrGLSLProgramBuilder::emitSamplersAndImageStorages(
- const GrProcessor& processor,
+ const GrResourceIOProcessor& processor,
SkTArray<SamplerHandle>* outTexSamplerHandles,
SkTArray<SamplerHandle>* outBufferSamplerHandles,
SkTArray<ImageStorageHandle>* outImageStorageHandles) {
SkString name;
int numTextureSamplers = processor.numTextureSamplers();
for (int t = 0; t < numTextureSamplers; ++t) {
- const GrProcessor::TextureSampler& sampler = processor.textureSampler(t);
+ const GrResourceIOProcessor::TextureSampler& sampler = processor.textureSampler(t);
name.printf("TextureSampler_%d", outTexSamplerHandles->count());
GrSLType samplerType = sampler.texture()->texturePriv().samplerType();
if (kTextureExternalSampler_GrSLType == samplerType) {
GrShaderFlags texelBufferVisibility = kNone_GrShaderFlags;
for (int b = 0; b < numBuffers; ++b) {
- const GrProcessor::BufferAccess& access = processor.bufferAccess(b);
+ const GrResourceIOProcessor::BufferAccess& access = processor.bufferAccess(b);
name.printf("BufferSampler_%d", outBufferSamplerHandles->count());
outBufferSamplerHandles->emplace_back(
this->emitSampler(kBufferSampler_GrSLType, access.texelConfig(), name.c_str(),
}
int numImageStorages = processor.numImageStorages();
for (int i = 0; i < numImageStorages; ++i) {
- const GrProcessor::ImageStorageAccess& imageStorageAccess = processor.imageStorageAccess(i);
+ const GrResourceIOProcessor::ImageStorageAccess& imageStorageAccess =
+ processor.imageStorageAccess(i);
name.printf("Image_%d", outImageStorageHandles->count());
outImageStorageHandles->emplace_back(
this->emitImageStorage(imageStorageAccess, name.c_str()));
}
GrGLSLProgramBuilder::ImageStorageHandle GrGLSLProgramBuilder::emitImageStorage(
- const GrProcessor::ImageStorageAccess& access, const char* name) {
+ const GrResourceIOProcessor::ImageStorageAccess& access, const char* name) {
if (access.visibility() & kVertex_GrShaderFlag) {
++fNumVertexImageStorages;
}
const GrGLSLExpr4& input,
GrGLSLExpr4* output);
void emitAndInstallXferProc(const GrGLSLExpr4& colorIn, const GrGLSLExpr4& coverageIn);
- void emitSamplersAndImageStorages(const GrProcessor& processor,
+ void emitSamplersAndImageStorages(const GrResourceIOProcessor& processor,
SkTArray<SamplerHandle>* outTexSamplerHandles,
SkTArray<SamplerHandle>* outBufferSamplerHandles,
SkTArray<ImageStorageHandle>* outImageStorageHandles);
SamplerHandle emitSampler(GrSLType samplerType, GrPixelConfig, const char* name,
GrShaderFlags visibility);
- ImageStorageHandle emitImageStorage(const GrProcessor::ImageStorageAccess&, const char* name);
+ ImageStorageHandle emitImageStorage(const GrResourceIOProcessor::ImageStorageAccess&,
+ const char* name);
void emitFSOutputSwizzle(bool hasSecondaryOutput);
bool checkSamplerCounts();
bool checkImageStorageCounts();
false);
}
-static void prepare_sampled_images(const GrProcessor& processor, GrVkGpu* gpu) {
+static void prepare_sampled_images(const GrResourceIOProcessor& processor, GrVkGpu* gpu) {
for (int i = 0; i < processor.numTextureSamplers(); ++i) {
- const GrProcessor::TextureSampler& sampler = processor.textureSampler(i);
+ const GrResourceIOProcessor::TextureSampler& sampler = processor.textureSampler(i);
GrVkTexture* vkTexture = static_cast<GrVkTexture*>(sampler.texture());
SkASSERT(vkTexture);
}
}
-static void append_texture_bindings(const GrProcessor& processor,
- SkTArray<const GrProcessor::TextureSampler*>* textureBindings) {
+static void append_texture_bindings(
+ const GrResourceIOProcessor& processor,
+ SkTArray<const GrResourceIOProcessor::TextureSampler*>* textureBindings) {
// We don't support image storages in VK.
SkASSERT(!processor.numImageStorages());
if (int numTextureSamplers = processor.numTextureSamplers()) {
- const GrProcessor::TextureSampler** bindings =
+ const GrResourceIOProcessor::TextureSampler** bindings =
textureBindings->push_back_n(numTextureSamplers);
int i = 0;
do {
this->setRenderTargetState(pipeline.getRenderTarget());
- SkSTArray<8, const GrProcessor::TextureSampler*> textureBindings;
+ SkSTArray<8, const GrResourceIOProcessor::TextureSampler*> textureBindings;
fGeometryProcessor->setData(fDataManager, primProc,
GrFragmentProcessor::CoordTransformIter(pipeline));
SkIPoint offset;
GrTexture* dstTexture = pipeline.dstTexture(&offset);
fXferProcessor->setData(fDataManager, pipeline.getXferProcessor(), dstTexture, offset);
- GrProcessor::TextureSampler dstTextureSampler;
+ GrResourceIOProcessor::TextureSampler dstTextureSampler;
if (dstTexture) {
dstTextureSampler.reset(dstTexture);
textureBindings.push_back(&dstTextureSampler);
void GrVkPipelineState::writeSamplers(
GrVkGpu* gpu,
- const SkTArray<const GrProcessor::TextureSampler*>& textureBindings,
+ const SkTArray<const GrResourceIOProcessor::TextureSampler*>& textureBindings,
bool allowSRGBInputs) {
SkASSERT(fNumSamplers == textureBindings.count());
void writeUniformBuffers(const GrVkGpu* gpu);
- void writeSamplers(GrVkGpu* gpu,
- const SkTArray<const GrProcessor::TextureSampler*>& textureBindings,
- bool allowSRGBInputs);
+ void writeSamplers(
+ GrVkGpu* gpu,
+ const SkTArray<const GrResourceIOProcessor::TextureSampler*>& textureBindings,
+ bool allowSRGBInputs);
/**
* We use the RT's size and origin to adjust from Skia device space to vulkan normalized device
projects / platform / upstream / libSkiaSharp.git / commitdiff