#include "SkXfermode.h"
class SkBitmap;
-class GrEffectRef;
+class GrEffect;
class GrContext;
/**
/** A subclass may implement this factory function to work with the GPU backend. If the return
is non-NULL then the caller owns a ref on the returned object.
*/
- virtual GrEffectRef* asNewEffect(GrContext*) const;
+ virtual GrEffect* asNewEffect(GrContext*) const;
SK_TO_STRING_PUREVIRT()
virtual bool asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const SK_OVERRIDE;
+ GrEffect** grEffect) const SK_OVERRIDE;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorShader)
class SkColorFilter;
class SkBaseDevice;
struct SkIPoint;
-class GrEffectRef;
+class GrEffect;
class GrTexture;
/**
* will be called with (NULL, NULL, SkMatrix::I()) to query for support,
* so returning "true" indicates support for all possible matrices.
*/
- virtual bool asNewEffect(GrEffectRef** effect,
+ virtual bool asNewEffect(GrEffect** effect,
GrTexture*,
const SkMatrix& matrix,
const SkIRect& bounds) const;
* If effect is non-NULL, a new GrEffect instance is stored in it. The caller assumes ownership
* of the effect and must unref it.
*/
- virtual bool asNewEffect(GrEffectRef** effect,
+ virtual bool asNewEffect(GrEffect** effect,
GrTexture*,
const SkMatrix& ctm) const;
class SkPicture;
class SkXfermode;
class GrContext;
-class GrEffectRef;
+class GrEffect;
/** \class SkShader
*
*/
virtual bool asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrixOrNull, GrColor* grColor,
- GrEffectRef** grEffect) const;
+ GrEffect** grEffect) const;
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
/**
#include "SkFlattenable.h"
#include "SkColor.h"
-class GrEffectRef;
+class GrEffect;
class GrTexture;
class SkString;
fragment shader. If NULL, the effect should request access to destination color
(setWillReadDstColor()), and use that in the fragment shader (builder->dstColor()).
*/
- virtual bool asNewEffect(GrEffectRef** effect, GrTexture* background = NULL) const;
+ virtual bool asNewEffect(GrEffect** effect, GrTexture* background = NULL) const;
/** Returns true if the xfermode can be expressed as coeffs (src, dst), or as an effect
(effect). This helper calls the asCoeff() and asNewEffect() virtuals. If the xfermode is
simply test the return value. effect, src, and dst must all be NULL or all non-NULL.
*/
static bool AsNewEffectOrCoeff(SkXfermode*,
- GrEffectRef** effect,
+ GrEffect** effect,
Coeff* src,
Coeff* dst,
GrTexture* background = NULL);
virtual uint32_t getFlags() const SK_OVERRIDE;
virtual bool asColorMatrix(SkScalar matrix[20]) const SK_OVERRIDE;
#if SK_SUPPORT_GPU
- virtual GrEffectRef* asNewEffect(GrContext*) const SK_OVERRIDE;
+ virtual GrEffect* asNewEffect(GrContext*) const SK_OVERRIDE;
#endif
struct State {
virtual void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const SK_OVERRIDE;
#if SK_SUPPORT_GPU
- virtual GrEffectRef* asNewEffect(GrContext*) const SK_OVERRIDE;
+ virtual GrEffect* asNewEffect(GrContext*) const SK_OVERRIDE;
#endif
SK_TO_STRING_OVERRIDE()
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
#if SK_SUPPORT_GPU
- virtual bool asNewEffect(GrEffectRef** effect, GrTexture* texture, const SkMatrix& matrix, const SkIRect& bounds) const SK_OVERRIDE;
+ virtual bool asNewEffect(GrEffect** effect, GrTexture* texture, const SkMatrix& matrix,
+ const SkIRect& bounds) const SK_OVERRIDE;
#endif
private:
#if SK_SUPPORT_GPU
- virtual bool asNewEffect(GrEffectRef** effect,
+ virtual bool asNewEffect(GrEffect** effect,
GrTexture*,
const SkMatrix& ctm,
const SkIRect& bounds) const SK_OVERRIDE;
};
virtual bool asNewEffect(GrContext* context, const SkPaint&, const SkMatrix*, GrColor*,
- GrEffectRef**) const SK_OVERRIDE;
+ GrEffect**) const SK_OVERRIDE;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPerlinNoiseShader)
of GrGLEffect.
*/
-class GrEffectRef;
class GrGLEffect;
class GrGLCaps;
class GrDrawEffect;
class GrVertexEffect;
class SkString;
-/**
- * A Wrapper class for GrEffect. Its ref-count will track owners that may use effects to enqueue
- * new draw operations separately from ownership within a deferred drawing queue. When the
- * GrEffectRef ref count reaches zero the scratch GrResources owned by the effect can be recycled
- * in service of later draws. However, the deferred draw queue may still own direct references to
- * the underlying GrEffect.
- *
- * GrEffectRefs created by new are placed in a per-thread managed pool. The pool is destroyed when
- * the thread ends. Therefore, all dynamically allocated GrEffectRefs must be unreffed before thread
- * termination.
- */
-class GrEffectRef : public SkRefCnt {
-public:
- SK_DECLARE_INST_COUNT(GrEffectRef);
- virtual ~GrEffectRef();
-
- GrEffect* get() { return fEffect; }
- const GrEffect* get() const { return fEffect; }
-
- const GrEffect* operator-> () { return fEffect; }
- const GrEffect* operator-> () const { return fEffect; }
-
- void* operator new(size_t size);
- void operator delete(void* target);
-
- void* operator new(size_t size, void* placement) {
- return ::operator new(size, placement);
- }
- void operator delete(void* target, void* placement) {
- ::operator delete(target, placement);
- }
-
-private:
- friend class GrEffect; // to construct these
-
- explicit GrEffectRef(GrEffect* effect);
-
- GrEffect* fEffect;
-
- typedef SkRefCnt INHERITED;
-};
-
/** Provides custom vertex shader, fragment shader, uniform data for a particular stage of the
Ganesh shading pipeline.
Subclasses must have a function that produces a human-readable name:
static const char* Name();
GrEffect objects *must* be immutable: after being constructed, their fields may not change.
- GrEffect subclass objects should be created by factory functions that return GrEffectRef.
- There is no public way to wrap a GrEffect in a GrEffectRef. Thus, a factory should be a static
- member function of a GrEffect subclass.
-
- Because almost no code should ever handle a GrEffect directly outside of a GrEffectRef, we
- privately inherit from SkRefCnt to help prevent accidental direct ref'ing/unref'ing of effects.
-
- Dynamically allocated GrEffects and their corresponding GrEffectRefs are managed by a per-thread
- memory pool. The ref count of an effect must reach 0 before the thread terminates and the pool
- is destroyed. To create a static effect use the macro GR_CREATE_STATIC_EFFECT declared below.
+ Dynamically allocated GrEffects are managed by a per-thread memory pool. The ref count of an
+ effect must reach 0 before the thread terminates and the pool is destroyed. To create a static
+ effect use the macro GR_CREATE_STATIC_EFFECT declared below.
*/
-class GrEffect : private SkRefCnt {
+class GrEffect : public SkRefCnt {
public:
SK_DECLARE_INST_COUNT(GrEffect)
computed by the GrBackendEffectFactory:
effectA.getFactory().glEffectKey(effectA) == effectB.getFactory().glEffectKey(effectB).
*/
- bool isEqual(const GrEffectRef& other) const {
- return this->isEqual(*other.get());
+ bool isEqual(const GrEffect& other) const {
+ if (&this->getFactory() != &other.getFactory()) {
+ return false;
+ }
+ bool result = this->onIsEqual(other);
+#ifdef SK_DEBUG
+ if (result) {
+ this->assertEquality(other);
+ }
+#endif
+ return result;
}
/** Human-meaningful string to identify this effect; may be embedded
::operator delete(target, placement);
}
- /** These functions are used when recording effects into a deferred drawing queue. The inc call
- keeps the effect alive outside of GrEffectRef while allowing any resources owned by the
- effect to be returned to the cache for reuse. The dec call must balance the inc call. */
- void incDeferredRefCounts() const {
- this->ref();
- int count = fTextureAccesses.count();
- for (int t = 0; t < count; ++t) {
- fTextureAccesses[t]->getTexture()->incDeferredRefCount();
- }
- }
- void decDeferredRefCounts() const {
- int count = fTextureAccesses.count();
- for (int t = 0; t < count; ++t) {
- fTextureAccesses[t]->getTexture()->decDeferredRefCount();
- }
- this->unref();
- }
-
protected:
/**
* Subclasses call this from their constructor to register coordinate transformations. The
: fWillReadDstColor(false)
, fWillReadFragmentPosition(false)
, fWillUseInputColor(true)
- , fHasVertexCode(false)
- , fEffectRef(NULL) {}
+ , fHasVertexCode(false) {}
/** This should be called by GrEffect subclass factories. See the comment on AutoEffectUnref for
an example factory function. */
- static GrEffectRef* CreateEffectRef(GrEffect* effect) {
- if (NULL == effect->fEffectRef) {
- effect->fEffectRef = SkNEW_ARGS(GrEffectRef, (effect));
- } else {
- effect->fEffectRef->ref();
- }
- return effect->fEffectRef;
+ static GrEffect* CreateEffectRef(GrEffect* effect) {
+ return SkRef(effect);
}
- static const GrEffectRef* CreateEffectRef(const GrEffect* effect) {
+ static const GrEffect* CreateEffectRef(const GrEffect* effect) {
return CreateEffectRef(const_cast<GrEffect*>(effect));
}
- /** Used by GR_CREATE_STATIC_EFFECT below */
- static GrEffectRef* CreateStaticEffectRef(void* refStorage, GrEffect* effect) {
- SkASSERT(NULL == effect->fEffectRef);
- effect->fEffectRef = SkNEW_PLACEMENT_ARGS(refStorage, GrEffectRef, (effect));
- return effect->fEffectRef;
- }
-
-
/** Helper used in subclass factory functions to unref the effect after it has been wrapped in a
GrEffectRef. E.g.:
return CreateEffectRef(effect);
}
*/
- class AutoEffectUnref {
- public:
- AutoEffectUnref(GrEffect* effect) : fEffect(effect) { }
- ~AutoEffectUnref() { fEffect->unref(); }
- operator GrEffect*() { return fEffect; }
- private:
- GrEffect* fEffect;
- };
+ typedef SkAutoTUnref<GrEffect> AutoEffectUnref;
/** Helper for getting the GrEffect out of a GrEffectRef and down-casting to a GrEffect subclass
*/
void setWillNotUseInputColor() { fWillUseInputColor = false; }
private:
- bool isEqual(const GrEffect& other) const {
- if (&this->getFactory() != &other.getFactory()) {
- return false;
- }
- bool result = this->onIsEqual(other);
-#ifdef SK_DEBUG
- if (result) {
- this->assertEquality(other);
- }
-#endif
- return result;
- }
-
SkDEBUGCODE(void assertEquality(const GrEffect& other) const;)
/** Subclass implements this to support isEqual(). It will only be called if it is known that
getFactory()).*/
virtual bool onIsEqual(const GrEffect& other) const = 0;
- void EffectRefDestroyed() { fEffectRef = NULL; }
-
- friend class GrEffectRef; // to call EffectRefDestroyed()
- friend class GrEffectStage; // to rewrap GrEffect in GrEffectRef when restoring an effect-stage
- // from deferred state, to call isEqual on naked GrEffects, and
- // to inc/dec deferred ref counts.
friend class GrVertexEffect; // to set fHasVertexCode and build fVertexAttribTypes.
SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
bool fWillReadFragmentPosition;
bool fWillUseInputColor;
bool fHasVertexCode;
- GrEffectRef* fEffectRef;
typedef SkRefCnt INHERITED;
};
-inline GrEffectRef::GrEffectRef(GrEffect* effect) {
- SkASSERT(NULL != effect);
- effect->ref();
- fEffect = effect;
-}
+typedef GrEffect GrEffectRef;
/**
* This creates an effect outside of the effect memory pool. The effect's destructor will be called
- * at global destruction time. NAME will be the name of the created GrEffectRef.
+ * at global destruction time. NAME will be the name of the created GrEffect.
*/
#define GR_CREATE_STATIC_EFFECT(NAME, EFFECT_CLASS, ARGS) \
-enum { \
- k_##NAME##_EffectRefOffset = GR_CT_ALIGN_UP(sizeof(EFFECT_CLASS), 8), \
- k_##NAME##_StorageSize = k_##NAME##_EffectRefOffset + sizeof(GrEffectRef) \
-}; \
-static SkAlignedSStorage<k_##NAME##_StorageSize> g_##NAME##_Storage; \
-static void* NAME##_RefLocation = (char*)g_##NAME##_Storage.get() + k_##NAME##_EffectRefOffset; \
-static GrEffect* NAME##_Effect SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS);\
-static SkAutoTDestroy<GrEffect> NAME##_ad(NAME##_Effect); \
-static GrEffectRef* NAME(GrEffect::CreateStaticEffectRef(NAME##_RefLocation, NAME##_Effect)); \
-static SkAutoTDestroy<GrEffectRef> NAME##_Ref_ad(NAME)
+static SkAlignedSStorage<sizeof(EFFECT_CLASS)> g_##NAME##_Storage; \
+static GrEffect* NAME SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS); \
+static SkAutoTDestroy<GrEffect> NAME##_ad(NAME);
#endif
class GrEffectStage {
public:
- explicit GrEffectStage(const GrEffectRef* effectRef, int attrIndex0 = -1, int attrIndex1 = -1)
- : fEffectRef(SkRef(effectRef)) {
+ explicit GrEffectStage(const GrEffect* effect, int attrIndex0 = -1, int attrIndex1 = -1)
+ : fEffect(SkRef(effect)) {
fCoordChangeMatrixSet = false;
fVertexAttribIndices[0] = attrIndex0;
fVertexAttribIndices[1] = attrIndex1;
if (other.fCoordChangeMatrixSet) {
fCoordChangeMatrix = other.fCoordChangeMatrix;
}
- fEffectRef.reset(SkRef(other.fEffectRef.get()));
+ fEffect.reset(SkRef(other.fEffect.get()));
memcpy(fVertexAttribIndices, other.fVertexAttribIndices, sizeof(fVertexAttribIndices));
return *this;
}
bool operator== (const GrEffectStage& other) const {
- SkASSERT(NULL != fEffectRef.get());
- SkASSERT(NULL != other.fEffectRef.get());
+ SkASSERT(NULL != fEffect.get());
+ SkASSERT(NULL != other.fEffect.get());
if (!this->getEffect()->isEqual(*other.getEffect())) {
return false;
private:
bool fCoordChangeMatrixSet;
SkMatrix fCoordChangeMatrix;
- SkDEBUGCODE(mutable SkAutoTUnref<const GrEffectRef> fEffectRef;)
+ SkDEBUGCODE(mutable SkAutoTUnref<const GrEffect> fEffect;)
friend class GrEffectStage;
};
if (fCoordChangeMatrixSet) {
savedCoordChange->fCoordChangeMatrix = fCoordChangeMatrix;
}
- SkASSERT(NULL == savedCoordChange->fEffectRef.get());
- SkDEBUGCODE(SkRef(fEffectRef.get());)
- SkDEBUGCODE(savedCoordChange->fEffectRef.reset(fEffectRef.get());)
+ SkASSERT(NULL == savedCoordChange->fEffect.get());
+ SkDEBUGCODE(SkRef(fEffect.get());)
+ SkDEBUGCODE(savedCoordChange->fEffect.reset(fEffect.get());)
}
/**
if (fCoordChangeMatrixSet) {
fCoordChangeMatrix = savedCoordChange.fCoordChangeMatrix;
}
- SkASSERT(savedCoordChange.fEffectRef.get() == fEffectRef);
- SkDEBUGCODE(savedCoordChange.fEffectRef.reset(NULL);)
+ SkASSERT(savedCoordChange.fEffect.get() == fEffect);
+ SkDEBUGCODE(savedCoordChange.fEffect.reset(NULL);)
}
/**
}
}
- const GrEffect* getEffect() const { return fEffectRef.get()->get(); }
+ const GrEffect* getEffect() const { return fEffect.get(); }
const int* getVertexAttribIndices() const { return fVertexAttribIndices; }
- int getVertexAttribIndexCount() const { return fEffectRef->get()->numVertexAttribs(); }
+ int getVertexAttribIndexCount() const { return fEffect->numVertexAttribs(); }
private:
bool fCoordChangeMatrixSet;
SkMatrix fCoordChangeMatrix;
- SkAutoTUnref<const GrEffectRef> fEffectRef;
+ SkAutoTUnref<const GrEffect> fEffect;
int fVertexAttribIndices[2];
};
#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
class GrContext;
-class GrEffectRef;
+class GrEffect;
class GrTexture;
class GrEffectTestFactory : SkNoncopyable {
public:
- typedef GrEffectRef* (*CreateProc)(SkRandom*,
- GrContext*,
- const GrDrawTargetCaps& caps,
- GrTexture* dummyTextures[]);
+ typedef GrEffect* (*CreateProc)(SkRandom*,
+ GrContext*,
+ const GrDrawTargetCaps& caps,
+ GrTexture* dummyTextures[]);
GrEffectTestFactory(CreateProc createProc) {
fCreateProc = createProc;
GetFactories()->push_back(this);
}
- static GrEffectRef* CreateStage(SkRandom* random,
- GrContext* context,
- const GrDrawTargetCaps& caps,
- GrTexture* dummyTextures[]) {
+ static GrEffect* CreateStage(SkRandom* random,
+ GrContext* context,
+ const GrDrawTargetCaps& caps,
+ GrTexture* dummyTextures[]) {
uint32_t idx = random->nextRangeU(0, GetFactories()->count() - 1);
GrEffectTestFactory* factory = (*GetFactories())[idx];
return factory->fCreateProc(random, context, caps, dummyTextures);
*/
#define GR_DECLARE_EFFECT_TEST \
static GrEffectTestFactory gTestFactory; \
- static GrEffectRef* TestCreate(SkRandom*, \
- GrContext*, \
- const GrDrawTargetCaps&, \
- GrTexture* dummyTextures[2])
+ static GrEffect* TestCreate(SkRandom*, \
+ GrContext*, \
+ const GrDrawTargetCaps&, \
+ GrTexture* dummyTextures[2])
/** GrEffect subclasses should insert this macro in their implementation file. They must then
* also implement this static function:
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_EFFECT_TEST \
- static GrEffectRef* TestCreate(SkRandom*, \
- GrContext*, \
- const GrDrawTargetCaps&, \
- GrTexture* dummyTextures[2])
+ static GrEffect* TestCreate(SkRandom*, \
+ GrContext*, \
+ const GrDrawTargetCaps&, \
+ GrTexture* dummyTextures[2])
#define GR_DEFINE_EFFECT_TEST(X)
#endif // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
/**
* Appends an additional color effect to the color computation.
*/
- const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+ const GrEffect* addColorEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
SkASSERT(NULL != effect);
- if (!(*effect)->willUseInputColor()) {
+ if (!effect->willUseInputColor()) {
fColorStages.reset();
}
SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
/**
* Appends an additional coverage effect to the coverage computation.
*/
- const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+ const GrEffect* addCoverageEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
SkASSERT(NULL != effect);
- if (!(*effect)->willUseInputColor()) {
+ if (!effect->willUseInputColor()) {
fCoverageStages.reset();
}
SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
bool SkBitmapProcShader::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapProcShader)
- bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**)
+ bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**)
const SK_OVERRIDE;
class BitmapProcShaderContext : public SkShader::Context {
return SkUnPreMultiply::PMColorToColor(dst);
}
-GrEffectRef* SkColorFilter::asNewEffect(GrContext*) const {
+GrEffect* SkColorFilter::asNewEffect(GrContext*) const {
return NULL;
}
matrix.postTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
this->asNewEffect(&effect, srcTexture, matrix, bounds);
SkASSERT(effect);
- SkAutoUnref effectRef(effect);
GrPaint paint;
- paint.addColorEffect(effect);
+ paint.addColorEffect(effect)->unref();
context->drawRectToRect(paint, dstRect, srcRect);
SkAutoTUnref<GrTexture> resultTex(dst.detach());
return true;
}
-bool SkImageFilter::asNewEffect(GrEffectRef**, GrTexture*, const SkMatrix&, const SkIRect&) const {
+bool SkImageFilter::asNewEffect(GrEffect**, GrTexture*, const SkMatrix&, const SkIRect&) const {
return false;
}
#if SK_SUPPORT_GPU
virtual bool asNewEffect(GrContext* context, const SkPaint& paint, const SkMatrix* localMatrix,
- GrColor* grColor, GrEffectRef** grEffect) const SK_OVERRIDE {
+ GrColor* grColor, GrEffect** grEffect) const SK_OVERRIDE {
SkMatrix tmp = fProxyLocalMatrix;
if (localMatrix) {
tmp.preConcat(*localMatrix);
#else
virtual bool asNewEffect(GrContext* context, const SkPaint& paint, const SkMatrix* localMatrix,
- GrColor* grColor, GrEffectRef** grEffect) const SK_OVERRIDE {
+ GrColor* grColor, GrEffect** grEffect) const SK_OVERRIDE {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
}
#if SK_SUPPORT_GPU
-bool SkMaskFilter::asNewEffect(GrEffectRef** effect, GrTexture*, const SkMatrix&) const {
+bool SkMaskFilter::asNewEffect(GrEffect** effect, GrTexture*, const SkMatrix&) const {
return false;
}
#else
bool SkPictureShader::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader)
- bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**)
+ bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**)
const SK_OVERRIDE;
protected:
bool SkShader::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrixOrNull, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
return false;
}
bool SkColorShader::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
return false;
}
-bool SkXfermode::asNewEffect(GrEffectRef** effect, GrTexture* background) const {
+bool SkXfermode::asNewEffect(GrEffect** effect, GrTexture* background) const {
return false;
}
bool SkXfermode::AsNewEffectOrCoeff(SkXfermode* xfermode,
- GrEffectRef** effect,
+ GrEffect** effect,
Coeff* src,
Coeff* dst,
GrTexture* background) {
virtual bool asCoeff(Coeff* sc, Coeff* dc) const SK_OVERRIDE;
#if SK_SUPPORT_GPU
- virtual bool asNewEffect(GrEffectRef** effect,
+ virtual bool asNewEffect(GrEffect** effect,
GrTexture* background) const SK_OVERRIDE;
#endif
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
#if SK_SUPPORT_GPU
- virtual bool asNewEffect(GrEffectRef** effect, GrTexture* texture,
+ virtual bool asNewEffect(GrEffect** effect, GrTexture* texture,
const SkMatrix& matrix, const SkIRect& bounds) const SK_OVERRIDE;
#endif
}
#if SK_SUPPORT_GPU
-bool SkAlphaThresholdFilterImpl::asNewEffect(GrEffectRef** effect, GrTexture* texture,
+bool SkAlphaThresholdFilterImpl::asNewEffect(GrEffect** effect, GrTexture* texture,
const SkMatrix& in_matrix, const SkIRect&) const {
if (effect) {
GrContext* context = texture->getContext();
#endif
#if SK_SUPPORT_GPU
- virtual GrEffectRef* asNewEffect(GrContext*) const SK_OVERRIDE;
+ virtual GrEffect* asNewEffect(GrContext*) const SK_OVERRIDE;
#endif
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
return ModeColorFilterEffect::Create(color, mode);
}
-GrEffectRef* SkModeColorFilter::asNewEffect(GrContext*) const {
+GrEffect* SkModeColorFilter::asNewEffect(GrContext*) const {
if (SkXfermode::kDst_Mode != fMode) {
return ModeColorFilterEffect::Create(SkColor2GrColor(fColor), fMode);
}
}
};
-GrEffectRef* SkLumaColorFilter::asNewEffect(GrContext*) const {
+GrEffect* SkLumaColorFilter::asNewEffect(GrContext*) const {
return LumaColorFilterEffect::Create();
}
#endif
bool SkPerlinNoiseShader::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* externalLocalMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkASSERT(NULL != context);
*grColor = SkColor2GrColorJustAlpha(paint.getColor());
bool SkPerlinNoiseShader::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* externalLocalMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
virtual bool asComponentTable(SkBitmap* table) const SK_OVERRIDE;
#if SK_SUPPORT_GPU
- virtual GrEffectRef* asNewEffect(GrContext* context) const SK_OVERRIDE;
+ virtual GrEffect* asNewEffect(GrContext* context) const SK_OVERRIDE;
#endif
virtual void filterSpan(const SkPMColor src[], int count,
bool SkLinearGradient::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
virtual BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*) const SK_OVERRIDE;
virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
virtual bool asNewEffect(GrContext* context, const SkPaint& paint, const SkMatrix* localMatrix,
- GrColor* grColor, GrEffectRef** grEffect) const SK_OVERRIDE;
+ GrColor* grColor, GrEffect** grEffect) const SK_OVERRIDE;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLinearGradient)
bool SkRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
SkMatrix* matrix,
TileMode* xy) const SK_OVERRIDE;
virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
- virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**) const SK_OVERRIDE;
+ virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**) const SK_OVERRIDE;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRadialGradient)
bool SkSweepGradient::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
- virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffectRef**)
+ virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor*, GrEffect**)
const SK_OVERRIDE;
SK_TO_STRING_OVERRIDE()
bool SkTwoPointConicalGradient::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
TileMode* xy) const;
virtual SkShader::GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
virtual bool asNewEffect(GrContext*, const SkPaint&, const SkMatrix*, GrColor* grColor,
- GrEffectRef**) const SK_OVERRIDE;
+ GrEffect**) const SK_OVERRIDE;
virtual bool isOpaque() const SK_OVERRIDE;
SkScalar getCenterX1() const { return SkPoint::Distance(fCenter1, fCenter2); }
#include "SkGradientShaderPriv.h"
-class GrEffectRef;
+class GrEffect;
class SkTwoPointConicalGradient;
namespace Gr2PtConicalGradientEffect {
* Creates an effect that produces a two point conical gradient based on the
* shader passed in.
*/
- GrEffectRef* Create(GrContext* ctx, const SkTwoPointConicalGradient& shader,
- SkShader::TileMode tm, const SkMatrix* localMatrix);
+ GrEffect* Create(GrContext* ctx, const SkTwoPointConicalGradient& shader,
+ SkShader::TileMode tm, const SkMatrix* localMatrix);
};
#endif
bool SkTwoPointRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
- GrEffectRef** grEffect) const {
+ GrEffect** grEffect) const {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
TileMode* xy) const SK_OVERRIDE;
virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
virtual bool asNewEffect(GrContext* context, const SkPaint&, const SkMatrix*, GrColor*,
- GrEffectRef**) const SK_OVERRIDE;
+ GrEffect**) const SK_OVERRIDE;
virtual size_t contextSize() const SK_OVERRIDE;
/// the color / coverage distinction.
////
- const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+ const GrEffect* addColorEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
SkASSERT(NULL != effect);
SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
return effect;
}
- const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
+ const GrEffect* addCoverageEffect(const GrEffect* effect, int attr0 = -1, int attr1 = -1) {
SkASSERT(NULL != effect);
SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
return effect;
* Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
*/
void addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
- this->addColorEffect(effect)->unref();
+ this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
}
void addCoverageTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
- this->addCoverageEffect(effect)->unref();
+ this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
}
void addColorTextureEffect(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
- this->addColorEffect(effect)->unref();
+ this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
}
void addCoverageTextureEffect(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
- this->addCoverageEffect(effect)->unref();
+ this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
}
/**
///////////////////////////////////////////////////////////////////////////////
-GrEffectRef::~GrEffectRef() {
- SkASSERT(this->unique());
- fEffect->EffectRefDestroyed();
- fEffect->unref();
-}
-
-void* GrEffectRef::operator new(size_t size) {
- return GrEffect_Globals::GetTLS()->allocate(size);
-}
-
-void GrEffectRef::operator delete(void* target) {
- GrEffect_Globals::GetTLS()->release(target);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-GrEffect::~GrEffect() {
- SkASSERT(NULL == fEffectRef);
-}
+GrEffect::~GrEffect() {}
const char* GrEffect::name() const {
return this->getFactory().name();
#include "effects/GrSimpleTextureEffect.h"
void GrPaint::addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
- this->addColorEffect(effect)->unref();
+ this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
}
void GrPaint::addCoverageTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
- this->addCoverageEffect(effect)->unref();
+ this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix))->unref();
}
void GrPaint::addColorTextureEffect(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
- this->addColorEffect(effect)->unref();
+ this->addColorEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
}
void GrPaint::addCoverageTextureEffect(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
- this->addCoverageEffect(effect)->unref();
+ this->addCoverageEffect(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
}
bool GrPaint::isOpaque() const {
* Bounding geometry is rendered and the effect computes coverage based on the fragment's
* position relative to the dashed line.
*/
- GrEffectRef* Create(GrEffectEdgeType edgeType, const SkPathEffect::DashInfo& info,
- SkScalar strokeWidth, DashCap cap);
+ GrEffect* Create(GrEffectEdgeType edgeType, const SkPathEffect::DashInfo& info,
+ SkScalar strokeWidth, DashCap cap);
}
#endif
#include "GrTypes.h"
#include "GrTypesPriv.h"
-class GrEffectRef;
+class GrEffect;
namespace GrDitherEffect {
/**
* Creates an effect that dithers the resulting color to an RGBA8 framebuffer
*/
- GrEffectRef* Create();
+ GrEffect* Create();
};
#endif
#include "GrTypes.h"
#include "GrTypesPriv.h"
-class GrEffectRef;
+class GrEffect;
struct SkRect;
namespace GrOvalEffect {
/**
* Creates an effect that performs clipping against an oval.
*/
- GrEffectRef* Create(GrEffectEdgeType, const SkRect&);
+ GrEffect* Create(GrEffectEdgeType, const SkRect&);
};
#endif
#include "GrTypes.h"
#include "GrTypesPriv.h"
-class GrEffectRef;
+class GrEffect;
class SkRRect;
namespace GrRRectEffect {
* Creates an effect that performs anti-aliased clipping against a SkRRect. It doesn't support
* all varieties of SkRRect so the caller must check for a NULL return.
*/
- GrEffectRef* Create(GrEffectEdgeType, const SkRRect&);
+ GrEffect* Create(GrEffectEdgeType, const SkRRect&);
};
#endif
class YUVtoRGBEffect : public GrEffect {
public:
- static GrEffectRef* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture) {
+ static GrEffect* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture) {
AutoEffectUnref effect(SkNEW_ARGS(YUVtoRGBEffect, (yTexture, uTexture, vTexture)));
return CreateEffectRef(effect);
}
#ifndef GrYUVtoRGBEffect_DEFINED
#define GrYUVtoRGBEffect_DEFINED
-class GrEffectRef;
+class GrEffect;
class GrTexture;
namespace GrYUVtoRGBEffect {
/**
* Creates an effect that performs color conversion from YUV to RGB
*/
- GrEffectRef* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture);
+ GrEffect* Create(GrTexture* yTexture, GrTexture* uTexture, GrTexture* vTexture);
};
#endif
*this->caps(),
dummyTextures));
SkASSERT(effect);
- int numAttribs = (*effect)->numVertexAttribs();
+ int numAttribs = effect->numVertexAttribs();
// If adding this effect would exceed the max attrib count then generate a
// new random effect.
// If adding this effect would exceed the max texture coord set count then generate a
// new random effect.
- if (useFixedFunctionTexturing && !(*effect)->hasVertexCode()) {
- int numTransforms = (*effect)->numTransforms();
+ if (useFixedFunctionTexturing && !effect->hasVertexCode()) {
+ int numTransforms = effect->numTransforms();
if (currTextureCoordSet + numTransforms > this->glCaps().maxFixedFunctionTextureCoords()) {
continue;
}
currTextureCoordSet += numTransforms;
}
- useFixedFunctionTexturing = useFixedFunctionTexturing && !(*effect)->hasVertexCode();
+ useFixedFunctionTexturing = useFixedFunctionTexturing && !effect->hasVertexCode();
for (int i = 0; i < numAttribs; ++i) {
attribIndices[i] = currAttribIndex++;
SkAutoTUnref<GrEffectRef> grEffect(cf->asNewEffect(grContext));
GrColor color = test.inputColor;
uint32_t components = test.inputComponents;
- grEffect->get()->getConstantColorComponents(&color, &components);
+ grEffect->getConstantColorComponents(&color, &components);
REPORTER_ASSERT(reporter, filterColor(color, components) == test.outputColor);
REPORTER_ASSERT(reporter, test.outputComponents == components);
projects / platform / upstream / libSkiaSharp.git / commitdiff