// copy android verts to our vertex buffer
if (antiAlias) {
- GrAssert(sizeof(ColorVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(ColorVertex) == drawState->getVertexSize());
ColorVertex* outVert = reinterpret_cast<ColorVertex*>(geo.vertices());
android::uirenderer::AlphaVertex* inVert =
reinterpret_cast<android::uirenderer::AlphaVertex*>(vertices.getBuffer());
break;
case SkPath::kQuad_Verb:
case SkPath::kCubic_Verb:
- GrAssert(!"Curves not supported!");
+ SkASSERT(!"Curves not supported!");
default:
// Unhandled cases
- GrAssert(false);
+ SkASSERT(false);
}
}
lastPt [1] += dir;
break;
case SkPaint::kRound_Cap:
- GrAssert(!"Round caps not supported!");
+ SkASSERT(!"Round caps not supported!");
default: // No cap
break;
}
}
- GrAssert(vCount <= maxVertexCount);
- GrAssert(iCount <= maxIndexCount);
+ SkASSERT(vCount <= maxVertexCount);
+ SkASSERT(iCount <= maxIndexCount);
if (vCount > 0) {
target->drawIndexed(kTriangles_GrPrimitiveType,
// atomic inc returns the old value not the incremented value. So we add
// 1 to the returned value.
int32_t id = sk_atomic_inc(&fCurrEffectClassID) + 1;
- GrAssert(id < (1 << kClassIDBits));
+ SkASSERT(id < (1 << kClassIDBits));
return static_cast<EffectKey>(id);
}
*/
static inline GrColor GrColorPackRGBA(unsigned r, unsigned g,
unsigned b, unsigned a) {
- GrAssert((uint8_t)r == r);
- GrAssert((uint8_t)g == g);
- GrAssert((uint8_t)b == b);
- GrAssert((uint8_t)a == a);
+ SkASSERT((uint8_t)r == r);
+ SkASSERT((uint8_t)g == g);
+ SkASSERT((uint8_t)b == b);
+ SkASSERT((uint8_t)a == a);
return (r << GrColor_SHIFT_R) |
(g << GrColor_SHIFT_G) |
(b << GrColor_SHIFT_B) |
};
static inline char GrColorComponentFlagToChar(GrColorComponentFlags component) {
- GrAssert(GrIsPow2(component));
+ SkASSERT(GrIsPow2(component));
switch (component) {
case kR_GrColorComponentFlag:
return 'r';
}
static inline uint32_t GrPixelConfigComponentMask(GrPixelConfig config) {
- GrAssert(config >= 0 && config < kGrPixelConfigCnt);
+ SkASSERT(config >= 0 && config < kGrPixelConfigCnt);
static const uint32_t kFlags[] = {
0, // kUnknown_GrPixelConfig
kA_GrColorComponentFlag, // kAlpha_8_GrPixelConfig
/**
* Prettier forms of the above macros.
*/
-#define GrAssert(COND) GR_DEBUGASSERT(COND)
#define GrAlwaysAssert(COND) GR_ALWAYSASSERT(COND)
/**
*/
inline void GrCrash() { GrAlwaysAssert(false); }
inline void GrCrash(const char* msg) { GrPrintf(msg); GrAlwaysAssert(false); }
-inline void GrDebugCrash() { GrAssert(false); }
-inline void GrDebugCrash(const char* msg) { GrPrintf(msg); GrAssert(false); }
+inline void GrDebugCrash() { SkASSERT(false); }
+inline void GrDebugCrash(const char* msg) { GrPrintf(msg); SkASSERT(false); }
/**
* GR_DEBUGCODE compiles the code X in debug builds only
* Initializes by pre-concat'ing the context's current matrix with the preConcat param.
*/
void setPreConcat(GrContext* context, const SkMatrix& preConcat, GrPaint* paint = NULL) {
- GrAssert(NULL != context);
+ SkASSERT(NULL != context);
this->restore();
* update a paint but the matrix cannot be inverted.
*/
bool setIdentity(GrContext* context, GrPaint* paint = NULL) {
- GrAssert(NULL != context);
+ SkASSERT(NULL != context);
this->restore();
AutoClip(GrContext* context, InitialClip initialState)
: fContext(context) {
- GrAssert(kWideOpen_InitialClip == initialState);
+ SkASSERT(kWideOpen_InitialClip == initialState);
fNewClipData.fClipStack = &fNewClipStack;
fOldClip = context->getClip();
, fAutoRT(ctx, rt) {
fAutoMatrix.setIdentity(ctx);
// should never fail with no paint param.
- GrAssert(fAutoMatrix.succeeded());
+ SkASSERT(fAutoMatrix.succeeded());
}
private:
// The cache also has a ref which we are lending to the caller of detach(). When the caller
// lets go of the ref and the ref count goes to 0 internal_dispose will see this flag is
// set and re-ref the texture, thereby restoring the cache's ref.
- GrAssert(texture->getRefCnt() > 1);
+ SkASSERT(texture->getRefCnt() > 1);
texture->setFlag((GrTextureFlags) GrTexture::kReturnToCache_FlagBit);
texture->unref();
- GrAssert(NULL != texture->getCacheEntry());
+ SkASSERT(NULL != texture->getCacheEntry());
return texture;
}
GrDrawEffect(const GrEffectStage& stage, bool explicitLocalCoords)
: fEffectStage(&stage)
, fExplicitLocalCoords(explicitLocalCoords) {
- GrAssert(NULL != fEffectStage);
- GrAssert(NULL != fEffectStage->getEffect());
+ SkASSERT(NULL != fEffectStage);
+ SkASSERT(NULL != fEffectStage->getEffect());
}
const GrEffectRef* effect() const { return fEffectStage->getEffect(); }
/** Useful for effects that want to insert a texture matrix that is implied by the texture
dimensions */
static inline SkMatrix MakeDivByTextureWHMatrix(const GrTexture* texture) {
- GrAssert(NULL != texture);
+ SkASSERT(NULL != texture);
SkMatrix mat;
mat.setIDiv(texture->width(), texture->height());
return mat;
/** Used by GR_CREATE_STATIC_EFFECT below */
static GrEffectRef* CreateStaticEffectRef(void* refStorage, GrEffect* effect) {
- GrAssert(NULL == effect->fEffectRef);
+ SkASSERT(NULL == effect->fEffectRef);
effect->fEffectRef = SkNEW_PLACEMENT_ARGS(refStorage, GrEffectRef, (effect));
return effect->fEffectRef;
}
bool result = this->onIsEqual(other);
#if GR_DEBUG
if (result) {
- GrAssert(this->numTextures() == other.numTextures());
+ SkASSERT(this->numTextures() == other.numTextures());
for (int i = 0; i < this->numTextures(); ++i) {
- GrAssert(*fTextureAccesses[i] == *other.fTextureAccesses[i]);
+ SkASSERT(*fTextureAccesses[i] == *other.fTextureAccesses[i]);
}
}
#endif
};
inline GrEffectRef::GrEffectRef(GrEffect* effect) {
- GrAssert(NULL != effect);
+ SkASSERT(NULL != effect);
effect->ref();
fEffect = effect;
}
}
bool operator== (const GrEffectStage& other) const {
- GrAssert(NULL != fEffectRef.get());
- GrAssert(NULL != other.fEffectRef.get());
+ SkASSERT(NULL != fEffectRef.get());
+ SkASSERT(NULL != other.fEffectRef.get());
if (!(*this->getEffect())->isEqual(*other.getEffect())) {
return false;
if (fCoordChangeMatrixSet) {
savedCoordChange->fCoordChangeMatrix = fCoordChangeMatrix;
}
- GrAssert(NULL == savedCoordChange->fEffectRef.get());
+ SkASSERT(NULL == savedCoordChange->fEffectRef.get());
GR_DEBUGCODE(SkRef(fEffectRef.get());)
GR_DEBUGCODE(savedCoordChange->fEffectRef.reset(fEffectRef.get());)
}
if (fCoordChangeMatrixSet) {
fCoordChangeMatrix = savedCoordChange.fCoordChangeMatrix;
}
- GrAssert(savedCoordChange.fEffectRef.get() == fEffectRef);
+ SkASSERT(savedCoordChange.fEffectRef.get() == fEffectRef);
GR_DEBUGCODE(savedCoordChange.fEffectRef.reset(NULL);)
}
}
void saveFrom(const GrEffectStage& stage) {
- GrAssert(!fInitialized);
- GrAssert(NULL != stage.fEffectRef.get());
+ SkASSERT(!fInitialized);
+ SkASSERT(NULL != stage.fEffectRef.get());
stage.fEffectRef->get()->incDeferredRefCounts();
fEffect = stage.fEffectRef->get();
fCoordChangeMatrixSet = stage.fCoordChangeMatrixSet;
}
void restoreTo(GrEffectStage* stage) const {
- GrAssert(fInitialized);
+ SkASSERT(fInitialized);
stage->fEffectRef.reset(GrEffect::CreateEffectRef(fEffect));
stage->fCoordChangeMatrixSet = fCoordChangeMatrixSet;
if (fCoordChangeMatrixSet) {
* Appends an additional color effect to the color computation.
*/
const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
- GrAssert(NULL != effect);
+ SkASSERT(NULL != effect);
SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
return effect;
}
* Appends an additional coverage effect to the coverage computation.
*/
const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
- GrAssert(NULL != effect);
+ SkASSERT(NULL != effect);
SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
return effect;
}
friend class GrTexture;
// called by ~GrTexture to remove the non-ref'ed back ptr.
void owningTextureDestroyed() {
- GrAssert(NULL != fTexture);
+ SkASSERT(NULL != fTexture);
fTexture = NULL;
}
void setCacheEntry(GrResourceEntry* cacheEntry) { fCacheEntry = cacheEntry; }
GrResourceEntry* getCacheEntry() { return fCacheEntry; }
- void incDeferredRefCount() const { GrAssert(fDeferredRefCount >= 0); ++fDeferredRefCount; }
- void decDeferredRefCount() const { GrAssert(fDeferredRefCount > 0); --fDeferredRefCount; }
+ void incDeferredRefCount() const { SkASSERT(fDeferredRefCount >= 0); ++fDeferredRefCount; }
+ void decDeferredRefCount() const { SkASSERT(fDeferredRefCount > 0); --fDeferredRefCount; }
protected:
/**
SkIntToScalar(this->height())); }
GrSurfaceOrigin origin() const {
- GrAssert(kTopLeft_GrSurfaceOrigin == fDesc.fOrigin || kBottomLeft_GrSurfaceOrigin == fDesc.fOrigin);
+ SkASSERT(kTopLeft_GrSurfaceOrigin == fDesc.fOrigin || kBottomLeft_GrSurfaceOrigin == fDesc.fOrigin);
return fDesc.fOrigin;
}
return thisRT == other->asRenderTarget();
} else {
const GrTexture* thisTex = this->asTexture();
- GrAssert(NULL != thisTex); // We must be one or the other
+ SkASSERT(NULL != thisTex); // We must be one or the other
return thisTex == other->asTexture();
}
}
GLSL code generation. */
virtual EffectKey glEffectKey(const GrDrawEffect& drawEffect,
const GrGLCaps& caps) const SK_OVERRIDE {
- GrAssert(kIllegalEffectClassID != fEffectClassID);
+ SkASSERT(kIllegalEffectClassID != fEffectClassID);
EffectKey effectKey = GLEffect::GenKey(drawEffect, caps);
EffectKey textureKey = GLEffect::GenTextureKey(drawEffect, caps);
EffectKey attribKey = GLEffect::GenAttribKey(drawEffect);
#if GR_DEBUG
static const EffectKey kIllegalIDMask = (uint16_t) (~((1U << kEffectKeyBits) - 1));
- GrAssert(!(kIllegalIDMask & effectKey));
+ SkASSERT(!(kIllegalIDMask & effectKey));
static const EffectKey kIllegalTextureKeyMask = (uint16_t) (~((1U << kTextureKeyBits) - 1));
- GrAssert(!(kIllegalTextureKeyMask & textureKey));
+ SkASSERT(!(kIllegalTextureKeyMask & textureKey));
static const EffectKey kIllegalAttribKeyMask = (uint16_t) (~((1U << kAttribKeyBits) - 1));
- GrAssert(!(kIllegalAttribKeyMask & textureKey));
+ SkASSERT(!(kIllegalAttribKeyMask & textureKey));
#endif
return fEffectClassID | (attribKey << (kEffectKeyBits+kTextureKeyBits)) |
(textureKey << kEffectKeyBits) | effectKey;
* only.
*/
GrFixed normalizeFixedX(GrFixed x) const {
- GrAssert(GrIsPow2(fDesc.fWidth));
+ SkASSERT(GrIsPow2(fDesc.fWidth));
return x >> fShiftFixedX;
}
GrFixed normalizeFixedY(GrFixed y) const {
- GrAssert(GrIsPow2(fDesc.fHeight));
+ SkASSERT(GrIsPow2(fDesc.fHeight));
return y >> fShiftFixedY;
}
bool operator== (const GrTextureAccess& other) const {
#if GR_DEBUG
// below assumes all chars in fSwizzle are initialized even if string is < 4 chars long.
- GrAssert(memcmp(fSwizzle, other.fSwizzle, sizeof(fSwizzle)-1) ==
+ SkASSERT(memcmp(fSwizzle, other.fSwizzle, sizeof(fSwizzle)-1) ==
strcmp(fSwizzle, other.fSwizzle));
#endif
return fParams == other.fParams &&
* divide, rounding up
*/
static inline int32_t GrIDivRoundUp(int x, int y) {
- GrAssert(y > 0);
+ SkASSERT(y > 0);
return (x + (y-1)) / y;
}
static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) {
}
static inline int GrNextPow2(int n) {
- GrAssert(n >= 0); // this impl only works for non-neg.
+ SkASSERT(n >= 0); // this impl only works for non-neg.
return n ? (1 << (32 - SkCLZ(n - 1))) : 1;
}
#if GR_DEBUG
static inline int16_t GrToS16(intptr_t x) {
- GrAssert((int16_t)x == x);
+ SkASSERT((int16_t)x == x);
return (int16_t)x;
}
* Return the number of bytes-per-pixel for the specified mask format.
*/
static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
- GrAssert((unsigned)format <= 2);
+ SkASSERT((unsigned)format <= 2);
// kA8 (0) -> 1
// kA565 (1) -> 2
// kA888 (2) -> 4
* Initialize the cache ID to a domain and key.
*/
GrCacheID(Domain domain, const Key& key) {
- GrAssert(kInvalid_Domain != domain);
+ SkASSERT(kInvalid_Domain != domain);
this->reset(domain, key);
}
/** Has this been initialized to a valid domain */
bool isValid() const { return kInvalid_Domain != fDomain; }
- const Key& getKey() const { GrAssert(this->isValid()); return fKey; }
- Domain getDomain() const { GrAssert(this->isValid()); return fDomain; }
+ const Key& getKey() const { SkASSERT(this->isValid()); return fKey; }
+ Domain getDomain() const { SkASSERT(this->isValid()); return fDomain; }
/** Creates a new unique ID domain. */
static Domain GenerateDomain();
* Gets the vector size of the SLType. Returns -1 for void, matrices, and samplers.
*/
static inline int GrSLTypeVectorCount(GrSLType type) {
- GrAssert(type >= 0 && type < static_cast<GrSLType>(kGrSLTypeCount));
+ SkASSERT(type >= 0 && type < static_cast<GrSLType>(kGrSLTypeCount));
static const int kCounts[] = { -1, 1, 2, 3, 4, -1, -1, -1 };
return kCounts[type];
/** Return the type enum for a vector of floats of length n (1..4),
e.g. 1 -> kFloat_GrSLType, 2 -> kVec2_GrSLType, ... */
static inline GrSLType GrSLFloatVectorType(int count) {
- GrAssert(count > 0 && count <= 4);
+ SkASSERT(count > 0 && count <= 4);
return (GrSLType)(count);
GR_STATIC_ASSERT(kFloat_GrSLType == 1);
* Returns the vector size of the type.
*/
static inline int GrVertexAttribTypeVectorCount(GrVertexAttribType type) {
- GrAssert(type >= 0 && type < kGrVertexAttribTypeCount);
+ SkASSERT(type >= 0 && type < kGrVertexAttribTypeCount);
static const int kCounts[] = { 1, 2, 3, 4, 4 };
return kCounts[type];
* Returns the size of the attrib type in bytes.
*/
static inline size_t GrVertexAttribTypeSize(GrVertexAttribType type) {
- GrAssert(type >= 0 && type < kGrVertexAttribTypeCount);
+ SkASSERT(type >= 0 && type < kGrVertexAttribTypeCount);
static const size_t kSizes[] = {
sizeof(float), // kFloat_GrVertexAttribType
2*sizeof(float), // kVec2f_GrVertexAttribType
kLastFixedFunction_GrVertexAttribBinding + 1;
static inline int GrFixedFunctionVertexAttribVectorCount(GrVertexAttribBinding binding) {
- GrAssert(binding >= 0 && binding < kGrFixedFunctionVertexAttribBindingCnt);
+ SkASSERT(binding >= 0 && binding < kGrFixedFunctionVertexAttribBindingCnt);
static const int kVecCounts[] = { 2, 2, 4, 4 };
return kVecCounts[binding];
class GrGLExtensions {
public:
bool init(GrGLBinding binding, const GrGLInterface* iface) {
- GrAssert(binding & iface->fBindingsExported);
+ SkASSERT(binding & iface->fBindingsExported);
return this->init(binding, iface->fGetString, iface->fGetStringi, iface->fGetIntegerv);
}
/**
virtual void makeCurrent() const = 0;
bool hasExtension(const char* extensionName) const {
- GrAssert(NULL != fGL);
+ SkASSERT(NULL != fGL);
return fExtensions.has(extensionName);
}
} else {
dstColor = builder->dstColor();
}
- GrAssert(NULL != dstColor);
+ SkASSERT(NULL != dstColor);
// We don't try to optimize for this case at all
if (NULL == inputColor) {
// undo the translate of p0 to the origin.
*c = center + p0;
}
- GrAssert(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY));
+ SkASSERT(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY));
}
static void compute_vectors(SegmentArray* segments,
return false;
}
// check whether m reverses the orientation
- GrAssert(!m.hasPerspective());
+ SkASSERT(!m.hasPerspective());
SkScalar det2x2 = SkScalarMul(m.get(SkMatrix::kMScaleX), m.get(SkMatrix::kMScaleY)) -
SkScalarMul(m.get(SkMatrix::kMSkewX), m.get(SkMatrix::kMSkewY));
if (det2x2 < 0) {
if (!arg.succeeded()) {
return false;
}
- GrAssert(sizeof(QuadVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(QuadVertex) == drawState->getVertexSize());
verts = reinterpret_cast<QuadVertex*>(arg.vertices());
idxs = reinterpret_cast<uint16_t*>(arg.indices());
for (int i = 2; i < vCount; ++i) {
actualBounds.growToInclude(verts[i].fPos.fX, verts[i].fPos.fY);
}
- GrAssert(tolDevBounds.contains(actualBounds));
+ SkASSERT(tolDevBounds.contains(actualBounds));
#endif
int vOffset = 0;
static bool tested;
if (!tested) {
tested = true;
- GrAssert(get_float_exp(0.25f) == -2);
- GrAssert(get_float_exp(0.3f) == -2);
- GrAssert(get_float_exp(0.5f) == -1);
- GrAssert(get_float_exp(1.f) == 0);
- GrAssert(get_float_exp(2.f) == 1);
- GrAssert(get_float_exp(2.5f) == 1);
- GrAssert(get_float_exp(8.f) == 3);
- GrAssert(get_float_exp(100.f) == 6);
- GrAssert(get_float_exp(1000.f) == 9);
- GrAssert(get_float_exp(1024.f) == 10);
- GrAssert(get_float_exp(3000000.f) == 21);
+ SkASSERT(get_float_exp(0.25f) == -2);
+ SkASSERT(get_float_exp(0.3f) == -2);
+ SkASSERT(get_float_exp(0.5f) == -1);
+ SkASSERT(get_float_exp(1.f) == 0);
+ SkASSERT(get_float_exp(2.f) == 1);
+ SkASSERT(get_float_exp(2.5f) == 1);
+ SkASSERT(get_float_exp(8.f) == 3);
+ SkASSERT(get_float_exp(100.f) == 6);
+ SkASSERT(get_float_exp(1000.f) == 9);
+ SkASSERT(get_float_exp(1024.f) == 10);
+ SkASSERT(get_float_exp(3000000.f) == 21);
}
#endif
const int* iptr = (const int*)&x;
if (SkIRect::Intersects(devClipBounds, ibounds)) {
int subdiv = num_quad_subdivs(devPts);
- GrAssert(subdiv >= -1);
+ SkASSERT(subdiv >= -1);
if (-1 == subdiv) {
SkPoint* pts = lines->push_back_n(4);
pts[0] = devPts[0];
bounds.roundOut(&ibounds);
if (SkIRect::Intersects(devClipBounds, ibounds)) {
int subdiv = num_quad_subdivs(qInDevSpace);
- GrAssert(subdiv >= -1);
+ SkASSERT(subdiv >= -1);
if (-1 == subdiv) {
SkPoint* pts = lines->push_back_n(4);
// lines should always be in device coords
void bloat_quad(const SkPoint qpts[3], const SkMatrix* toDevice,
const SkMatrix* toSrc, BezierVertex verts[kVertsPerQuad],
SkRect* devBounds) {
- GrAssert(!toDevice == !toSrc);
+ SkASSERT(!toDevice == !toSrc);
// original quad is specified by tri a,b,c
SkPoint a = qpts[0];
SkPoint b = qpts[1];
cb -= c;
// We should have already handled degenerates
- GrAssert(ab.length() > 0 && cb.length() > 0);
+ SkASSERT(ab.length() > 0 && cb.length() > 0);
ab.normalize();
SkVector abN;
scale = SkMaxScalar(scale, SkScalarAbs(l[i]));
scale = SkMaxScalar(scale, SkScalarAbs(m[i]));
}
- GrAssert(scale > 0);
+ SkASSERT(scale > 0);
scale /= 10.0f;
k[0] /= scale;
k[1] /= scale;
const SkMatrix* toSrc,
BezierVertex** vert,
SkRect* devBounds) {
- GrAssert(subdiv >= 0);
+ SkASSERT(subdiv >= 0);
if (subdiv) {
SkPoint newP[5];
SkChopQuadAtHalf(p, newP);
int vertCnt = kVertsPerLineSeg * lineCnt;
target->drawState()->setVertexAttribs<gHairlineLineAttribs>(SK_ARRAY_COUNT(gHairlineLineAttribs));
- GrAssert(sizeof(LineVertex) == target->getDrawState().getVertexSize());
+ SkASSERT(sizeof(LineVertex) == target->getDrawState().getVertexSize());
if (!arg->set(target, vertCnt, 0)) {
return false;
int vertCnt = kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt;
target->drawState()->setVertexAttribs<gHairlineBezierAttribs>(SK_ARRAY_COUNT(gHairlineBezierAttribs));
- GrAssert(sizeof(BezierVertex) == target->getDrawState().getVertexSize());
+ SkASSERT(sizeof(BezierVertex) == target->getDrawState().getVertexSize());
if (!arg->set(target, vertCnt, 0)) {
return false;
int unsubdivQuadCnt = quads.count() / 3;
for (int i = 0; i < unsubdivQuadCnt; ++i) {
- GrAssert(qSubdivs[i] >= 0);
+ SkASSERT(qSubdivs[i] >= 0);
add_quads(&quads[3*i], qSubdivs[i], toDevice, toSrc, &verts, devBounds);
}
intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
size_t vsize = drawState->getVertexSize();
- GrAssert(sizeof(GrPoint) + sizeof(GrColor) == vsize);
+ SkASSERT(sizeof(GrPoint) + sizeof(GrColor) == vsize);
GrPoint* fan0Pos = reinterpret_cast<GrPoint*>(verts);
GrPoint* fan1Pos = reinterpret_cast<GrPoint*>(verts + 4 * vsize);
SkScalar newWidth = SkScalarHalf(rect.width() * vec[0].length()) + SK_ScalarHalf;
SkScalar newHeight = SkScalarHalf(rect.height() * vec[1].length()) + SK_ScalarHalf;
drawState->setVertexAttribs<gAARectVertexAttribs>(SK_ARRAY_COUNT(gAARectVertexAttribs));
- GrAssert(sizeof(RectVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(RectVertex) == drawState->getVertexSize());
GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
if (!geo.succeeded()) {
SkASSERT(combinedMatrix.rectStaysRect());
drawState->setVertexAttribs<gAAAARectVertexAttribs>(SK_ARRAY_COUNT(gAAAARectVertexAttribs));
- GrAssert(sizeof(AARectVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(AARectVertex) == drawState->getVertexSize());
GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
if (!geo.succeeded()) {
intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
size_t vsize = drawState->getVertexSize();
- GrAssert(sizeof(GrPoint) + sizeof(GrColor) == vsize);
+ SkASSERT(sizeof(GrPoint) + sizeof(GrColor) == vsize);
// We create vertices for four nested rectangles. There are two ramps from 0 to full
// coverage, one on the exterior of the stroke and the other on the interior.
size_t fBytesTotal;
static Block* Create(size_t size, Block* next) {
- GrAssert(size >= GrAllocPool_MIN_BLOCK_SIZE);
+ SkASSERT(size >= GrAllocPool_MIN_BLOCK_SIZE);
Block* block = (Block*)GrMalloc(sizeof(Block) + size);
block->fNext = next;
}
void* alloc(size_t bytes) {
- GrAssert(bytes <= fBytesFree);
+ SkASSERT(bytes <= fBytesFree);
fBytesFree -= bytes;
void* ptr = fPtr;
fPtr += bytes;
}
size_t release(size_t bytes) {
- GrAssert(bytes > 0);
+ SkASSERT(bytes > 0);
size_t free = GrMin(bytes, fBytesTotal - fBytesFree);
fBytesFree += free;
fPtr -= free;
count += 1;
block = block->fNext;
}
- GrAssert(fBlocksAllocated == count);
+ SkASSERT(fBlocksAllocated == count);
}
#endif
fItemsPerBlock(itemsPerBlock),
fOwnFirstBlock(NULL == initialBlock),
fCount(0) {
- GrAssert(itemsPerBlock > 0);
+ SkASSERT(itemsPerBlock > 0);
fBlockSize = fItemSize * fItemsPerBlock;
fBlocks.push_back() = initialBlock;
GR_DEBUGCODE(if (!fOwnFirstBlock) {*((char*)initialBlock+fBlockSize-1)='a';} );
* access last item, only call if count() != 0
*/
void* back() {
- GrAssert(fCount);
+ SkASSERT(fCount);
return (*this)[fCount-1];
}
* access last item, only call if count() != 0
*/
const void* back() const {
- GrAssert(fCount);
+ SkASSERT(fCount);
return (*this)[fCount-1];
}
* access item by index.
*/
void* operator[] (int i) {
- GrAssert(i >= 0 && i < fCount);
+ SkASSERT(i >= 0 && i < fCount);
return (char*)fBlocks[i / fItemsPerBlock] +
fItemSize * (i % fItemsPerBlock);
}
* access item by index.
*/
const void* operator[] (int i) const {
- GrAssert(i >= 0 && i < fCount);
+ SkASSERT(i >= 0 && i < fCount);
return (const char*)fBlocks[i / fItemsPerBlock] +
fItemSize * (i % fItemsPerBlock);
}
*/
T& push_back() {
void* item = fAllocator.push_back();
- GrAssert(NULL != item);
+ SkASSERT(NULL != item);
SkNEW_PLACEMENT(item, T);
return *(T*)item;
}
T& push_back(const T& t) {
void* item = fAllocator.push_back();
- GrAssert(NULL != item);
+ SkASSERT(NULL != item);
SkNEW_PLACEMENT_ARGS(item, T, (t));
return *(T*)item;
}
int width, int height, const void* image,
GrMaskFormat format,
GrIPoint16* loc) {
- GrAssert(NULL == *atlas || (*atlas)->getMaskFormat() == format);
+ SkASSERT(NULL == *atlas || (*atlas)->getMaskFormat() == format);
// iterate through entire atlas list, see if we can find a hole
GrAtlas* atlasIter = *atlas;
void deleteAtlas(GrAtlas* atlas) { delete atlas; }
GrTexture* getTexture(GrMaskFormat format) const {
- GrAssert((unsigned)format < kCount_GrMaskFormats);
+ SkASSERT((unsigned)format < kCount_GrMaskFormats);
return fTexture[format];
}
}
void setKeyData(const uint32_t* SK_RESTRICT data) {
- GrAssert(GrIsALIGN4(KEY_SIZE));
+ SkASSERT(GrIsALIGN4(KEY_SIZE));
memcpy(&fData, data, KEY_SIZE);
uint32_t hash = 0;
}
int compare(const GrTBinHashKey<ENTRY, KEY_SIZE>& key) const {
- GrAssert(fIsValid && key.fIsValid);
+ SkASSERT(fIsValid && key.fIsValid);
return memcmp(fData, key.fData, KEY_SIZE);
}
static bool EQ(const ENTRY& entry, const GrTBinHashKey<ENTRY, KEY_SIZE>& key) {
- GrAssert(key.fIsValid);
+ SkASSERT(key.fIsValid);
return 0 == entry.compare(key);
}
static bool LT(const ENTRY& entry, const GrTBinHashKey<ENTRY, KEY_SIZE>& key) {
- GrAssert(key.fIsValid);
+ SkASSERT(key.fIsValid);
return entry.compare(key) < 0;
}
uint32_t getHash() const {
- GrAssert(fIsValid);
+ SkASSERT(fIsValid);
return fHash;
}
const uint8_t* getData() const {
- GrAssert(fIsValid);
+ SkASSERT(fIsValid);
return fData;
}
GrColor dstColor, uint32_t dstCompFlags,
GrColor constantColor) {
- GrAssert(!GrBlendCoeffRefsSrc(*srcCoeff));
- GrAssert(NULL != srcCoeff);
+ SkASSERT(!GrBlendCoeffRefsSrc(*srcCoeff));
+ SkASSERT(NULL != srcCoeff);
// Check whether srcCoeff can be reduced to kOne or kZero based on known color inputs.
// We could pick out the coeff r,g,b,a values here and use them to compute the blend term color,
int preallocBufferCnt) :
fBlocks(GrMax(8, 2*preallocBufferCnt)) {
- GrAssert(NULL != gpu);
+ SkASSERT(NULL != gpu);
fGpu = gpu;
fGpu->ref();
fGpuIsReffed = true;
// we may have created a large cpu mirror of a large VB. Reset the size
// to match our pre-allocated VBs.
fCpuData.reset(fMinBlockSize);
- GrAssert(0 == fPreallocBuffersInUse);
+ SkASSERT(0 == fPreallocBuffersInUse);
VALIDATE();
}
#if GR_DEBUG
void GrBufferAllocPool::validate(bool unusedBlockAllowed) const {
if (NULL != fBufferPtr) {
- GrAssert(!fBlocks.empty());
+ SkASSERT(!fBlocks.empty());
if (fBlocks.back().fBuffer->isLocked()) {
GrGeometryBuffer* buf = fBlocks.back().fBuffer;
- GrAssert(buf->lockPtr() == fBufferPtr);
+ SkASSERT(buf->lockPtr() == fBufferPtr);
} else {
- GrAssert(fCpuData.get() == fBufferPtr);
+ SkASSERT(fCpuData.get() == fBufferPtr);
}
} else {
- GrAssert(fBlocks.empty() || !fBlocks.back().fBuffer->isLocked());
+ SkASSERT(fBlocks.empty() || !fBlocks.back().fBuffer->isLocked());
}
size_t bytesInUse = 0;
for (int i = 0; i < fBlocks.count() - 1; ++i) {
- GrAssert(!fBlocks[i].fBuffer->isLocked());
+ SkASSERT(!fBlocks[i].fBuffer->isLocked());
}
for (int i = 0; i < fBlocks.count(); ++i) {
size_t bytes = fBlocks[i].fBuffer->sizeInBytes() - fBlocks[i].fBytesFree;
bytesInUse += bytes;
- GrAssert(bytes || unusedBlockAllowed);
+ SkASSERT(bytes || unusedBlockAllowed);
}
- GrAssert(bytesInUse == fBytesInUse);
+ SkASSERT(bytesInUse == fBytesInUse);
if (unusedBlockAllowed) {
- GrAssert((fBytesInUse && !fBlocks.empty()) ||
+ SkASSERT((fBytesInUse && !fBlocks.empty()) ||
(!fBytesInUse && (fBlocks.count() < 2)));
} else {
- GrAssert((0 == fBytesInUse) == fBlocks.empty());
+ SkASSERT((0 == fBytesInUse) == fBlocks.empty());
}
}
#endif
size_t* offset) {
VALIDATE();
- GrAssert(NULL != buffer);
- GrAssert(NULL != offset);
+ SkASSERT(NULL != buffer);
+ SkASSERT(NULL != offset);
if (NULL != fBufferPtr) {
BufferBlock& back = fBlocks.back();
if (!createBlock(size)) {
return NULL;
}
- GrAssert(NULL != fBufferPtr);
+ SkASSERT(NULL != fBufferPtr);
*offset = 0;
BufferBlock& back = fBlocks.back();
while (bytes) {
// caller shouldnt try to put back more than they've taken
- GrAssert(!fBlocks.empty());
+ SkASSERT(!fBlocks.empty());
BufferBlock& block = fBlocks.back();
size_t bytesUsed = block.fBuffer->sizeInBytes() - block.fBytesFree;
if (bytes >= bytesUsed) {
bool GrBufferAllocPool::createBlock(size_t requestSize) {
size_t size = GrMax(requestSize, fMinBlockSize);
- GrAssert(size >= GrBufferAllocPool_MIN_BLOCK_SIZE);
+ SkASSERT(size >= GrBufferAllocPool_MIN_BLOCK_SIZE);
VALIDATE();
block.fBytesFree = size;
if (NULL != fBufferPtr) {
- GrAssert(fBlocks.count() > 1);
+ SkASSERT(fBlocks.count() > 1);
BufferBlock& prev = fBlocks.fromBack(1);
if (prev.fBuffer->isLocked()) {
prev.fBuffer->unlock();
fBufferPtr = NULL;
}
- GrAssert(NULL == fBufferPtr);
+ SkASSERT(NULL == fBufferPtr);
// If the buffer is CPU-backed we lock it because it is free to do so and saves a copy.
// Otherwise when buffer locking is supported:
}
void GrBufferAllocPool::destroyBlock() {
- GrAssert(!fBlocks.empty());
+ SkASSERT(!fBlocks.empty());
BufferBlock& block = fBlocks.back();
if (fPreallocBuffersInUse > 0) {
--fPreallocBuffersInUse;
}
}
- GrAssert(!block.fBuffer->isLocked());
+ SkASSERT(!block.fBuffer->isLocked());
block.fBuffer->unref();
fBlocks.pop_back();
fBufferPtr = NULL;
void GrBufferAllocPool::flushCpuData(GrGeometryBuffer* buffer,
size_t flushSize) {
- GrAssert(NULL != buffer);
- GrAssert(!buffer->isLocked());
- GrAssert(fCpuData.get() == fBufferPtr);
- GrAssert(flushSize <= buffer->sizeInBytes());
+ SkASSERT(NULL != buffer);
+ SkASSERT(!buffer->isLocked());
+ SkASSERT(fCpuData.get() == fBufferPtr);
+ SkASSERT(flushSize <= buffer->sizeInBytes());
VALIDATE(true);
if (fGpu->caps()->bufferLockSupport() &&
if (kIndex_BufferType == fBufferType) {
return fGpu->createIndexBuffer(size, true);
} else {
- GrAssert(kVertex_BufferType == fBufferType);
+ SkASSERT(kVertex_BufferType == fBufferType);
return fGpu->createVertexBuffer(size, true);
}
}
const GrVertexBuffer** buffer,
int* startVertex) {
- GrAssert(vertexCount >= 0);
- GrAssert(NULL != buffer);
- GrAssert(NULL != startVertex);
+ SkASSERT(vertexCount >= 0);
+ SkASSERT(NULL != buffer);
+ SkASSERT(NULL != startVertex);
size_t offset = 0; // assign to suppress warning
const GrGeometryBuffer* geomBuffer = NULL; // assign to suppress warning
&offset);
*buffer = (const GrVertexBuffer*) geomBuffer;
- GrAssert(0 == offset % vertexSize);
+ SkASSERT(0 == offset % vertexSize);
*startVertex = offset / vertexSize;
return ptr;
}
const GrIndexBuffer** buffer,
int* startIndex) {
- GrAssert(indexCount >= 0);
- GrAssert(NULL != buffer);
- GrAssert(NULL != startIndex);
+ SkASSERT(indexCount >= 0);
+ SkASSERT(NULL != buffer);
+ SkASSERT(NULL != startIndex);
size_t offset = 0; // assign to suppress warning
const GrGeometryBuffer* geomBuffer = NULL; // assign to suppress warning
&offset);
*buffer = (const GrIndexBuffer*) geomBuffer;
- GrAssert(0 == offset % sizeof(uint16_t));
+ SkASSERT(0 == offset % sizeof(uint16_t));
*startIndex = offset / sizeof(uint16_t);
return ptr;
}
void reset() {
if (fStack.empty()) {
-// GrAssert(false);
+// SkASSERT(false);
return;
}
void push();
void pop() {
- //GrAssert(!fStack.empty());
+ //SkASSERT(!fStack.empty());
if (!fStack.empty()) {
GrClipStackFrame* back = (GrClipStackFrame*) fStack.back();
GrTexture* getLastMask() {
if (fStack.empty()) {
- GrAssert(false);
+ SkASSERT(false);
return NULL;
}
const GrTexture* getLastMask() const {
if (fStack.empty()) {
- GrAssert(false);
+ SkASSERT(false);
return NULL;
}
const SkIRect& bound) {
if (fStack.empty()) {
- GrAssert(false);
+ SkASSERT(false);
return;
}
int getLastMaskWidth() const {
if (fStack.empty()) {
- GrAssert(false);
+ SkASSERT(false);
return -1;
}
int getLastMaskHeight() const {
if (fStack.empty()) {
- GrAssert(false);
+ SkASSERT(false);
return -1;
}
void getLastBound(SkIRect* bound) const {
if (fStack.empty()) {
- GrAssert(false);
+ SkASSERT(false);
bound->setEmpty();
return;
}
GrTexture* result,
const SkIRect &devBound) {
GrDrawState* drawState = gpu->drawState();
- GrAssert(drawState);
+ SkASSERT(drawState);
SkMatrix mat;
// We want to use device coords to compute the texture coordinates. We set our matrix to be
const GrRenderTarget* rt = drawState->getRenderTarget();
// GrDrawTarget should have filtered this for us
- GrAssert(NULL != rt);
+ SkASSERT(NULL != rt);
bool ignoreClip = !drawState->isClipState() || clipDataIn->fClipStack->isWideOpen();
drawState->setBlendFunc(kIDC_GrBlendCoeff, kZero_GrBlendCoeff);
break;
default:
- GrAssert(false);
+ SkASSERT(false);
break;
}
}
InitialState initialState,
const ElementList& elements,
const SkIRect& clipSpaceIBounds) {
- GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+ SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
GrTexture* result;
if (this->getMaskTexture(clipStackGenID, clipSpaceIBounds, &result)) {
const SkIRect& clipSpaceIBounds,
const SkIPoint& clipSpaceToStencilOffset) {
- GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+ SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
GrDrawState* drawState = fGpu->drawState();
- GrAssert(drawState->isClipState());
+ SkASSERT(drawState->isClipState());
GrRenderTarget* rt = drawState->getRenderTarget();
- GrAssert(NULL != rt);
+ SkASSERT(NULL != rt);
// TODO: dynamically attach a SB when needed.
GrStencilBuffer* stencilBuffer = rt->getStencilBuffer();
stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
fillInverted = false;
} else {
- GrAssert(Element::kPath_Type == element->getType());
+ SkASSERT(Element::kPath_Type == element->getType());
clipPath.init(element->getPath());
fillInverted = clipPath->isInverseFillType();
if (fillInverted) {
*drawState->stencil() = gDrawToStencil;
fGpu->drawSimpleRect(element->getRect(), NULL);
} else {
- GrAssert(Element::kPath_Type == element->getType());
+ SkASSERT(Element::kPath_Type == element->getType());
if (!clipPath->isEmpty()) {
if (canRenderDirectToStencil) {
*drawState->stencil() = gDrawToStencil;
SET_RANDOM_COLOR
fGpu->drawSimpleRect(element->getRect(), NULL);
} else {
- GrAssert(Element::kPath_Type == element->getType());
+ SkASSERT(Element::kPath_Type == element->getType());
SET_RANDOM_COLOR
pr->drawPath(*clipPath, stroke, fGpu, false);
}
}
}
// set this last because recursive draws may overwrite it back to kNone.
- GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+ SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
fCurrClipMaskType = kStencil_ClipMaskType;
return true;
}
if (this->isClipInStencil() && drawState.isClipState()) {
clipMode = GrClipMaskManager::kRespectClip_StencilClipMode;
// We can't be modifying the clip and respecting it at the same time.
- GrAssert(!drawState.isStateFlagEnabled(
+ SkASSERT(!drawState.isStateFlagEnabled(
GrGpu::kModifyStencilClip_StateBit));
} else if (drawState.isStateFlagEnabled(
GrGpu::kModifyStencilClip_StateBit)) {
stencilBits = stencilBuffer->bits();
}
- GrAssert(fGpu->caps()->stencilWrapOpsSupport() || !settings.usesWrapOp());
- GrAssert(fGpu->caps()->twoSidedStencilSupport() || !settings.isTwoSided());
+ SkASSERT(fGpu->caps()->stencilWrapOpsSupport() || !settings.usesWrapOp());
+ SkASSERT(fGpu->caps()->twoSidedStencilSupport() || !settings.isTwoSided());
this->adjustStencilParams(&settings, clipMode, stencilBits);
fGpu->setStencilSettings(settings);
}
void GrClipMaskManager::adjustStencilParams(GrStencilSettings* settings,
StencilClipMode mode,
int stencilBitCnt) {
- GrAssert(stencilBitCnt > 0);
+ SkASSERT(stencilBitCnt > 0);
if (kModifyClip_StencilClipMode == mode) {
// We assume that this clip manager itself is drawing to the GrGpu and
uint16_t funcMask = settings->funcMask(face);
uint16_t funcRef = settings->funcRef(face);
- GrAssert((unsigned) func < kStencilFuncCount);
+ SkASSERT((unsigned) func < kStencilFuncCount);
writeMask &= userBits;
int respectClip = kRespectClip_StencilClipMode == mode;
if (respectClip) {
// The GrGpu class should have checked this
- GrAssert(this->isClipInStencil());
+ SkASSERT(this->isClipInStencil());
switch (func) {
case kAlwaysIfInClip_StencilFunc:
funcMask = clipBit;
const GrStencilFunc* table =
gSpecialToBasicStencilFunc[respectClip];
func = table[func - kBasicStencilFuncCount];
- GrAssert(func >= 0 && func < kBasicStencilFuncCount);
+ SkASSERT(func >= 0 && func < kBasicStencilFuncCount);
} else {
funcMask &= userBits;
funcRef &= userBits;
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkIRect& clipSpaceIBounds) {
- GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+ SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
GrTexture* result;
if (this->getMaskTexture(clipStackGenID, clipSpaceIBounds, &result)) {
element->isAA(),
0x00);
} else {
- GrAssert(Element::kPath_Type == element->getType());
+ SkASSERT(Element::kPath_Type == element->getType());
SkPath clipPath = element->getPath();
clipPath.toggleInverseFillType();
helper.draw(clipPath, stroke,
if (Element::kRect_Type == element->getType()) {
helper.draw(element->getRect(), op, element->isAA(), 0xFF);
} else {
- GrAssert(Element::kPath_Type == element->getType());
+ SkASSERT(Element::kPath_Type == element->getType());
helper.draw(element->getPath(), stroke, op, element->isAA(), 0xFF);
}
}
static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 1 << 11;
static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 4;
-#define ASSERT_OWNED_RESOURCE(R) GrAssert(!(R) || (R)->getContext() == this)
+#define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
// Glorified typedef to avoid including GrDrawState.h in GrContext.h
class GrContext::AutoRestoreEffects : public GrDrawState::AutoRestoreEffects {};
}
bool GrContext::init(GrBackend backend, GrBackendContext backendContext) {
- GrAssert(NULL == fGpu);
+ SkASSERT(NULL == fGpu);
fGpu = GrGpu::Create(backend, backendContext, this);
if (NULL == fGpu) {
SkDEBUGCODE(GrTexture* texture = )fGpu->createTexture(rtDesc, stretchedPixels.get(),
stretchedRowBytes);
- GrAssert(NULL != texture);
+ SkASSERT(NULL != texture);
}
return texture;
GrTexture* GrContext::lockAndRefScratchTexture(const GrTextureDesc& inDesc, ScratchTexMatch match) {
- GrAssert((inDesc.fFlags & kRenderTarget_GrTextureFlagBit) ||
+ SkASSERT((inDesc.fFlags & kRenderTarget_GrTextureFlagBit) ||
!(inDesc.fFlags & kNoStencil_GrTextureFlagBit));
// Renderable A8 targets are not universally supported (e.g., not on ANGLE)
- GrAssert(this->isConfigRenderable(kAlpha_8_GrPixelConfig) ||
+ SkASSERT(this->isConfigRenderable(kAlpha_8_GrPixelConfig) ||
!(inDesc.fFlags & kRenderTarget_GrTextureFlagBit) ||
(inDesc.fConfig != kAlpha_8_GrPixelConfig));
// This texture should already have a cache entry since it was once
// attached
- GrAssert(NULL != texture->getCacheEntry());
+ SkASSERT(NULL != texture->getCacheEntry());
// Conceptually, the cache entry is going to assume responsibility
// for the creation ref.
- GrAssert(texture->unique());
+ SkASSERT(texture->unique());
// Since this texture came from an AutoScratchTexture it should
// still be in the exclusive pile
void GrContext::unlockScratchTexture(GrTexture* texture) {
ASSERT_OWNED_RESOURCE(texture);
- GrAssert(NULL != texture->getCacheEntry());
+ SkASSERT(NULL != texture->getCacheEntry());
// If this is a scratch texture we detached it from the cache
// while it was locked (to avoid two callers simultaneously getting
}
bool GrContext::OverbudgetCB(void* data) {
- GrAssert(NULL != data);
+ SkASSERT(NULL != data);
GrContext* context = reinterpret_cast<GrContext*>(data);
// can be invoked in this method
GrDrawTarget::AutoGeometryAndStatePush agasp(fGpu, GrDrawTarget::kReset_ASRInit);
GrDrawState* drawState = fGpu->drawState();
- GrAssert(effect);
+ SkASSERT(effect);
drawState->addColorEffect(effect);
drawState->setRenderTarget(texture->asRenderTarget());
grconfig_to_config8888(dstConfig, unpremul, &dstC8888);
if (swapRAndB) {
- GrAssert(c8888IsValid); // we should only do r/b swap on 8888 configs
+ SkASSERT(c8888IsValid); // we should only do r/b swap on 8888 configs
srcC8888 = swap_config8888_red_and_blue(srcC8888);
}
- GrAssert(c8888IsValid);
+ SkASSERT(c8888IsValid);
uint32_t* b32 = reinterpret_cast<uint32_t*>(buffer);
SkConvertConfig8888Pixels(b32, rowBytes, dstC8888,
b32, rowBytes, srcC8888,
}
void GrContext::resolveRenderTarget(GrRenderTarget* target) {
- GrAssert(target);
+ SkASSERT(target);
ASSERT_OWNED_RESOURCE(target);
// In the future we may track whether there are any pending draws to this
// target. We don't today so we always perform a flush. We don't promise
SkCanvas::Config8888 srcConfig8888, dstConfig8888;
GR_DEBUGCODE(bool success = )
grconfig_to_config8888(srcConfig, true, &srcConfig8888);
- GrAssert(success);
+ SkASSERT(success);
GR_DEBUGCODE(success = )
grconfig_to_config8888(srcConfig, false, &dstConfig8888);
- GrAssert(success);
+ SkASSERT(success);
const uint32_t* src = reinterpret_cast<const uint32_t*>(buffer);
tmpPixels.reset(width * height);
SkConvertConfig8888Pixels(tmpPixels.get(), 4 * width, dstConfig8888,
matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
GrDrawTarget::AutoGeometryAndStatePush agasp(fGpu, GrDrawTarget::kReset_ASRInit, &matrix);
GrDrawState* drawState = fGpu->drawState();
- GrAssert(effect);
+ SkASSERT(effect);
drawState->addColorEffect(effect);
drawState->setRenderTarget(target);
AutoRestoreEffects* are) {
// All users of this draw state should be freeing up all effects when they're done.
// Otherwise effects that own resources may keep those resources alive indefinitely.
- GrAssert(0 == fDrawState->numColorStages() && 0 == fDrawState->numCoverageStages());
+ SkASSERT(0 == fDrawState->numColorStages() && 0 == fDrawState->numCoverageStages());
if (kNo_BufferedDraw == buffered && kYes_BufferedDraw == fLastDrawWasBuffered) {
fDrawBuffer->flush();
}
ASSERT_OWNED_RESOURCE(fRenderTarget.get());
if (NULL != paint) {
- GrAssert(NULL != are);
+ SkASSERT(NULL != are);
are->set(fDrawState);
fDrawState->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
#if GR_DEBUG_PARTIAL_COVERAGE_CHECK
fLastDrawWasBuffered = kYes_BufferedDraw;
target = fDrawBuffer;
} else {
- GrAssert(kNo_BufferedDraw == buffered);
+ SkASSERT(kNo_BufferedDraw == buffered);
fLastDrawWasBuffered = kNo_BufferedDraw;
target = fGpu;
}
fDrawState->setState(GrDrawState::kClip_StateBit, NULL != fClip &&
!fClip->fClipStack->isWideOpen());
target->setClip(fClip);
- GrAssert(fDrawState == target->drawState());
+ SkASSERT(fDrawState == target->drawState());
return target;
}
}
void GrContext::setupDrawBuffer() {
-
- GrAssert(NULL == fDrawBuffer);
- GrAssert(NULL == fDrawBufferVBAllocPool);
- GrAssert(NULL == fDrawBufferIBAllocPool);
+ SkASSERT(NULL == fDrawBuffer);
+ SkASSERT(NULL == fDrawBufferVBAllocPool);
+ SkASSERT(NULL == fDrawBufferIBAllocPool);
fDrawBufferVBAllocPool =
SkNEW_ARGS(GrVertexBufferAllocPool, (fGpu, false,
uint16_t subpathIdxStart = 0;
GrPoint* base = reinterpret_cast<GrPoint*>(arg->vertices());
- GrAssert(NULL != base);
+ SkASSERT(NULL != base);
GrPoint* vert = base;
GrPoint pts[4];
first = false;
}
FINISHED:
- GrAssert((vert - base) <= maxPts);
- GrAssert((idx - idxBase) <= maxIdxs);
+ SkASSERT((vert - base) <= maxPts);
+ SkASSERT((idx - idxBase) <= maxIdxs);
*vertexCnt = vert - base;
*indexCnt = idx - idxBase;
return false;
}
- GrAssert(NULL != target);
+ SkASSERT(NULL != target);
GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
GrDrawState* drawState = target->drawState();
bool colorWritesWereDisabled = drawState->isColorWriteDisabled();
// face culling doesn't make sense here
- GrAssert(GrDrawState::kBoth_DrawFace == drawState->getDrawFace());
+ SkASSERT(GrDrawState::kBoth_DrawFace == drawState->getDrawFace());
int passCount = 0;
const GrStencilSettings* passes[3];
}
break;
default:
- GrAssert(!"Unknown path fFill!");
+ SkASSERT(!"Unknown path fFill!");
return false;
}
}
SkRect bounds;
GrDrawState::AutoViewMatrixRestore avmr;
if (reverse) {
- GrAssert(NULL != drawState->getRenderTarget());
+ SkASSERT(NULL != drawState->getRenderTarget());
// draw over the dev bounds (which will be the whole dst surface for inv fill).
bounds = devBounds;
SkMatrix vmi;
void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
const SkStrokeRec& stroke,
GrDrawTarget* target) {
- GrAssert(SkPath::kInverseEvenOdd_FillType != path.getFillType());
- GrAssert(SkPath::kInverseWinding_FillType != path.getFillType());
+ SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
+ SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
this->internalDrawPath(path, stroke, target, true);
}
}
void GrDrawState::setFromPaint(const GrPaint& paint, const SkMatrix& vm, GrRenderTarget* rt) {
- GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+ SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
fColorStages.reset();
fCoverageStages.reset();
#if GR_DEBUG
uint32_t overlapCheck = 0;
#endif
- GrAssert(count <= GrDrawState::kMaxVertexAttribCnt);
+ SkASSERT(count <= GrDrawState::kMaxVertexAttribCnt);
size_t size = 0;
for (int index = 0; index < count; ++index) {
size_t attribSize = GrVertexAttribTypeSize(attribs[index].fType);
size_t dwordCount = attribSize >> 2;
uint32_t mask = (1 << dwordCount)-1;
size_t offsetShift = attribs[index].fOffset >> 2;
- GrAssert(!(overlapCheck & (mask << offsetShift)));
+ SkASSERT(!(overlapCheck & (mask << offsetShift)));
overlapCheck |= (mask << offsetShift);
#endif
}
////////////////////////////////////////////////////////////////////////////////
void GrDrawState::setVertexAttribs(const GrVertexAttrib* attribs, int count) {
- GrAssert(count <= kMaxVertexAttribCnt);
+ SkASSERT(count <= kMaxVertexAttribCnt);
fCommon.fVAPtr = attribs;
fCommon.fVACount = count;
for (int i = 0; i < count; ++i) {
if (attribs[i].fBinding < kGrFixedFunctionVertexAttribBindingCnt) {
// The fixed function attribs can only be specified once
- GrAssert(-1 == fCommon.fFixedFunctionVertexAttribIndices[attribs[i].fBinding]);
- GrAssert(GrFixedFunctionVertexAttribVectorCount(attribs[i].fBinding) ==
+ SkASSERT(-1 == fCommon.fFixedFunctionVertexAttribIndices[attribs[i].fBinding]);
+ SkASSERT(GrFixedFunctionVertexAttribVectorCount(attribs[i].fBinding) ==
GrVertexAttribTypeVectorCount(attribs[i].fType));
fCommon.fFixedFunctionVertexAttribIndices[attribs[i].fBinding] = i;
}
size_t dwordCount = GrVertexAttribTypeSize(attribs[i].fType) >> 2;
uint32_t mask = (1 << dwordCount)-1;
size_t offsetShift = attribs[i].fOffset >> 2;
- GrAssert(!(overlapCheck & (mask << offsetShift)));
+ SkASSERT(!(overlapCheck & (mask << offsetShift)));
overlapCheck |= (mask << offsetShift);
#endif
}
// Positions must be specified.
- GrAssert(-1 != fCommon.fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding]);
+ SkASSERT(-1 != fCommon.fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding]);
}
////////////////////////////////////////////////////////////////////////////////
int covIdx = s - fColorStages.count();
const GrEffectStage& stage = covIdx < 0 ? fColorStages[s] : fCoverageStages[covIdx];
const GrEffectRef* effect = stage.getEffect();
- GrAssert(NULL != effect);
+ SkASSERT(NULL != effect);
// make sure that any attribute indices have the correct binding type, that the attrib
// type and effect's shader lang type are compatible, and that attributes shared by
// multiple effects use the same shader lang type.
if (NULL != fDrawState) {
GR_DEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
fDrawState->fCommon.fViewMatrix = fViewMatrix;
- GrAssert(fDrawState->numColorStages() >= fNumColorStages);
+ SkASSERT(fDrawState->numColorStages() >= fNumColorStages);
int numCoverageStages = fSavedCoordChanges.count() - fNumColorStages;
- GrAssert(fDrawState->numCoverageStages() >= numCoverageStages);
+ SkASSERT(fDrawState->numCoverageStages() >= numCoverageStages);
int i = 0;
for (int s = 0; s < fNumColorStages; ++s, ++i) {
const SkMatrix& preconcatMatrix) {
this->restore();
- GrAssert(NULL == fDrawState);
+ SkASSERT(NULL == fDrawState);
if (NULL == drawState || preconcatMatrix.isIdentity()) {
return;
}
}
}
- virtual ~GrDrawState() { GrAssert(0 == fBlockEffectRemovalCnt); }
+ virtual ~GrDrawState() { SkASSERT(0 == fBlockEffectRemovalCnt); }
/**
* Resets to the default state. GrEffects will be removed from all stages.
class AutoVertexAttribRestore {
public:
AutoVertexAttribRestore(GrDrawState* drawState) {
- GrAssert(NULL != drawState);
+ SkASSERT(NULL != drawState);
fDrawState = drawState;
fVAPtr = drawState->fCommon.fVAPtr;
fVACount = drawState->fCommon.fVACount;
////
const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
- GrAssert(NULL != effect);
+ 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) {
- GrAssert(NULL != effect);
+ SkASSERT(NULL != effect);
SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
return effect;
}
void set(GrDrawState* ds) {
if (NULL != fDrawState) {
int n = fDrawState->fColorStages.count() - fColorEffectCnt;
- GrAssert(n >= 0);
+ SkASSERT(n >= 0);
fDrawState->fColorStages.pop_back_n(n);
n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;
- GrAssert(n >= 0);
+ SkASSERT(n >= 0);
fDrawState->fCoverageStages.pop_back_n(n);
GR_DEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
}
this->restore();
if (NULL != ds) {
- GrAssert(NULL == fSavedTarget);
+ SkASSERT(NULL == fSavedTarget);
fSavedTarget = ds->getRenderTarget();
SkSafeRef(fSavedTarget);
ds->setRenderTarget(newTarget);
* @param face the face(s) to draw.
*/
void setDrawFace(DrawFace face) {
- GrAssert(kInvalid_DrawFace != face);
+ SkASSERT(kInvalid_DrawFace != face);
fCommon.fDrawFace = face;
}
bool operator !=(const GrDrawState& s) const { return !(*this == s); }
GrDrawState& operator= (const GrDrawState& s) {
- GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+ SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
this->setRenderTarget(s.fRenderTarget.get());
fCommon = s.fCommon;
fColorStages = s.fColorStages;
private:
void onReset(const SkMatrix* initialViewMatrix) {
- GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+ SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
fColorStages.reset();
fCoverageStages.reset();
fColorFilterMode == other.fColorFilterMode &&
fColorFilterColor == other.fColorFilterColor &&
fDrawFace == other.fDrawFace;
- GrAssert(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
+ SkASSERT(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
other.fFixedFunctionVertexAttribIndices,
sizeof(fFixedFunctionVertexAttribIndices)));
return result;
}
void restoreTo(GrDrawState* drawState) {
- GrAssert(fInitialized);
+ SkASSERT(fInitialized);
drawState->fCommon = fCommon;
drawState->setRenderTarget(fRenderTarget);
// reinflate color/cov stage arrays.
fIndicesPerInstance = di.fIndicesPerInstance;
if (NULL != di.fDevBounds) {
- GrAssert(di.fDevBounds == &di.fDevBoundsStorage);
+ SkASSERT(di.fDevBounds == &di.fDevBoundsStorage);
fDevBoundsStorage = di.fDevBoundsStorage;
fDevBounds = &fDevBoundsStorage;
} else {
#if GR_DEBUG
bool GrDrawTarget::DrawInfo::isInstanced() const {
if (fInstanceCount > 0) {
- GrAssert(0 == fIndexCount % fIndicesPerInstance);
- GrAssert(0 == fVertexCount % fVerticesPerInstance);
- GrAssert(fIndexCount / fIndicesPerInstance == fInstanceCount);
- GrAssert(fVertexCount / fVerticesPerInstance == fInstanceCount);
+ SkASSERT(0 == fIndexCount % fIndicesPerInstance);
+ SkASSERT(0 == fVertexCount % fVerticesPerInstance);
+ SkASSERT(fIndexCount / fIndicesPerInstance == fInstanceCount);
+ SkASSERT(fVertexCount / fVerticesPerInstance == fInstanceCount);
// there is no way to specify a non-zero start index to drawIndexedInstances().
- GrAssert(0 == fStartIndex);
+ SkASSERT(0 == fStartIndex);
return true;
} else {
- GrAssert(!fVerticesPerInstance);
- GrAssert(!fIndicesPerInstance);
+ SkASSERT(!fVerticesPerInstance);
+ SkASSERT(!fIndicesPerInstance);
return false;
}
}
#endif
void GrDrawTarget::DrawInfo::adjustInstanceCount(int instanceOffset) {
- GrAssert(this->isInstanced());
- GrAssert(instanceOffset + fInstanceCount >= 0);
+ SkASSERT(this->isInstanced());
+ SkASSERT(instanceOffset + fInstanceCount >= 0);
fInstanceCount += instanceOffset;
fVertexCount = fVerticesPerInstance * fInstanceCount;
fIndexCount = fIndicesPerInstance * fInstanceCount;
void GrDrawTarget::DrawInfo::adjustStartVertex(int vertexOffset) {
fStartVertex += vertexOffset;
- GrAssert(fStartVertex >= 0);
+ SkASSERT(fStartVertex >= 0);
}
void GrDrawTarget::DrawInfo::adjustStartIndex(int indexOffset) {
- GrAssert(this->isIndexed());
+ SkASSERT(this->isIndexed());
fStartIndex += indexOffset;
- GrAssert(fStartIndex >= 0);
+ SkASSERT(fStartIndex >= 0);
}
////////////////////////////////////////////////////////////////////////////////
GrDrawTarget::GrDrawTarget(GrContext* context)
: fClip(NULL)
, fContext(context) {
- GrAssert(NULL != context);
+ SkASSERT(NULL != context);
fDrawState = &fDefaultDrawState;
// We assume that fDrawState always owns a ref to the object it points at.
}
GrDrawTarget::~GrDrawTarget() {
- GrAssert(1 == fGeoSrcStateStack.count());
+ SkASSERT(1 == fGeoSrcStateStack.count());
SkDEBUGCODE(GeometrySrcState& geoSrc = fGeoSrcStateStack.back());
- GrAssert(kNone_GeometrySrcType == geoSrc.fIndexSrc);
- GrAssert(kNone_GeometrySrcType == geoSrc.fVertexSrc);
+ SkASSERT(kNone_GeometrySrcType == geoSrc.fIndexSrc);
+ SkASSERT(kNone_GeometrySrcType == geoSrc.fVertexSrc);
fDrawState->unref();
}
}
void GrDrawTarget::setDrawState(GrDrawState* drawState) {
- GrAssert(NULL != fDrawState);
+ SkASSERT(NULL != fDrawState);
if (NULL == drawState) {
drawState = &fDefaultDrawState;
}
GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
bool acquired = false;
if (vertexCount > 0) {
- GrAssert(NULL != vertices);
+ SkASSERT(NULL != vertices);
this->releasePreviousVertexSource();
geoSrc.fVertexSrc = kNone_GeometrySrcType;
GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
bool acquired = false;
if (indexCount > 0) {
- GrAssert(NULL != indices);
+ SkASSERT(NULL != indices);
this->releasePreviousIndexSource();
geoSrc.fIndexSrc = kNone_GeometrySrcType;
void GrDrawTarget::popGeometrySource() {
// if popping last element then pops are unbalanced with pushes
- GrAssert(fGeoSrcStateStack.count() > 1);
+ SkASSERT(fGeoSrcStateStack.count() > 1);
this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1));
this->releasePreviousVertexSource();
}
}
- GrAssert(NULL != drawState.getRenderTarget());
+ SkASSERT(NULL != drawState.getRenderTarget());
for (int s = 0; s < drawState.numColorStages(); ++s) {
const GrEffectRef& effect = *drawState.getColorStage(s).getEffect();
int numTextures = effect->numTextures();
for (int t = 0; t < numTextures; ++t) {
GrTexture* texture = effect->texture(t);
- GrAssert(texture->asRenderTarget() != drawState.getRenderTarget());
+ SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget());
}
}
for (int s = 0; s < drawState.numCoverageStages(); ++s) {
int numTextures = effect->numTextures();
for (int t = 0; t < numTextures; ++t) {
GrTexture* texture = effect->texture(t);
- GrAssert(texture->asRenderTarget() != drawState.getRenderTarget());
+ SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget());
}
}
- GrAssert(drawState.validateVertexAttribs());
+ SkASSERT(drawState.validateVertexAttribs());
#endif
if (NULL == drawState.getRenderTarget()) {
return false;
void GrDrawTarget::stencilPath(const GrPath* path, const SkStrokeRec& stroke, SkPath::FillType fill) {
// TODO: extract portions of checkDraw that are relevant to path stenciling.
- GrAssert(NULL != path);
- GrAssert(this->caps()->pathStencilingSupport());
- GrAssert(!stroke.isHairlineStyle());
- GrAssert(!SkPath::IsInverseFillType(fill));
+ SkASSERT(NULL != path);
+ SkASSERT(this->caps()->pathStencilingSupport());
+ SkASSERT(!stroke.isHairlineStyle());
+ SkASSERT(!SkPath::IsInverseFillType(fill));
this->onStencilPath(path, stroke, fill);
}
}
void GrDrawTarget::AutoStateRestore::set(GrDrawTarget* target, ASRInit init, const SkMatrix* vm) {
- GrAssert(NULL == fDrawTarget);
+ SkASSERT(NULL == fDrawTarget);
fDrawTarget = target;
fSavedState = target->drawState();
- GrAssert(fSavedState);
+ SkASSERT(fSavedState);
fSavedState->ref();
if (kReset_ASRInit == init) {
if (NULL == vm) {
SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*vm));
}
} else {
- GrAssert(kPreserve_ASRInit == init);
+ SkASSERT(kPreserve_ASRInit == init);
if (NULL == vm) {
fTempState.set(*fSavedState);
} else {
}
bool GrDrawTarget::AutoStateRestore::setIdentity(GrDrawTarget* target, ASRInit init) {
- GrAssert(NULL == fDrawTarget);
+ SkASSERT(NULL == fDrawTarget);
fDrawTarget = target;
fSavedState = target->drawState();
- GrAssert(fSavedState);
+ SkASSERT(fSavedState);
fSavedState->ref();
if (kReset_ASRInit == init) {
// calls the default cons
fTempState.init();
} else {
- GrAssert(kPreserve_ASRInit == init);
+ SkASSERT(kPreserve_ASRInit == init);
// calls the copy cons
fTempState.set(*fSavedState);
if (!fTempState.get()->setIdentityViewMatrix()) {
this->reset();
}
}
- GrAssert(success == (NULL != fTarget));
+ SkASSERT(success == (NULL != fTarget));
return success;
}
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
- GrAssert(NULL != dst);
- GrAssert(NULL != src);
+ SkASSERT(NULL != dst);
+ SkASSERT(NULL != src);
SkIRect clippedSrcRect;
SkIPoint clippedDstPoint;
dstPoint,
&clippedSrcRect,
&clippedDstPoint)) {
- GrAssert(this->canCopySurface(dst, src, srcRect, dstPoint));
+ SkASSERT(this->canCopySurface(dst, src, srcRect, dstPoint));
return true;
}
bool result = this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
- GrAssert(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint));
+ SkASSERT(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint));
return result;
}
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
- GrAssert(NULL != dst);
- GrAssert(NULL != src);
+ SkASSERT(NULL != dst);
+ SkASSERT(NULL != src);
SkIRect clippedSrcRect;
SkIPoint clippedDstPoint;
const SkIRect& srcRect,
const SkIPoint& dstPoint) {
// Check that the read/write rects are contained within the src/dst bounds.
- GrAssert(!srcRect.isEmpty());
- GrAssert(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect));
- GrAssert(dstPoint.fX >= 0 && dstPoint.fY >= 0);
- GrAssert(dstPoint.fX + srcRect.width() <= dst->width() &&
+ SkASSERT(!srcRect.isEmpty());
+ SkASSERT(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect));
+ SkASSERT(dstPoint.fX >= 0 && dstPoint.fY >= 0);
+ SkASSERT(dstPoint.fX + srcRect.width() <= dst->width() &&
dstPoint.fY + srcRect.height() <= dst->height());
return !dst->isSameAs(src) && NULL != dst->asRenderTarget() && NULL != src->asTexture();
int vertexCount,
int indexCount);
bool succeeded() const { return NULL != fTarget; }
- void* vertices() const { GrAssert(this->succeeded()); return fVertices; }
- void* indices() const { GrAssert(this->succeeded()); return fIndices; }
+ void* vertices() const { SkASSERT(this->succeeded()); return fVertices; }
+ void* indices() const { SkASSERT(this->succeeded()); return fIndices; }
GrPoint* positions() const {
return static_cast<GrPoint*>(this->vertices());
}
public:
AutoGeometryPush(GrDrawTarget* target)
: fAttribRestore(target->drawState()) {
- GrAssert(NULL != target);
+ SkASSERT(NULL != target);
fTarget = target;
target->pushGeometrySource();
}
ASRInit init,
const SkMatrix* viewMatrix = NULL)
: fState(target, init, viewMatrix) {
- GrAssert(NULL != target);
+ SkASSERT(NULL != target);
fTarget = target;
target->pushGeometrySource();
if (kPreserve_ASRInit == init) {
// it is preferable to call this rather than getGeomSrc()->fVertexSize because of the assert.
size_t getVertexSize() const {
// the vertex layout is only valid if a vertex source has been specified.
- GrAssert(this->getGeomSrc().fVertexSrc != kNone_GeometrySrcType);
+ SkASSERT(this->getGeomSrc().fVertexSrc != kNone_GeometrySrcType);
return this->getGeomSrc().fVertexSize;
}
SK_DEFINE_INST_COUNT(GrEffectRef)
GrEffectRef::~GrEffectRef() {
- GrAssert(this->unique());
+ SkASSERT(this->unique());
fEffect->EffectRefDestroyed();
fEffect->unref();
}
///////////////////////////////////////////////////////////////////////////////
GrEffect::~GrEffect() {
- GrAssert(NULL == fEffectRef);
+ SkASSERT(NULL == fEffectRef);
}
const char* GrEffect::name() const {
}
void GrEffect::addVertexAttrib(GrSLType type) {
- GrAssert(fVertexAttribTypes.count() < kMaxVertexAttribs);
+ SkASSERT(fVertexAttribTypes.count() < kMaxVertexAttribs);
fVertexAttribTypes.push_back(type);
}
fResourceList.head()->abandon();
}
- GrAssert(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
+ SkASSERT(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
GrSafeSetNull(fQuadIndexBuffer);
delete fVertexPool;
fVertexPool = NULL;
fResourceList.head()->release();
}
- GrAssert(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
+ SkASSERT(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
GrSafeSetNull(fQuadIndexBuffer);
delete fVertexPool;
fVertexPool = NULL;
}
void GrGpu::insertResource(GrResource* resource) {
- GrAssert(NULL != resource);
- GrAssert(this == resource->getGpu());
+ SkASSERT(NULL != resource);
+ SkASSERT(this == resource->getGpu());
fResourceList.addToHead(resource);
}
void GrGpu::removeResource(GrResource* resource) {
- GrAssert(NULL != resource);
- GrAssert(this == resource->getGpu());
+ SkASSERT(NULL != resource);
+ SkASSERT(this == resource->getGpu());
fResourceList.remove(resource);
}
if (NULL != tex &&
(kRenderTarget_GrTextureFlagBit & desc.fFlags) &&
!(kNoStencil_GrTextureFlagBit & desc.fFlags)) {
- GrAssert(NULL != tex->asRenderTarget());
+ SkASSERT(NULL != tex->asRenderTarget());
// TODO: defer this and attach dynamically
if (!this->attachStencilBufferToRenderTarget(tex->asRenderTarget())) {
tex->unref();
}
bool GrGpu::attachStencilBufferToRenderTarget(GrRenderTarget* rt) {
- GrAssert(NULL == rt->getStencilBuffer());
+ SkASSERT(NULL == rt->getStencilBuffer());
GrStencilBuffer* sb =
this->getContext()->findStencilBuffer(rt->width(),
rt->height(),
}
GrPath* GrGpu::createPath(const SkPath& path) {
- GrAssert(this->caps()->pathStencilingSupport());
+ SkASSERT(this->caps()->pathStencilingSupport());
this->handleDirtyContext();
return this->onCreatePath(path);
}
art.set(this->drawState(), renderTarget);
}
if (NULL == this->getDrawState().getRenderTarget()) {
- GrAssert(0);
+ SkASSERT(0);
return;
}
this->handleDirtyContext();
}
void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
- GrAssert(target);
+ SkASSERT(target);
this->handleDirtyContext();
this->onResolveRenderTarget(target);
}
void GrGpu::geometrySourceWillPop(const GeometrySrcState& restoredState) {
// if popping last entry then pops are unbalanced with pushes
- GrAssert(fGeomPoolStateStack.count() > 1);
+ SkASSERT(fGeomPoolStateStack.count() > 1);
fGeomPoolStateStack.pop_back();
}
}
void GrGpu::finalizeReservedVertices() {
- GrAssert(NULL != fVertexPool);
+ SkASSERT(NULL != fVertexPool);
fVertexPool->unlock();
}
void GrGpu::finalizeReservedIndices() {
- GrAssert(NULL != fIndexPool);
+ SkASSERT(NULL != fIndexPool);
fIndexPool->unlock();
}
void GrGpu::prepareVertexPool() {
if (NULL == fVertexPool) {
- GrAssert(0 == fVertexPoolUseCnt);
+ SkASSERT(0 == fVertexPoolUseCnt);
fVertexPool = SkNEW_ARGS(GrVertexBufferAllocPool, (this, true,
VERTEX_POOL_VB_SIZE,
VERTEX_POOL_VB_COUNT));
void GrGpu::prepareIndexPool() {
if (NULL == fIndexPool) {
- GrAssert(0 == fIndexPoolUseCnt);
+ SkASSERT(0 == fIndexPoolUseCnt);
fIndexPool = SkNEW_ARGS(GrIndexBufferAllocPool, (this, true,
INDEX_POOL_IB_SIZE,
INDEX_POOL_IB_COUNT));
void** vertices) {
GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
- GrAssert(vertexCount > 0);
- GrAssert(NULL != vertices);
+ SkASSERT(vertexCount > 0);
+ SkASSERT(NULL != vertices);
this->prepareVertexPool();
bool GrGpu::onReserveIndexSpace(int indexCount, void** indices) {
GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
- GrAssert(indexCount > 0);
- GrAssert(NULL != indices);
+ SkASSERT(indexCount > 0);
+ SkASSERT(NULL != indices);
this->prepareIndexPool();
void GrGpu::releaseReservedVertexSpace() {
const GeometrySrcState& geoSrc = this->getGeomSrc();
- GrAssert(kReserved_GeometrySrcType == geoSrc.fVertexSrc);
+ SkASSERT(kReserved_GeometrySrcType == geoSrc.fVertexSrc);
size_t bytes = geoSrc.fVertexCount * geoSrc.fVertexSize;
fVertexPool->putBack(bytes);
--fVertexPoolUseCnt;
void GrGpu::releaseReservedIndexSpace() {
const GeometrySrcState& geoSrc = this->getGeomSrc();
- GrAssert(kReserved_GeometrySrcType == geoSrc.fIndexSrc);
+ SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc);
size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
fIndexPool->putBack(bytes);
--fIndexPoolUseCnt;
void GrGpu::releaseVertexArray() {
// if vertex source was array, we stowed data in the pool
const GeometrySrcState& geoSrc = this->getGeomSrc();
- GrAssert(kArray_GeometrySrcType == geoSrc.fVertexSrc);
+ SkASSERT(kArray_GeometrySrcType == geoSrc.fVertexSrc);
size_t bytes = geoSrc.fVertexCount * geoSrc.fVertexSize;
fVertexPool->putBack(bytes);
--fVertexPoolUseCnt;
void GrGpu::releaseIndexArray() {
// if index source was array, we stowed data in the pool
const GeometrySrcState& geoSrc = this->getGeomSrc();
- GrAssert(kArray_GeometrySrcType == geoSrc.fIndexSrc);
+ SkASSERT(kArray_GeometrySrcType == geoSrc.fIndexSrc);
size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
fIndexPool->putBack(bytes);
--fIndexPoolUseCnt;
* Can the provided configuration act as a color render target?
*/
bool isConfigRenderable(GrPixelConfig config) const {
- GrAssert(kGrPixelConfigCnt > config);
+ SkASSERT(kGrPixelConfigCnt > config);
return fConfigRenderSupport[config];
}
fDstGpu->ref();
fCaps.reset(SkRef(fDstGpu->caps()));
- GrAssert(NULL != vertexPool);
- GrAssert(NULL != indexPool);
+ SkASSERT(NULL != vertexPool);
+ SkASSERT(NULL != indexPool);
GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
poolState.fUsedPoolVertexBytes = 0;
size_t vertexSize,
int vertexCount,
SkRect* bounds) {
- GrAssert(vertexSize >= sizeof(GrPoint));
- GrAssert(vertexCount > 0);
+ SkASSERT(vertexSize >= sizeof(GrPoint));
+ SkASSERT(vertexCount > 0);
const GrPoint* point = static_cast<const GrPoint*>(vertices);
bounds->fLeft = bounds->fRight = point->fX;
bounds->fTop = bounds->fBottom = point->fY;
this->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6, &devBounds);
// to ensure that stashing the drawState ptr is valid
- GrAssert(this->drawState() == drawState);
+ SkASSERT(this->drawState() == drawState);
}
bool GrInOrderDrawBuffer::quickInsideClip(const SkRect& devBounds) {
}
int GrInOrderDrawBuffer::concatInstancedDraw(const DrawInfo& info) {
- GrAssert(info.isInstanced());
+ SkASSERT(info.isInstanced());
const GeometrySrcState& geomSrc = this->getGeomSrc();
const GrDrawState& drawState = this->getDrawState();
return 0;
}
- GrAssert(poolState.fPoolStartVertex == draw->startVertex() + draw->vertexCount());
+ SkASSERT(poolState.fPoolStartVertex == draw->startVertex() + draw->vertexCount());
// how many instances can be concat'ed onto draw given the size of the index buffer
int instancesToConcat = this->indexCountInCurrentSource() / info.indicesPerInstance();
SkIRect r;
if (NULL == renderTarget) {
renderTarget = this->drawState()->getRenderTarget();
- GrAssert(NULL != renderTarget);
+ SkASSERT(NULL != renderTarget);
}
if (NULL == rect) {
// We could do something smart and remove previous draws and clears to
}
void GrInOrderDrawBuffer::reset() {
- GrAssert(1 == fGeoPoolStateStack.count());
+ SkASSERT(1 == fGeoPoolStateStack.count());
this->resetVertexSource();
this->resetIndexSource();
int numDraws = fDraws.count();
for (int d = 0; d < numDraws; ++d) {
// we always have a VB, but not always an IB
- GrAssert(NULL != fDraws[d].fVertexBuffer);
+ SkASSERT(NULL != fDraws[d].fVertexBuffer);
fDraws[d].fVertexBuffer->unref();
GrSafeUnref(fDraws[d].fIndexBuffer);
}
return;
}
- GrAssert(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
- GrAssert(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);
+ SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
+ SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);
int numCmds = fCmds.count();
if (0 == numCmds) {
}
}
// we should have consumed all the states, clips, etc.
- GrAssert(fStates.count() == currState);
- GrAssert(fClips.count() == currClip);
- GrAssert(fClipOrigins.count() == currClip);
- GrAssert(fClears.count() == currClear);
- GrAssert(fDraws.count() == currDraw);
- GrAssert(fCopySurfaces.count() == currCopySurface);
+ SkASSERT(fStates.count() == currState);
+ SkASSERT(fClips.count() == currClip);
+ SkASSERT(fClipOrigins.count() == currClip);
+ SkASSERT(fClears.count() == currClear);
+ SkASSERT(fDraws.count() == currDraw);
+ SkASSERT(fCopySurfaces.count() == currCopySurface);
fDstGpu->setDrawState(prevDrawState);
prevDrawState->unref();
int vertexCount,
void** vertices) {
GeometryPoolState& poolState = fGeoPoolStateStack.back();
- GrAssert(vertexCount > 0);
- GrAssert(NULL != vertices);
- GrAssert(0 == poolState.fUsedPoolVertexBytes);
+ SkASSERT(vertexCount > 0);
+ SkASSERT(NULL != vertices);
+ SkASSERT(0 == poolState.fUsedPoolVertexBytes);
*vertices = fVertexPool.makeSpace(vertexSize,
vertexCount,
bool GrInOrderDrawBuffer::onReserveIndexSpace(int indexCount, void** indices) {
GeometryPoolState& poolState = fGeoPoolStateStack.back();
- GrAssert(indexCount > 0);
- GrAssert(NULL != indices);
- GrAssert(0 == poolState.fUsedPoolIndexBytes);
+ SkASSERT(indexCount > 0);
+ SkASSERT(NULL != indices);
+ SkASSERT(0 == poolState.fUsedPoolIndexBytes);
*indices = fIndexPool.makeSpace(indexCount,
&poolState.fPoolIndexBuffer,
// If we get a release vertex space call then our current source should either be reserved
// or array (which we copied into reserved space).
- GrAssert(kReserved_GeometrySrcType == geoSrc.fVertexSrc ||
+ SkASSERT(kReserved_GeometrySrcType == geoSrc.fVertexSrc ||
kArray_GeometrySrcType == geoSrc.fVertexSrc);
// When the caller reserved vertex buffer space we gave it back a pointer
// If we get a release index space call then our current source should either be reserved
// or array (which we copied into reserved space).
- GrAssert(kReserved_GeometrySrcType == geoSrc.fIndexSrc ||
+ SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc ||
kArray_GeometrySrcType == geoSrc.fIndexSrc);
// Similar to releaseReservedVertexSpace we return any unused portion at
int vertexCount) {
GeometryPoolState& poolState = fGeoPoolStateStack.back();
- GrAssert(0 == poolState.fUsedPoolVertexBytes);
+ SkASSERT(0 == poolState.fUsedPoolVertexBytes);
#if GR_DEBUG
bool success =
#endif
void GrInOrderDrawBuffer::onSetIndexSourceToArray(const void* indexArray,
int indexCount) {
GeometryPoolState& poolState = fGeoPoolStateStack.back();
- GrAssert(0 == poolState.fUsedPoolIndexBytes);
+ SkASSERT(0 == poolState.fUsedPoolIndexBytes);
#if GR_DEBUG
bool success =
#endif
void GrInOrderDrawBuffer::geometrySourceWillPop(
const GeometrySrcState& restoredState) {
- GrAssert(fGeoPoolStateStack.count() > 1);
+ SkASSERT(fGeoPoolStateStack.count() > 1);
fGeoPoolStateStack.pop_back();
GeometryPoolState& poolState = fGeoPoolStateStack.back();
// we have to assume that any slack we had in our vertex/index data
}
bool GrInOrderDrawBuffer::needsNewClip() const {
- GrAssert(fClips.count() == fClipOrigins.count());
+ SkASSERT(fClips.count() == fClipOrigins.count());
if (this->getDrawState().isClipState()) {
if (fClipSet &&
(fClips.empty() ||
GrMemoryPool::~GrMemoryPool() {
VALIDATE;
- GrAssert(0 == fAllocationCnt);
- GrAssert(fHead == fTail);
- GrAssert(0 == fHead->fLiveCount);
+ SkASSERT(0 == fAllocationCnt);
+ SkASSERT(fHead == fTail);
+ SkASSERT(0 == fHead->fLiveCount);
DeleteBlock(fHead);
};
block->fPrev = fTail;
block->fNext = NULL;
- GrAssert(NULL == fTail->fNext);
+ SkASSERT(NULL == fTail->fNext);
fTail->fNext = block;
fTail = block;
}
- GrAssert(fTail->fFreeSize >= size);
+ SkASSERT(fTail->fFreeSize >= size);
intptr_t ptr = fTail->fCurrPtr;
// We stash a pointer to the block header, just before the allocated space,
// so that we can decrement the live count on delete in constant time.
} else {
BlockHeader* prev = block->fPrev;
BlockHeader* next = block->fNext;
- GrAssert(prev);
+ SkASSERT(prev);
prev->fNext = next;
if (next) {
next->fPrev = prev;
} else {
- GrAssert(fTail == block);
+ SkASSERT(fTail == block);
fTail = prev;
}
DeleteBlock(block);
BlockHeader* block =
reinterpret_cast<BlockHeader*>(GrMalloc(size + kHeaderSize));
// we assume malloc gives us aligned memory
- GrAssert(!(reinterpret_cast<intptr_t>(block) % kAlignment));
+ SkASSERT(!(reinterpret_cast<intptr_t>(block) % kAlignment));
block->fLiveCount = 0;
block->fFreeSize = size;
block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize;
#ifdef SK_DEBUG
BlockHeader* block = fHead;
BlockHeader* prev = NULL;
- GrAssert(block);
+ SkASSERT(block);
int allocCount = 0;
do {
allocCount += block->fLiveCount;
- GrAssert(prev == block->fPrev);
+ SkASSERT(prev == block->fPrev);
if (NULL != prev) {
- GrAssert(prev->fNext == block);
+ SkASSERT(prev->fNext == block);
}
intptr_t b = reinterpret_cast<intptr_t>(block);
size_t userSize = totalSize - kHeaderSize;
intptr_t userStart = b + kHeaderSize;
- GrAssert(!(b % kAlignment));
- GrAssert(!(totalSize % kAlignment));
- GrAssert(!(userSize % kAlignment));
- GrAssert(!(block->fCurrPtr % kAlignment));
+ SkASSERT(!(b % kAlignment));
+ SkASSERT(!(totalSize % kAlignment));
+ SkASSERT(!(userSize % kAlignment));
+ SkASSERT(!(block->fCurrPtr % kAlignment));
if (fHead != block) {
- GrAssert(block->fLiveCount);
- GrAssert(userSize >= fMinAllocSize);
+ SkASSERT(block->fLiveCount);
+ SkASSERT(userSize >= fMinAllocSize);
} else {
- GrAssert(userSize == fPreallocSize);
+ SkASSERT(userSize == fPreallocSize);
}
if (!block->fLiveCount) {
- GrAssert(ptrOffset == kHeaderSize);
- GrAssert(userStart == block->fCurrPtr);
+ SkASSERT(ptrOffset == kHeaderSize);
+ SkASSERT(userStart == block->fCurrPtr);
} else {
- GrAssert(block == *reinterpret_cast<BlockHeader**>(userStart));
+ SkASSERT(block == *reinterpret_cast<BlockHeader**>(userStart));
}
prev = block;
} while ((block = block->fNext));
- GrAssert(allocCount == fAllocationCnt);
- GrAssert(prev == fTail);
+ SkASSERT(allocCount == fAllocationCnt);
+ SkASSERT(prev == fTail);
#endif
}
}
drawState->setVertexAttribs<gCircleVertexAttribs>(SK_ARRAY_COUNT(gCircleVertexAttribs));
- GrAssert(sizeof(CircleVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(CircleVertex) == drawState->getVertexSize());
GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
if (!geo.succeeded()) {
}
drawState->setVertexAttribs<gEllipseVertexAttribs>(SK_ARRAY_COUNT(gEllipseVertexAttribs));
- GrAssert(sizeof(EllipseVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(EllipseVertex) == drawState->getVertexSize());
GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
if (!geo.succeeded()) {
// if the corners are circles, use the circle renderer
if ((!isStroked || scaledStroke.fX == scaledStroke.fY) && xRadius == yRadius) {
drawState->setVertexAttribs<gCircleVertexAttribs>(SK_ARRAY_COUNT(gCircleVertexAttribs));
- GrAssert(sizeof(CircleVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(CircleVertex) == drawState->getVertexSize());
GrDrawTarget::AutoReleaseGeometry geo(target, 16, 0);
if (!geo.succeeded()) {
// otherwise we use the ellipse renderer
} else {
drawState->setVertexAttribs<gEllipseVertexAttribs>(SK_ARRAY_COUNT(gEllipseVertexAttribs));
- GrAssert(sizeof(EllipseVertex) == drawState->getVertexSize());
+ SkASSERT(sizeof(EllipseVertex) == drawState->getVertexSize());
SkScalar innerXRadius = 0.0f;
SkScalar innerYRadius = 0.0f;
(*fColorStages[i].getEffect())->getConstantColorComponents(&color, &colorComps);
}
- GrAssert((NULL == solidColor) == (NULL == solidColorKnownComponents));
+ SkASSERT((NULL == solidColor) == (NULL == solidColorKnownComponents));
GrBlendCoeff srcCoeff = fSrcBlendCoeff;
GrBlendCoeff dstCoeff = fDstBlendCoeff;
StencilSupport getStencilSupport(const SkPath& path,
const SkStrokeRec& stroke,
const GrDrawTarget* target) const {
- GrAssert(!path.isInverseFillType());
+ SkASSERT(!path.isInverseFillType());
return this->onGetStencilSupport(path, stroke, target);
}
const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) {
- GrAssert(!path.isEmpty());
- GrAssert(this->canDrawPath(path, stroke, target, antiAlias));
- GrAssert(target->drawState()->getStencil().isDisabled() ||
+ SkASSERT(!path.isEmpty());
+ SkASSERT(this->canDrawPath(path, stroke, target, antiAlias));
+ SkASSERT(target->drawState()->getStencil().isDisabled() ||
kNoRestriction_StencilSupport == this->getStencilSupport(path, stroke, target));
return this->onDrawPath(path, stroke, target, antiAlias);
}
* @param target target that the path will be rendered to
*/
void stencilPath(const SkPath& path, const SkStrokeRec& stroke, GrDrawTarget* target) {
- GrAssert(!path.isEmpty());
- GrAssert(kNoSupport_StencilSupport != this->getStencilSupport(path, stroke, target));
+ SkASSERT(!path.isEmpty());
+ SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(path, stroke, target));
this->onStencilPath(path, stroke, target);
}
}
void GrPathRendererChain::init() {
- GrAssert(!fInit);
+ SkASSERT(!fInit);
GrGpu* gpu = fOwner->getGpu();
bool twoSided = gpu->caps()->twoSidedStencilSupport();
bool wrapOp = gpu->caps()->stencilWrapOpsSupport();
if (tol < gMinCurveTol) {
tol = gMinCurveTol;
}
- GrAssert(tol > 0);
+ SkASSERT(tol > 0);
SkScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
if (d <= tol) {
if (tol < gMinCurveTol) {
tol = gMinCurveTol;
}
- GrAssert(tol > 0);
+ SkASSERT(tol > 0);
SkScalar d = GrMax(
points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
if (tol < gMinCurveTol) {
tol = gMinCurveTol;
}
- GrAssert(tol > 0);
+ SkASSERT(tol > 0);
int pointCount = 0;
*subpaths = 1;
// The matrix should not have perspective.
SkDEBUGCODE(static const SkScalar gTOL = SkFloatToScalar(1.f / 100.f));
- GrAssert(SkScalarAbs(m.get(SkMatrix::kMPersp0)) < gTOL);
- GrAssert(SkScalarAbs(m.get(SkMatrix::kMPersp1)) < gTOL);
+ SkASSERT(SkScalarAbs(m.get(SkMatrix::kMPersp0)) < gTOL);
+ SkASSERT(SkScalarAbs(m.get(SkMatrix::kMPersp1)) < gTOL);
// It may not be normalized to have 1.0 in the bottom right
float m33 = m.get(SkMatrix::kMPersp2);
return false;
}
} else {
- GrAssert(SkPath::kCCW_Direction == dir);
+ SkASSERT(SkPath::kCCW_Direction == dir);
if (apXab < 0) {
return false;
}
return false;
}
} else {
- GrAssert(SkPath::kCCW_Direction == dir);
+ SkASSERT(SkPath::kCCW_Direction == dir);
if (dpXdc > 0) {
return false;
}
}
bool isBusy(int x, int y) const {
- GrAssert((unsigned)x < (unsigned)fDim.fX);
- GrAssert((unsigned)y < (unsigned)fDim.fY);
+ SkASSERT((unsigned)x < (unsigned)fDim.fX);
+ SkASSERT((unsigned)y < (unsigned)fDim.fY);
return fBusy[y * fDim.fX + x] != 0;
}
void freePlot(int x, int y) {
- GrAssert((unsigned)x < (unsigned)fDim.fX);
- GrAssert((unsigned)y < (unsigned)fDim.fY);
+ SkASSERT((unsigned)x < (unsigned)fDim.fX);
+ SkASSERT((unsigned)y < (unsigned)fDim.fY);
fBusy[y * fDim.fX + x] = false;
}
Row fRows[16];
static int HeightToRowIndex(int height) {
- GrAssert(height >= MIN_HEIGHT_POW2);
+ SkASSERT(height >= MIN_HEIGHT_POW2);
return 32 - SkCLZ(height - 1);
}
}
Row* row = &fRows[HeightToRowIndex(height)];
- GrAssert(row->fRowHeight == 0 || row->fRowHeight == height);
+ SkASSERT(row->fRowHeight == 0 || row->fRowHeight == height);
if (0 == row->fRowHeight) {
if (!this->canAddStrip(height)) {
}
}
- GrAssert(row->fRowHeight == height);
- GrAssert(row->canAddWidth(width, this->width()));
+ SkASSERT(row->fRowHeight == height);
+ SkASSERT(row->canAddWidth(width, this->width()));
*loc = row->fLoc;
row->fLoc.fX += width;
- GrAssert(row->fLoc.fX <= this->width());
- GrAssert(row->fLoc.fY <= this->height());
- GrAssert(fNextStripY <= this->height());
+ SkASSERT(row->fLoc.fX <= this->width());
+ SkASSERT(row->fLoc.fY <= this->height());
+ SkASSERT(fNextStripY <= this->height());
fAreaSoFar += area;
return true;
}
class GrRectanizer {
public:
GrRectanizer(int width, int height) : fWidth(width), fHeight(height) {
- GrAssert(width >= 0);
- GrAssert(height >= 0);
+ SkASSERT(width >= 0);
+ SkASSERT(height >= 0);
}
virtual ~GrRectanizer() {}
Row fRows[16];
static int HeightToRowIndex(int height) {
- GrAssert(height >= MIN_HEIGHT_POW2);
+ SkASSERT(height >= MIN_HEIGHT_POW2);
return 32 - Gr_clz(height - 1);
}
}
Row* row = &fRows[HeightToRowIndex(height)];
- GrAssert(row->fRowHeight == 0 || row->fRowHeight == height);
+ SkASSERT(row->fRowHeight == 0 || row->fRowHeight == height);
if (0 == row->fRowHeight) {
if (!this->canAddStrip(height)) {
}
}
- GrAssert(row->fRowHeight == height);
- GrAssert(row->canAddWidth(width, this->width()));
+ SkASSERT(row->fRowHeight == height);
+ SkASSERT(row->canAddWidth(width, this->width()));
*loc = row->fLoc;
row->fLoc.fX += width;
- GrAssert(row->fLoc.fX <= this->width());
- GrAssert(row->fLoc.fY <= this->height());
- GrAssert(fNextStripY <= this->height());
+ SkASSERT(row->fLoc.fX <= this->width());
+ SkASSERT(row->fLoc.fY <= this->height());
+ SkASSERT(fNextStripY <= this->height());
fAreaSoFar += area;
return true;
}
}
bool operator !=(const Iter& i) const { return !(*this == i); }
Iter& operator ++() {
- GrAssert(*this != fTree->end());
+ SkASSERT(*this != fTree->end());
fN = SuccessorNode(fN);
return *this;
}
Iter& operator --() {
- GrAssert(*this != fTree->begin());
+ SkASSERT(*this != fTree->begin());
if (NULL != fN) {
fN = PredecessorNode(fN);
} else {
fRoot = x;
x->fColor = kBlack_Color;
x->fParent = NULL;
- GrAssert(1 == fCount);
+ SkASSERT(1 == fCount);
return Iter(returnNode, this);
}
p->fChildren[pc] = x;
do {
// assumptions at loop start.
- GrAssert(NULL != x);
- GrAssert(kRed_Color == x->fColor);
+ SkASSERT(NULL != x);
+ SkASSERT(kRed_Color == x->fColor);
// can't have a grandparent but no parent.
- GrAssert(!(NULL != gp && NULL == p));
+ SkASSERT(!(NULL != gp && NULL == p));
// make sure pc and gpc are correct
- GrAssert(NULL == p || p->fChildren[pc] == x);
- GrAssert(NULL == gp || gp->fChildren[gpc] == p);
+ SkASSERT(NULL == p || p->fChildren[pc] == x);
+ SkASSERT(NULL == gp || gp->fChildren[gpc] == p);
// if x's parent is black then we didn't violate any of the
// red/black properties when we added x as red.
return Iter(returnNode, this);
}
// gp must be valid because if p was the root then it is black
- GrAssert(NULL != gp);
+ SkASSERT(NULL != gp);
// gp must be black since it's child, p, is red.
- GrAssert(kBlack_Color == gp->fColor);
+ SkASSERT(kBlack_Color == gp->fColor);
// x and its parent are red, violating red-black property.
p = x->fParent;
if (NULL == p) {
// x (prev gp) is the root, color it black and be done.
- GrAssert(fRoot == x);
+ SkASSERT(fRoot == x);
x->fColor = kBlack_Color;
validate();
return Iter(returnNode, this);
} while (true);
// Here p is red but u is black and we still have to resolve the fact
// that x and p are both red.
- GrAssert(NULL == gp->fChildren[1-gpc] || kBlack_Color == gp->fChildren[1-gpc]->fColor);
- GrAssert(kRed_Color == x->fColor);
- GrAssert(kRed_Color == p->fColor);
- GrAssert(kBlack_Color == gp->fColor);
+ SkASSERT(NULL == gp->fChildren[1-gpc] || kBlack_Color == gp->fChildren[1-gpc]->fColor);
+ SkASSERT(kRed_Color == x->fColor);
+ SkASSERT(kRed_Color == p->fColor);
+ SkASSERT(kBlack_Color == gp->fColor);
// make x be on the same side of p as p is of gp. If it isn't already
// the case then rotate x up to p and swap their labels.
// gp's child, u, that is not affected we know to be black. gp's new
// child is p's previous child (x's pre-rotation sibling) which must be
// black since p is red.
- GrAssert(NULL == p->fChildren[1-pc] ||
+ SkASSERT(NULL == p->fChildren[1-pc] ||
kBlack_Color == p->fChildren[1-pc]->fColor);
// Since gp's two children are black it can become red if p is made
// black. This leaves the black-height of both of p's new subtrees
*/
Node* d = n->fParent;
Node* s = n->fChildren[kLeft_Child];
- GrAssert(NULL != s);
+ SkASSERT(NULL != s);
Node* b = s->fChildren[kRight_Child];
if (NULL != d) {
kRight_Child;
d->fChildren[c] = s;
} else {
- GrAssert(fRoot == n);
+ SkASSERT(fRoot == n);
fRoot = s;
}
s->fParent = d;
Node* d = n->fParent;
Node* s = n->fChildren[kRight_Child];
- GrAssert(NULL != s);
+ SkASSERT(NULL != s);
Node* b = s->fChildren[kLeft_Child];
if (NULL != d) {
kLeft_Child;
d->fChildren[c] = s;
} else {
- GrAssert(fRoot == n);
+ SkASSERT(fRoot == n);
fRoot = s;
}
s->fParent = d;
template <typename T, typename C>
typename GrRedBlackTree<T,C>::Node* GrRedBlackTree<T,C>::SuccessorNode(Node* x) {
- GrAssert(NULL != x);
+ SkASSERT(NULL != x);
if (NULL != x->fChildren[kRight_Child]) {
x = x->fChildren[kRight_Child];
while (NULL != x->fChildren[kLeft_Child]) {
template <typename T, typename C>
typename GrRedBlackTree<T,C>::Node* GrRedBlackTree<T,C>::PredecessorNode(Node* x) {
- GrAssert(NULL != x);
+ SkASSERT(NULL != x);
if (NULL != x->fChildren[kLeft_Child]) {
x = x->fChildren[kLeft_Child];
while (NULL != x->fChildren[kRight_Child]) {
template <typename T, typename C>
void GrRedBlackTree<T,C>::deleteAtNode(Node* x) {
- GrAssert(NULL != x);
+ SkASSERT(NULL != x);
validate();
--fCount;
if (hasLeft && hasRight) {
// first and last can't have two children.
- GrAssert(fFirst != x);
- GrAssert(fLast != x);
+ SkASSERT(fFirst != x);
+ SkASSERT(fLast != x);
// if x is an interior node then we find it's successor
// and swap them.
Node* s = x->fChildren[kRight_Child];
while (NULL != s->fChildren[kLeft_Child]) {
s = s->fChildren[kLeft_Child];
}
- GrAssert(NULL != s);
+ SkASSERT(NULL != s);
// this might be expensive relative to swapping node ptrs around.
// depends on T.
x->fItem = s->fItem;
} else if (NULL == x->fParent) {
// if x was the root we just replace it with its child and make
// the new root (if the tree is not empty) black.
- GrAssert(fRoot == x);
+ SkASSERT(fRoot == x);
fRoot = x->fChildren[c];
if (NULL != fRoot) {
fRoot->fParent = NULL;
fRoot->fColor = kBlack_Color;
if (x == fLast) {
- GrAssert(c == kLeft_Child);
+ SkASSERT(c == kLeft_Child);
fLast = fRoot;
} else if (x == fFirst) {
- GrAssert(c == kRight_Child);
+ SkASSERT(c == kRight_Child);
fFirst = fRoot;
}
} else {
- GrAssert(fFirst == fLast && x == fFirst);
+ SkASSERT(fFirst == fLast && x == fFirst);
fFirst = NULL;
fLast = NULL;
- GrAssert(0 == fCount);
+ SkASSERT(0 == fCount);
}
delete x;
validate();
if (NULL == x->fChildren[c]) {
if (fLast == x) {
fLast = p;
- GrAssert(p == PredecessorNode(x));
+ SkASSERT(p == PredecessorNode(x));
} else if (fFirst == x) {
fFirst = p;
- GrAssert(p == SuccessorNode(x));
+ SkASSERT(p == SuccessorNode(x));
}
// x has two implicit black children.
Color xcolor = x->fColor;
//s cannot be an implicit black node because the original
// black-height at x was >= 2 and s's black-height must equal the
// initial black height of x.
- GrAssert(NULL != s);
- GrAssert(p == s->fParent);
+ SkASSERT(NULL != s);
+ SkASSERT(p == s->fParent);
// assigned in loop
Node* sl;
// be real nodes.
// The x side of p has a black-height that is one less than the
// s side. It must be rebalanced.
- GrAssert(NULL != s);
- GrAssert(p == s->fParent);
- GrAssert(NULL == x || x->fParent == p);
+ SkASSERT(NULL != s);
+ SkASSERT(p == s->fParent);
+ SkASSERT(NULL == x || x->fParent == p);
//sl and sr are s's children, which may be implicit.
sl = s->fChildren[kLeft_Child];
// that x's new sibling is black
if (kRed_Color == s->fColor) {
// if s is red then it's parent must be black.
- GrAssert(kBlack_Color == p->fColor);
+ SkASSERT(kBlack_Color == p->fColor);
// s's children must also be black since s is red. They can't
// be implicit since s is red and it's black-height is >= 2.
- GrAssert(NULL != sl && kBlack_Color == sl->fColor);
- GrAssert(NULL != sr && kBlack_Color == sr->fColor);
+ SkASSERT(NULL != sl && kBlack_Color == sl->fColor);
+ SkASSERT(NULL != sr && kBlack_Color == sr->fColor);
p->fColor = kRed_Color;
s->fColor = kBlack_Color;
if (kLeft_Child == pc) {
sr = s->fChildren[kRight_Child];
}
// x and s are now both black.
- GrAssert(kBlack_Color == s->fColor);
- GrAssert(NULL == x || kBlack_Color == x->fColor);
- GrAssert(p == s->fParent);
- GrAssert(NULL == x || p == x->fParent);
+ SkASSERT(kBlack_Color == s->fColor);
+ SkASSERT(NULL == x || kBlack_Color == x->fColor);
+ SkASSERT(p == s->fParent);
+ SkASSERT(NULL == x || p == x->fParent);
// when x is deleted its subtree will have reduced black-height.
slRed = (NULL != sl && kRed_Color == sl->fColor);
x = p;
p = x->fParent;
if (NULL == p) {
- GrAssert(fRoot == x);
+ SkASSERT(fRoot == x);
validate();
return;
} else {
}
s = p->fChildren[1-pc];
- GrAssert(NULL != s);
- GrAssert(p == s->fParent);
+ SkASSERT(NULL != s);
+ SkASSERT(p == s->fParent);
continue;
} else if (kRed_Color == p->fColor) {
// we can make p black and s red. This balance out p's
// if we made it here one or both of sl and sr is red.
// s and x are black. We make sure that a red child is on
// the same side of s as s is of p.
- GrAssert(slRed || srRed);
+ SkASSERT(slRed || srRed);
if (kLeft_Child == pc && !srRed) {
s->fColor = kRed_Color;
sl->fColor = kBlack_Color;
s->fColor = p->fColor;
p->fColor = kBlack_Color;
if (kLeft_Child == pc) {
- GrAssert(NULL != sr && kRed_Color == sr->fColor);
+ SkASSERT(NULL != sr && kRed_Color == sr->fColor);
sr->fColor = kBlack_Color;
rotateLeft(p);
} else {
- GrAssert(NULL != sl && kRed_Color == sl->fColor);
+ SkASSERT(NULL != sl && kRed_Color == sl->fColor);
sl->fColor = kBlack_Color;
rotateRight(p);
}
// child and c1 be its non-implicit child. c1 must be black because
// red nodes always have two black children. Then the two subtrees
// of x rooted at c0 and c1 will have different black-heights.
- GrAssert(kBlack_Color == x->fColor);
+ SkASSERT(kBlack_Color == x->fColor);
// So we know x is black and has one implicit black child, c0. c1
// must be red, otherwise the subtree at c1 will have a different
// black-height than the subtree rooted at c0.
- GrAssert(kRed_Color == x->fChildren[c]->fColor);
+ SkASSERT(kRed_Color == x->fChildren[c]->fColor);
// replace x with c1, making c1 black, preserves all red-black tree
// props.
Node* c1 = x->fChildren[c];
if (x == fFirst) {
- GrAssert(c == kRight_Child);
+ SkASSERT(c == kRight_Child);
fFirst = c1;
while (NULL != fFirst->fChildren[kLeft_Child]) {
fFirst = fFirst->fChildren[kLeft_Child];
}
- GrAssert(fFirst == SuccessorNode(x));
+ SkASSERT(fFirst == SuccessorNode(x));
} else if (x == fLast) {
- GrAssert(c == kLeft_Child);
+ SkASSERT(c == kLeft_Child);
fLast = c1;
while (NULL != fLast->fChildren[kRight_Child]) {
fLast = fLast->fChildren[kRight_Child];
}
- GrAssert(fLast == PredecessorNode(x));
+ SkASSERT(fLast == PredecessorNode(x));
}
c1->fParent = p;
p->fChildren[pc] = c1;
template <typename T, typename C>
void GrRedBlackTree<T,C>::validate() const {
if (fCount) {
- GrAssert(NULL == fRoot->fParent);
- GrAssert(NULL != fFirst);
- GrAssert(NULL != fLast);
+ SkASSERT(NULL == fRoot->fParent);
+ SkASSERT(NULL != fFirst);
+ SkASSERT(NULL != fLast);
- GrAssert(kBlack_Color == fRoot->fColor);
+ SkASSERT(kBlack_Color == fRoot->fColor);
if (1 == fCount) {
- GrAssert(fFirst == fRoot);
- GrAssert(fLast == fRoot);
- GrAssert(0 == fRoot->fChildren[kLeft_Child]);
- GrAssert(0 == fRoot->fChildren[kRight_Child]);
+ SkASSERT(fFirst == fRoot);
+ SkASSERT(fLast == fRoot);
+ SkASSERT(0 == fRoot->fChildren[kLeft_Child]);
+ SkASSERT(0 == fRoot->fChildren[kRight_Child]);
}
} else {
- GrAssert(NULL == fRoot);
- GrAssert(NULL == fFirst);
- GrAssert(NULL == fLast);
+ SkASSERT(NULL == fRoot);
+ SkASSERT(NULL == fFirst);
+ SkASSERT(NULL == fLast);
}
#if DEEP_VALIDATE
int bh;
int count = checkNode(fRoot, &bh);
- GrAssert(count == fCount);
+ SkASSERT(count == fCount);
#endif
}
template <typename T, typename C>
int GrRedBlackTree<T,C>::checkNode(Node* n, int* bh) const {
if (NULL != n) {
- GrAssert(validateChildRelations(n, false));
+ SkASSERT(validateChildRelations(n, false));
if (kBlack_Color == n->fColor) {
*bh += 1;
}
- GrAssert(!fComp(n->fItem, fFirst->fItem));
- GrAssert(!fComp(fLast->fItem, n->fItem));
+ SkASSERT(!fComp(n->fItem, fFirst->fItem));
+ SkASSERT(!fComp(fLast->fItem, n->fItem));
int leftBh = *bh;
int rightBh = *bh;
int cl = checkNode(n->fChildren[kLeft_Child], &leftBh);
int cr = checkNode(n->fChildren[kRight_Child], &rightBh);
- GrAssert(leftBh == rightBh);
+ SkASSERT(leftBh == rightBh);
*bh = leftBh;
return 1 + cl + cr;
}
for (int i = 0; i < 10000; ++i) {
int x = r.nextU()%100;
SkDEBUGCODE(Iter xi = ) tree.insert(x);
- GrAssert(*xi == x);
+ SkASSERT(*xi == x);
++count[x];
}
++count[0];
tree.insert(99);
++count[99];
- GrAssert(*tree.begin() == 0);
- GrAssert(*tree.last() == 99);
- GrAssert(--(++tree.begin()) == tree.begin());
- GrAssert(--tree.end() == tree.last());
- GrAssert(tree.count() == 10002);
+ SkASSERT(*tree.begin() == 0);
+ SkASSERT(*tree.last() == 99);
+ SkASSERT(--(++tree.begin()) == tree.begin());
+ SkASSERT(--tree.end() == tree.last());
+ SkASSERT(tree.count() == 10002);
int c = 0;
// check that we iterate through the correct number of
Iter b = a;
++b;
++c;
- GrAssert(b == tree.end() || *a <= *b);
+ SkASSERT(b == tree.end() || *a <= *b);
}
- GrAssert(c == tree.count());
+ SkASSERT(c == tree.count());
// check that the tree reports the correct number of each int
// and that we can iterate through them correctly both forward
for (int i = 0; i < 100; ++i) {
int c;
c = tree.countOf(i);
- GrAssert(c == count[i]);
+ SkASSERT(c == count[i]);
c = 0;
Iter iter = tree.findFirst(i);
while (iter != tree.end() && *iter == i) {
++c;
++iter;
}
- GrAssert(count[i] == c);
+ SkASSERT(count[i] == c);
c = 0;
iter = tree.findLast(i);
if (iter != tree.end()) {
}
} while (true);
}
- GrAssert(c == count[i]);
+ SkASSERT(c == count[i]);
}
// remove all the ints between 25 and 74. Randomly chose to remove
// the first, last, or any entry for each.
}
tree.remove(iter);
}
- GrAssert(0 == count[i]);
- GrAssert(tree.findFirst(i) == tree.end());
- GrAssert(tree.findLast(i) == tree.end());
- GrAssert(tree.find(i) == tree.end());
+ SkASSERT(0 == count[i]);
+ SkASSERT(tree.findFirst(i) == tree.end());
+ SkASSERT(tree.findLast(i) == tree.end());
+ SkASSERT(tree.find(i) == tree.end());
}
// remove all of the 0 entries. (tests removing begin())
- GrAssert(*tree.begin() == 0);
- GrAssert(*(--tree.end()) == 99);
+ SkASSERT(*tree.begin() == 0);
+ SkASSERT(*(--tree.end()) == 99);
while (0 != tree.countOf(0)) {
--count[0];
tree.remove(tree.find(0));
}
- GrAssert(0 == count[0]);
- GrAssert(tree.findFirst(0) == tree.end());
- GrAssert(tree.findLast(0) == tree.end());
- GrAssert(tree.find(0) == tree.end());
- GrAssert(0 < *tree.begin());
+ SkASSERT(0 == count[0]);
+ SkASSERT(tree.findFirst(0) == tree.end());
+ SkASSERT(tree.findLast(0) == tree.end());
+ SkASSERT(tree.find(0) == tree.end());
+ SkASSERT(0 < *tree.begin());
// remove all the 99 entries (tests removing last()).
while (0 != tree.countOf(99)) {
--count[99];
tree.remove(tree.find(99));
}
- GrAssert(0 == count[99]);
- GrAssert(tree.findFirst(99) == tree.end());
- GrAssert(tree.findLast(99) == tree.end());
- GrAssert(tree.find(99) == tree.end());
- GrAssert(99 > *(--tree.end()));
- GrAssert(tree.last() == --tree.end());
+ SkASSERT(0 == count[99]);
+ SkASSERT(tree.findFirst(99) == tree.end());
+ SkASSERT(tree.findLast(99) == tree.end());
+ SkASSERT(tree.find(99) == tree.end());
+ SkASSERT(99 > *(--tree.end()));
+ SkASSERT(tree.last() == --tree.end());
// Make sure iteration still goes through correct number of entries
// and is still sorted correctly.
Iter b = a;
++b;
++c;
- GrAssert(b == tree.end() || *a <= *b);
+ SkASSERT(b == tree.end() || *a <= *b);
}
- GrAssert(c == tree.count());
+ SkASSERT(c == tree.count());
// repeat check that correct number of each entry is in the tree
// and iterates correctly both forward and backward.
for (int i = 0; i < 100; ++i) {
- GrAssert(tree.countOf(i) == count[i]);
+ SkASSERT(tree.countOf(i) == count[i]);
int c = 0;
Iter iter = tree.findFirst(i);
while (iter != tree.end() && *iter == i) {
++c;
++iter;
}
- GrAssert(count[i] == c);
+ SkASSERT(count[i] == c);
c = 0;
iter = tree.findLast(i);
if (iter != tree.end()) {
}
} while (true);
}
- GrAssert(count[i] == c);
+ SkASSERT(count[i] == c);
}
// remove all entries
GrResource::~GrResource() {
// subclass should have released this.
- GrAssert(0 == fDeferredRefCount);
- GrAssert(!this->isValid());
+ SkASSERT(0 == fDeferredRefCount);
+ SkASSERT(!this->isValid());
}
void GrResource::release() {
GrResourceEntry::GrResourceEntry(const GrResourceKey& key, GrResource* resource)
: fKey(key), fResource(resource) {
// we assume ownership of the resource, and will unref it when we die
- GrAssert(resource);
+ SkASSERT(resource);
resource->ref();
}
#if GR_DEBUG
void GrResourceEntry::validate() const {
- GrAssert(fResource);
- GrAssert(fResource->getCacheEntry() == this);
+ SkASSERT(fResource);
+ SkASSERT(fResource->getCacheEntry() == this);
fResource->validate();
}
#endif
#endif
} else {
- GrAssert(kAccountFor_BudgetBehavior == behavior);
+ SkASSERT(kAccountFor_BudgetBehavior == behavior);
fEntryCount -= 1;
fEntryBytes -= entry->resource()->sizeInBytes();
fClientDetachedCount -= 1;
fClientDetachedBytes -= entry->resource()->sizeInBytes();
} else {
- GrAssert(kAccountFor_BudgetBehavior == behavior);
+ SkASSERT(kAccountFor_BudgetBehavior == behavior);
fEntryCount += 1;
fEntryBytes += entry->resource()->sizeInBytes();
void GrResourceCache::addResource(const GrResourceKey& key,
GrResource* resource,
uint32_t ownershipFlags) {
- GrAssert(NULL == resource->getCacheEntry());
+ SkASSERT(NULL == resource->getCacheEntry());
// we don't expect to create new resources during a purge. In theory
// this could cause purgeAsNeeded() into an infinite loop (e.g.
// each resource destroyed creates and locks 2 resources and
// unlocks 1 thereby causing a new purge).
- GrAssert(!fPurging);
+ SkASSERT(!fPurging);
GrAutoResourceCacheValidate atcv(this);
GrResourceEntry* entry = SkNEW_ARGS(GrResourceEntry, (key, resource));
}
void GrResourceCache::deleteResource(GrResourceEntry* entry) {
- GrAssert(1 == entry->fResource->getRefCnt());
+ SkASSERT(1 == entry->fResource->getRefCnt());
// remove from our cache
fCache.remove(entry->key(), entry);
this->purgeAsNeeded();
#if GR_DEBUG
- GrAssert(fExclusiveList.countEntries() == fClientDetachedCount);
- GrAssert(countBytes(fExclusiveList) == fClientDetachedBytes);
+ SkASSERT(fExclusiveList.countEntries() == fClientDetachedCount);
+ SkASSERT(countBytes(fExclusiveList) == fClientDetachedBytes);
if (!fCache.count()) {
// Items may have been detached from the cache (such as the backing
// texture for an SkGpuDevice). The above purge would not have removed
// them.
- GrAssert(fEntryCount == fClientDetachedCount);
- GrAssert(fEntryBytes == fClientDetachedBytes);
- GrAssert(fList.isEmpty());
+ SkASSERT(fEntryCount == fClientDetachedCount);
+ SkASSERT(fEntryBytes == fClientDetachedBytes);
+ SkASSERT(fList.isEmpty());
}
#endif
void GrResourceCache::validate() const {
fList.validate();
fExclusiveList.validate();
- GrAssert(both_zero_or_nonzero(fEntryCount, fEntryBytes));
- GrAssert(both_zero_or_nonzero(fClientDetachedCount, fClientDetachedBytes));
- GrAssert(fClientDetachedBytes <= fEntryBytes);
- GrAssert(fClientDetachedCount <= fEntryCount);
- GrAssert((fEntryCount - fClientDetachedCount) == fCache.count());
+ SkASSERT(both_zero_or_nonzero(fEntryCount, fEntryBytes));
+ SkASSERT(both_zero_or_nonzero(fClientDetachedCount, fClientDetachedBytes));
+ SkASSERT(fClientDetachedBytes <= fEntryBytes);
+ SkASSERT(fClientDetachedCount <= fEntryCount);
+ SkASSERT((fEntryCount - fClientDetachedCount) == fCache.count());
fCache.validate();
int count = 0;
for ( ; NULL != entry; entry = iter.next()) {
entry->validate();
- GrAssert(fCache.find(entry->key()));
+ SkASSERT(fCache.find(entry->key()));
count += 1;
}
- GrAssert(count == fEntryCount - fClientDetachedCount);
+ SkASSERT(count == fEntryCount - fClientDetachedCount);
size_t bytes = countBytes(fList);
- GrAssert(bytes == fEntryBytes - fClientDetachedBytes);
+ SkASSERT(bytes == fEntryBytes - fClientDetachedBytes);
bytes = countBytes(fExclusiveList);
- GrAssert(bytes == fClientDetachedBytes);
+ SkASSERT(bytes == fClientDetachedBytes);
- GrAssert(fList.countEntries() == fEntryCount - fClientDetachedCount);
+ SkASSERT(fList.countEntries() == fEntryCount - fClientDetachedCount);
- GrAssert(fExclusiveList.countEntries() == fClientDetachedCount);
+ SkASSERT(fExclusiveList.countEntries() == fClientDetachedCount);
}
#endif // GR_DEBUG
bool operator == (const GrStencilSettings& s) const {
static const size_t gCompareSize = sizeof(GrStencilSettings) -
sizeof(fFlags);
- GrAssert((const char*)&fFlags + sizeof(fFlags) ==
+ SkASSERT((const char*)&fFlags + sizeof(fFlags) ==
(const char*)this + sizeof(GrStencilSettings));
if (this->isDisabled() & s.isDisabled()) { // using & not &&
return true;
#include "SkStrokeRec.h"
GrPathRenderer* GrStencilAndCoverPathRenderer::Create(GrContext* context) {
- GrAssert(NULL != context);
- GrAssert(NULL != context->getGpu());
+ SkASSERT(NULL != context);
+ SkASSERT(NULL != context->getGpu());
if (context->getGpu()->caps()->pathStencilingSupport()) {
return SkNEW_ARGS(GrStencilAndCoverPathRenderer, (context->getGpu()));
} else {
}
GrStencilAndCoverPathRenderer::GrStencilAndCoverPathRenderer(GrGpu* gpu) {
- GrAssert(gpu->caps()->pathStencilingSupport());
+ SkASSERT(gpu->caps()->pathStencilingSupport());
fGpu = gpu;
gpu->ref();
}
void GrStencilAndCoverPathRenderer::onStencilPath(const SkPath& path,
const SkStrokeRec& stroke,
GrDrawTarget* target) {
- GrAssert(!path.isInverseFillType());
+ SkASSERT(!path.isInverseFillType());
SkAutoTUnref<GrPath> p(fGpu->createPath(path));
target->stencilPath(p, stroke, path.getFillType());
}
const SkStrokeRec& stroke,
GrDrawTarget* target,
bool antiAlias) {
- GrAssert(!antiAlias);
- GrAssert(!stroke.isHairlineStyle());
+ SkASSERT(!antiAlias);
+ SkASSERT(!stroke.isHairlineStyle());
GrDrawState* drawState = target->drawState();
- GrAssert(drawState->getStencil().isDisabled());
+ SkASSERT(drawState->getStencil().isDisabled());
SkAutoTUnref<GrPath> p(fGpu->createPath(path));
SK_DEFINE_INST_COUNT(GrStencilBuffer)
void GrStencilBuffer::transferToCache() {
- GrAssert(NULL == this->getCacheEntry());
+ SkASSERT(NULL == this->getCacheEntry());
this->getGpu()->getContext()->addStencilBuffer(this);
}
template <typename ELEM, typename KEY>
int GrTBSearch(const ELEM array[], int count, KEY target) {
- GrAssert(count >= 0);
+ SkASSERT(count >= 0);
if (0 == count) {
// we should insert it at 0
return ~0;
if (Key::EQ(*array[high], key)) {
// above search should have found the first occurrence if there
// are multiple.
- GrAssert(0 == high || Key::LT(*array[high - 1], key));
+ SkASSERT(0 == high || Key::LT(*array[high - 1], key));
return high;
}
// above search should have found the first occurrence if there
// are multiple.
- GrAssert(0 == index || Key::LT(*array[index - 1], key));
+ SkASSERT(0 == index || Key::LT(*array[index - 1], key));
for ( ; index < count() && Key::EQ(*array[index], key); ++index) {
if (findFunc(fSorted[index])) {
// remove from our sorted array
index = this->searchArray(key);
- GrAssert(index >= 0);
+ SkASSERT(index >= 0);
// if there are multiple matches searchArray will give us the first match
// march forward until we find elem.
while (elem != fSorted[index]) {
++index;
- GrAssert(index < fSorted.count());
+ SkASSERT(index < fSorted.count());
}
- GrAssert(elem == fSorted[index]);
+ SkASSERT(elem == fSorted[index]);
fSorted.remove(index);
}
void GrTHashTable<T, Key, kHashBits>::validate() const {
int count = fSorted.count();
for (int i = 1; i < count; i++) {
- GrAssert(Key::LT(*fSorted[i - 1], *fSorted[i]) ||
+ SkASSERT(Key::LT(*fSorted[i - 1], *fSorted[i]) ||
Key::EQ(*fSorted[i - 1], *fSorted[i]));
}
}
if (fCurrVertex > 0) {
// setup our sampler state for our text texture/atlas
- GrAssert(GrIsALIGN4(fCurrVertex));
- GrAssert(fCurrTexture);
+ SkASSERT(GrIsALIGN4(fCurrVertex));
+ SkASSERT(fCurrTexture);
GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kNone_FilterMode);
// This effect could be stored with one of the cache objects (atlas?)
}
HAS_ATLAS:
- GrAssert(glyph->fAtlas);
+ SkASSERT(glyph->fAtlas);
// now promote them to fixed (TODO: Rethink using fixed pt).
width = SkIntToFixed(width);
height = SkIntToFixed(height);
GrTexture* texture = glyph->fAtlas->texture();
- GrAssert(texture);
+ SkASSERT(texture);
if (fCurrTexture != texture || fCurrVertex + 4 > fMaxVertices) {
this->flushGlyphs();
GrTCast<void**>(&fVertices),
NULL);
GrAlwaysAssert(success);
- GrAssert(2*sizeof(GrPoint) == fDrawTarget->getDrawState().getVertexSize());
+ SkASSERT(2*sizeof(GrPoint) == fDrawTarget->getDrawState().getVertexSize());
}
GrFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX);
if (fHead) {
fHead->fPrev = strike;
} else {
- GrAssert(NULL == fTail);
+ SkASSERT(NULL == fTail);
fTail = strike;
}
strike->fPrev = NULL;
// keep purging if we won't free up any atlases with this strike.
purge = (NULL == strikeToPurge->fAtlas);
int index = fCache.slowFindIndex(strikeToPurge);
- GrAssert(index >= 0);
+ SkASSERT(index >= 0);
fCache.removeAt(index, strikeToPurge->fFontScalerKey->getHash());
this->detachStrikeFromList(strikeToPurge);
delete strikeToPurge;
if (strikeToPurge->removeUnusedAtlases()) {
if (NULL == strikeToPurge->fAtlas) {
int index = fCache.slowFindIndex(strikeToPurge);
- GrAssert(index >= 0);
+ SkASSERT(index >= 0);
fCache.removeAt(index, strikeToPurge->fFontScalerKey->getHash());
this->detachStrikeFromList(strikeToPurge);
delete strikeToPurge;
void GrFontCache::validate() const {
int count = fCache.count();
if (0 == count) {
- GrAssert(!fHead);
- GrAssert(!fTail);
+ SkASSERT(!fHead);
+ SkASSERT(!fTail);
} else if (1 == count) {
- GrAssert(fHead == fTail);
+ SkASSERT(fHead == fTail);
} else {
- GrAssert(fHead != fTail);
+ SkASSERT(fHead != fTail);
}
int count2 = 0;
count2 += 1;
strike = strike->fNext;
}
- GrAssert(count == count2);
+ SkASSERT(count == count2);
count2 = 0;
strike = fTail;
count2 += 1;
strike = strike->fPrev;
}
- GrAssert(count == count2);
+ SkASSERT(count == count2);
}
#endif
if ((++gCounter % 10) == 0) return false;
#endif
- GrAssert(glyph);
- GrAssert(scaler);
- GrAssert(fCache.contains(glyph));
+ SkASSERT(glyph);
+ SkASSERT(scaler);
+ SkASSERT(fCache.contains(glyph));
if (glyph->fAtlas) {
glyph->fAtlas->setDrawToken(currentDrawToken);
return true;
void GrFontCache::detachStrikeFromList(GrTextStrike* strike) {
if (strike->fPrev) {
- GrAssert(fHead != strike);
+ SkASSERT(fHead != strike);
strike->fPrev->fNext = strike->fNext;
} else {
- GrAssert(fHead == strike);
+ SkASSERT(fHead == strike);
fHead = strike->fNext;
}
if (strike->fNext) {
- GrAssert(fTail != strike);
+ SkASSERT(fTail != strike);
strike->fNext->fPrev = strike->fPrev;
} else {
- GrAssert(fTail == strike);
+ SkASSERT(fTail == strike);
fTail = strike->fPrev;
}
}
}
void GrTexture::onRelease() {
- GrAssert(!this->isSetFlag((GrTextureFlags) kReturnToCache_FlagBit));
+ SkASSERT(!this->isSetFlag((GrTextureFlags) kReturnToCache_FlagBit));
INHERITED::onRelease();
}
void GrTexture::validateDesc() const {
if (NULL != this->asRenderTarget()) {
// This texture has a render target
- GrAssert(0 != (fDesc.fFlags & kRenderTarget_GrTextureFlagBit));
+ SkASSERT(0 != (fDesc.fFlags & kRenderTarget_GrTextureFlagBit));
if (NULL != this->asRenderTarget()->getStencilBuffer()) {
- GrAssert(0 != (fDesc.fFlags & kNoStencil_GrTextureFlagBit));
+ SkASSERT(0 != (fDesc.fFlags & kNoStencil_GrTextureFlagBit));
} else {
- GrAssert(0 == (fDesc.fFlags & kNoStencil_GrTextureFlagBit));
+ SkASSERT(0 == (fDesc.fFlags & kNoStencil_GrTextureFlagBit));
}
- GrAssert(fDesc.fSampleCnt == this->asRenderTarget()->numSamples());
+ SkASSERT(fDesc.fSampleCnt == this->asRenderTarget()->numSamples());
} else {
- GrAssert(0 == (fDesc.fFlags & kRenderTarget_GrTextureFlagBit));
- GrAssert(0 == (fDesc.fFlags & kNoStencil_GrTextureFlagBit));
- GrAssert(0 == fDesc.fSampleCnt);
+ SkASSERT(0 == (fDesc.fFlags & kRenderTarget_GrTextureFlagBit));
+ SkASSERT(0 == (fDesc.fFlags & kNoStencil_GrTextureFlagBit));
+ SkASSERT(0 == fDesc.fSampleCnt);
}
}
// Instead of a client-provided key of the texture contents we create a key from the
// descriptor.
GR_STATIC_ASSERT(sizeof(idKey) >= 16);
- GrAssert(desc.fHeight < (1 << 16));
- GrAssert(desc.fWidth < (1 << 16));
+ SkASSERT(desc.fHeight < (1 << 16));
+ SkASSERT(desc.fWidth < (1 << 16));
idKey.fData32[0] = (desc.fWidth) | (desc.fHeight << 16);
idKey.fData32[1] = desc.fConfig | desc.fSampleCnt << 16;
idKey.fData32[2] = desc.fFlags;
void GrTextureAccess::reset(GrTexture* texture,
const char* swizzle,
const GrTextureParams& params) {
- GrAssert(NULL != texture);
- GrAssert(strlen(swizzle) >= 1 && strlen(swizzle) <= 4);
+ SkASSERT(NULL != texture);
+ SkASSERT(strlen(swizzle) >= 1 && strlen(swizzle) <= 4);
fParams = params;
fTexture.reset(SkRef(texture));
const char* swizzle,
GrTextureParams::FilterMode filterMode,
SkShader::TileMode tileXAndY) {
- GrAssert(NULL != texture);
- GrAssert(strlen(swizzle) >= 1 && strlen(swizzle) <= 4);
+ SkASSERT(NULL != texture);
+ SkASSERT(strlen(swizzle) >= 1 && strlen(swizzle) <= 4);
fParams.reset(tileXAndY, filterMode);
fTexture.reset(SkRef(texture));
void GrTextureAccess::reset(GrTexture* texture,
const GrTextureParams& params) {
- GrAssert(NULL != texture);
+ SkASSERT(NULL != texture);
fTexture.reset(SkRef(texture));
fParams = params;
memcpy(fSwizzle, "rgba", 5);
void GrTextureAccess::reset(GrTexture* texture,
GrTextureParams::FilterMode filterMode,
SkShader::TileMode tileXAndY) {
- GrAssert(NULL != texture);
+ SkASSERT(NULL != texture);
fTexture.reset(SkRef(texture));
fParams.reset(tileXAndY, filterMode);
memcpy(fSwizzle, "rgba", 5);
GrTexture** texture)
: fDevice(NULL)
, fTexture(NULL) {
- GrAssert(NULL != texture);
+ SkASSERT(NULL != texture);
*texture = this->set(device, bitmap, params);
}
}
SkGpuDevice* SkGpuDevice::Create(GrSurface* surface) {
- GrAssert(NULL != surface);
+ SkASSERT(NULL != surface);
if (NULL == surface->asRenderTarget() || NULL == surface->getContext()) {
return NULL;
}
fRenderTarget = NULL;
fNeedClear = false;
- GrAssert(NULL != renderTarget);
+ SkASSERT(NULL != renderTarget);
fRenderTarget = renderTarget;
fRenderTarget->ref();
fRenderTarget = texture->asRenderTarget();
fRenderTarget->ref();
- GrAssert(NULL != fRenderTarget);
+ SkASSERT(NULL != fRenderTarget);
// wrap the bitmap with a pixelref to expose our texture
SkGrPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (texture));
} else {
GrPrintf("--- failed to create gpu-offscreen [%d %d]\n",
width, height);
- GrAssert(false);
+ SkASSERT(false);
}
}
}
}
- GrAssert(devBound.contains(clipRegion.getBounds()));
+ SkASSERT(devBound.contains(clipRegion.getBounds()));
}
#endif
// call this every draw call, to ensure that the context reflects our state,
// and not the state from some other canvas/device
void SkGpuDevice::prepareDraw(const SkDraw& draw, bool forceIdentity) {
- GrAssert(NULL != fClipData.fClipStack);
+ SkASSERT(NULL != fClipData.fClipStack);
fContext->setRenderTarget(fRenderTarget);
grPaint->setColor(GrColorPackRGBA(alpha, alpha, alpha, alpha));
// justAlpha is currently set to true only if there is a texture,
// so constantColor should not also be true.
- GrAssert(!constantColor);
+ SkASSERT(!constantColor);
} else {
grPaint->setColor(SkColor2GrColor(skPaint.getColor()));
}
const SkMatrix& m) {
// Only gets called if has_aligned_samples returned false.
// So we can assume that sampling is axis aligned but not texel aligned.
- GrAssert(!has_aligned_samples(srcRect, transformedRect));
+ SkASSERT(!has_aligned_samples(srcRect, transformedRect));
SkRect innerSrcRect(srcRect), innerTransformedRect,
outerTransformedRect(transformedRect);
innerSrcRect.inset(SK_ScalarHalf, SK_ScalarHalf);
GrTexture* texture, SkImageFilter* filter,
int w, int h, const SkMatrix& ctm, SkBitmap* result,
SkIPoint* offset) {
- GrAssert(filter);
+ SkASSERT(filter);
SkDeviceImageFilterProxy proxy(device);
if (filter->canFilterImageGPU()) {
bool needClear)
: SkDevice(make_bitmap(context, texture->asRenderTarget())) {
- GrAssert(texture && texture->asRenderTarget());
+ SkASSERT(texture && texture->asRenderTarget());
// This constructor is called from onCreateCompatibleDevice. It has locked the RT in the texture
// cache. We pass true for the third argument so that it will get unlocked.
this->initFromRenderTarget(context, texture->asRenderTarget(), true);
}
void GrUnlockAndUnrefCachedBitmapTexture(GrTexture* texture) {
- GrAssert(NULL != texture->getContext());
+ SkASSERT(NULL != texture->getContext());
texture->getContext()->unlockScratchTexture(texture);
texture->unref();
case SkMask::kLCD32_Format:
return kA888_GrMaskFormat;
default:
- GrAssert(!"unsupported SkMask::Format");
+ SkASSERT(!"unsupported SkMask::Format");
return kA8_GrMaskFormat;
}
}
const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
GrGlyph::UnpackFixedX(packed),
GrGlyph::UnpackFixedY(packed));
- GrAssert(glyph.fWidth == width);
- GrAssert(glyph.fHeight == height);
+ SkASSERT(glyph.fWidth == width);
+ SkASSERT(glyph.fHeight == height);
const void* src = fStrike->findImage(glyph);
if (NULL == src) {
return false;
coordsType);
builder->fsCodeAppend(";\n");
if (GrConfigConversionEffect::kNone_PMConversion == fPMConversion) {
- GrAssert(fSwapRedAndBlue);
+ SkASSERT(fSwapRedAndBlue);
builder->fsCodeAppendf("\t%s = %s.bgra;\n", outputColor, outputColor);
} else {
const char* swiz = fSwapRedAndBlue ? "bgr" : "rgb";
drawEffect,
conv.coordsType(),
conv.texture(0));
- GrAssert(!(matrixKey & key));
+ SkASSERT(!(matrixKey & key));
return matrixKey | key;
}
: GrSingleTextureEffect(texture, matrix)
, fSwapRedAndBlue(swapRedAndBlue)
, fPMConversion(pmConversion) {
- GrAssert(kRGBA_8888_GrPixelConfig == texture->config() ||
+ SkASSERT(kRGBA_8888_GrPixelConfig == texture->config() ||
kBGRA_8888_GrPixelConfig == texture->config());
// Why did we pollute our texture cache instead of using a GrSingleTextureEffect?
- GrAssert(swapRedAndBlue || kNone_PMConversion != pmConversion);
+ SkASSERT(swapRedAndBlue || kNone_PMConversion != pmConversion);
}
const GrBackendEffectFactory& GrConfigConversionEffect::getFactory() const {
const GrConvolutionEffect& conv = drawEffect.castEffect<GrConvolutionEffect>();
GrTexture& texture = *conv.texture(0);
// the code we generated was for a specific kernel radius
- GrAssert(conv.radius() == fRadius);
+ SkASSERT(conv.radius() == fRadius);
float imageIncrement[2] = { 0 };
float ySign = texture.origin() != kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
switch (conv.direction()) {
bool useBounds,
float bounds[2])
: Gr1DKernelEffect(texture, direction, radius), fUseBounds(useBounds) {
- GrAssert(radius <= kMaxKernelRadius);
- GrAssert(NULL != kernel);
+ SkASSERT(radius <= kMaxKernelRadius);
+ SkASSERT(NULL != kernel);
int width = this->width();
for (int i = 0; i < width; i++) {
fKernel[i] = kernel[i];
bool useBounds,
float bounds[2])
: Gr1DKernelEffect(texture, direction, radius), fUseBounds(useBounds) {
- GrAssert(radius <= kMaxKernelRadius);
+ SkASSERT(radius <= kMaxKernelRadius);
int width = this->width();
float sum = 0.0f;
const char* fsCoordName;
GrSLType fsCoordSLType;
if (GrEffect::kCustom_CoordsType == ste.coordsType()) {
- GrAssert(ste.getMatrix().isIdentity());
- GrAssert(1 == ste.numVertexAttribs());
+ SkASSERT(ste.getMatrix().isIdentity());
+ SkASSERT(1 == ste.numVertexAttribs());
fsCoordSLType = kVec2f_GrSLType;
const char* vsVaryingName;
builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsVaryingName, &fsCoordName);
const GrDrawEffect& drawEffect) SK_OVERRIDE {
const GrSimpleTextureEffect& ste = drawEffect.castEffect<GrSimpleTextureEffect>();
if (GrEffect::kCustom_CoordsType == ste.coordsType()) {
- GrAssert(ste.getMatrix().isIdentity());
+ SkASSERT(ste.getMatrix().isIdentity());
} else {
fEffectMatrix.get()->setData(uman, ste.getMatrix(), drawEffect, ste.texture(0));
}
static GrEffectRef* Create(GrTexture* tex,
const SkMatrix& matrix,
CoordsType coordsType = kLocal_CoordsType) {
- GrAssert(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
+ SkASSERT(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
AutoEffectUnref effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix, GrTextureParams::kNone_FilterMode, coordsType)));
return CreateEffectRef(effect);
}
const SkMatrix& matrix,
GrTextureParams::FilterMode filterMode,
CoordsType coordsType = kLocal_CoordsType) {
- GrAssert(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
+ SkASSERT(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
AutoEffectUnref effect(
SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix, filterMode, coordsType)));
return CreateEffectRef(effect);
const SkMatrix& matrix,
const GrTextureParams& p,
CoordsType coordsType = kLocal_CoordsType) {
- GrAssert(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
+ SkASSERT(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
AutoEffectUnref effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix, p, coordsType)));
return CreateEffectRef(effect);
}
GrTextureParams::FilterMode filterMode,
CoordsType coordsType)
: GrSingleTextureEffect(texture, matrix, filterMode, coordsType) {
- GrAssert(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
+ SkASSERT(kLocal_CoordsType == coordsType || kPosition_CoordsType == coordsType);
}
GrSimpleTextureEffect(GrTexture* texture,
CoordsType coordsType)
: GrSingleTextureEffect(texture, matrix, params, coordsType) {
if (kCustom_CoordsType == coordsType) {
- GrAssert(matrix.isIdentity());
+ SkASSERT(matrix.isIdentity());
this->addVertexAttrib(kVec2f_GrSLType);
}
}
"clampCoord");
builder->fsCodeAppend(";\n");
} else {
- GrAssert(GrTextureDomainEffect::kDecal_WrapMode == texDom.wrapMode());
+ SkASSERT(GrTextureDomainEffect::kDecal_WrapMode == texDom.wrapMode());
if (kImagination_GrGLVendor == builder->ctxInfo().vendor()) {
// On the NexusS and GalaxyNexus, the other path (with the 'any'
// We don't currently handle domains that are empty or don't intersect the texture.
// It is OK if the domain rect is a line or point, but it should not be inverted. We do not
// handle rects that do not intersect the [0..1]x[0..1] rect.
- GrAssert(domain.fLeft <= domain.fRight);
- GrAssert(domain.fTop <= domain.fBottom);
+ SkASSERT(domain.fLeft <= domain.fRight);
+ SkASSERT(domain.fTop <= domain.fBottom);
clippedDomain.fLeft = SkMaxScalar(domain.fLeft, kFullRect.fLeft);
clippedDomain.fRight = SkMinScalar(domain.fRight, kFullRect.fRight);
clippedDomain.fTop = SkMaxScalar(domain.fTop, kFullRect.fTop);
clippedDomain.fBottom = SkMinScalar(domain.fBottom, kFullRect.fBottom);
- GrAssert(clippedDomain.fLeft <= clippedDomain.fRight);
- GrAssert(clippedDomain.fTop <= clippedDomain.fBottom);
+ SkASSERT(clippedDomain.fLeft <= clippedDomain.fRight);
+ SkASSERT(clippedDomain.fTop <= clippedDomain.fBottom);
AutoEffectUnref effect(SkNEW_ARGS(GrTextureDomainEffect, (texture,
matrix,
// Remove the specified atlas from the cache
void GrTextureStripAtlas::CleanUp(const GrContext*, void* info) {
- GrAssert(NULL != info);
+ SkASSERT(NULL != info);
AtlasEntry* entry = static_cast<AtlasEntry*>(info);
, fRows(SkNEW_ARRAY(AtlasRow, fNumRows))
, fLRUFront(NULL)
, fLRUBack(NULL) {
- GrAssert(fNumRows * fDesc.fRowHeight == fDesc.fHeight);
+ SkASSERT(fNumRows * fDesc.fRowHeight == fDesc.fHeight);
this->initLRU();
VALIDATE;
}
GrContext::kDontFlush_PixelOpsFlag);
}
- GrAssert(rowNumber >= 0);
+ SkASSERT(rowNumber >= 0);
VALIDATE;
return rowNumber;
}
VALIDATE;
--fRows[row].fLocks;
--fLockedRows;
- GrAssert(fRows[row].fLocks >= 0 && fLockedRows >= 0);
+ SkASSERT(fRows[row].fLocks >= 0 && fLockedRows >= 0);
if (0 == fRows[row].fLocks) {
this->appendLRU(fRows + row);
}
this->initLRU();
fKeyTable.rewind();
}
- GrAssert(NULL != fTexture);
+ SkASSERT(NULL != fTexture);
}
void GrTextureStripAtlas::unlockTexture() {
- GrAssert(NULL != fTexture && 0 == fLockedRows);
+ SkASSERT(NULL != fTexture && 0 == fLockedRows);
fTexture->unref();
fTexture = NULL;
fDesc.fContext->purgeCache();
fRows[i].fPrev = NULL;
this->appendLRU(fRows + i);
}
- GrAssert(NULL == fLRUFront || NULL == fLRUFront->fPrev);
- GrAssert(NULL == fLRUBack || NULL == fLRUBack->fNext);
+ SkASSERT(NULL == fLRUFront || NULL == fLRUFront->fPrev);
+ SkASSERT(NULL == fLRUBack || NULL == fLRUBack->fNext);
}
void GrTextureStripAtlas::appendLRU(AtlasRow* row) {
- GrAssert(NULL == row->fPrev && NULL == row->fNext);
+ SkASSERT(NULL == row->fPrev && NULL == row->fNext);
if (NULL == fLRUFront && NULL == fLRUBack) {
fLRUFront = row;
fLRUBack = row;
}
void GrTextureStripAtlas::removeFromLRU(AtlasRow* row) {
- GrAssert(NULL != row);
+ SkASSERT(NULL != row);
if (NULL != row->fNext && NULL != row->fPrev) {
row->fPrev->fNext = row->fNext;
row->fNext->fPrev = row->fPrev;
} else {
if (NULL == row->fNext) {
- GrAssert(row == fLRUBack);
+ SkASSERT(row == fLRUBack);
fLRUBack = row->fPrev;
if (fLRUBack) {
fLRUBack->fNext = NULL;
}
}
if (NULL == row->fPrev) {
- GrAssert(row == fLRUFront);
+ SkASSERT(row == fLRUFront);
fLRUFront = row->fNext;
if (fLRUFront) {
fLRUFront->fPrev = NULL;
// Our key table should be sorted
uint32_t prev = 1 > fKeyTable.count() ? 0 : fKeyTable[0]->fKey;
for (int i = 1; i < fKeyTable.count(); ++i) {
- GrAssert(prev < fKeyTable[i]->fKey);
- GrAssert(fKeyTable[i]->fKey != kEmptyAtlasRowKey);
+ SkASSERT(prev < fKeyTable[i]->fKey);
+ SkASSERT(fKeyTable[i]->fKey != kEmptyAtlasRowKey);
prev = fKeyTable[i]->fKey;
}
int lruCount = 0;
// Validate LRU pointers, and count LRU entries
- GrAssert(NULL == fLRUFront || NULL == fLRUFront->fPrev);
- GrAssert(NULL == fLRUBack || NULL == fLRUBack->fNext);
+ SkASSERT(NULL == fLRUFront || NULL == fLRUFront->fPrev);
+ SkASSERT(NULL == fLRUBack || NULL == fLRUBack->fNext);
for (AtlasRow* r = fLRUFront; r != NULL; r = r->fNext) {
if (NULL == r->fNext) {
- GrAssert(r == fLRUBack);
+ SkASSERT(r == fLRUBack);
} else {
- GrAssert(r->fNext->fPrev == r);
+ SkASSERT(r->fNext->fPrev == r);
}
++lruCount;
}
break;
}
}
- GrAssert(inLRU);
+ SkASSERT(inLRU);
} else {
// If we are locked, we should have a key
- GrAssert(kEmptyAtlasRowKey != fRows[i].fKey);
+ SkASSERT(kEmptyAtlasRowKey != fRows[i].fKey);
}
// If we have a key != kEmptyAtlasRowKey, it should be in the key table
- GrAssert(fRows[i].fKey == kEmptyAtlasRowKey || this->searchByKey(fRows[i].fKey) >= 0);
+ SkASSERT(fRows[i].fKey == kEmptyAtlasRowKey || this->searchByKey(fRows[i].fKey) >= 0);
}
// Our count of locks should equal the sum of row locks, unless we ran out of rows and flushed,
// in which case we'll have one more lock than recorded in the rows (to represent the pending
// lock of a row; which ensures we don't unlock the texture prematurely).
- GrAssert(rowLocks == fLockedRows || rowLocks + 1 == fLockedRows);
+ SkASSERT(rowLocks == fLockedRows || rowLocks + 1 == fLockedRows);
// We should have one lru entry for each free row
- GrAssert(freeRows == lruCount);
+ SkASSERT(freeRows == lruCount);
// If we have locked rows, we should have a locked texture, otherwise
// it should be unlocked
if (fLockedRows == 0) {
- GrAssert(NULL == fTexture);
+ SkASSERT(NULL == fTexture);
} else {
- GrAssert(NULL != fTexture);
+ SkASSERT(NULL != fTexture);
}
}
#endif
if (GR_GL_ARRAY_BUFFER == fBufferType) {
gpu->notifyVertexBufferDelete(fDesc.fID);
} else {
- GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+ SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
gpu->notifyIndexBufferDelete(fDesc.fID);
}
fDesc.fID = 0;
if (GR_GL_ARRAY_BUFFER == fBufferType) {
gpu->bindVertexBuffer(fDesc.fID);
} else {
- GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+ SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
gpu->bindIndexBufferAndDefaultVertexArray(fDesc.fID);
}
}
void* GrGLBufferImpl::lock(GrGpuGL* gpu) {
VALIDATE();
- GrAssert(!this->isLocked());
+ SkASSERT(!this->isLocked());
if (0 == fDesc.fID) {
fLockPtr = fCPUData;
} else if (gpu->caps()->bufferLockSupport()) {
void GrGLBufferImpl::unlock(GrGpuGL* gpu) {
VALIDATE();
- GrAssert(this->isLocked());
+ SkASSERT(this->isLocked());
if (0 != fDesc.fID) {
- GrAssert(gpu->caps()->bufferLockSupport());
+ SkASSERT(gpu->caps()->bufferLockSupport());
this->bind(gpu);
GL_CALL(gpu, UnmapBuffer(fBufferType));
}
}
bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) {
- GrAssert(!this->isLocked());
+ SkASSERT(!this->isLocked());
VALIDATE();
if (srcSizeInBytes > fDesc.fSizeInBytes) {
return false;
}
void GrGLBufferImpl::validate() const {
- GrAssert(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+ SkASSERT(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
// The following assert isn't valid when the buffer has been abandoned:
- // GrAssert((0 == fDesc.fID) == (NULL != fCPUData));
- GrAssert(0 != fDesc.fID || !fDesc.fIsWrapped);
- GrAssert(NULL == fCPUData || NULL == fLockPtr || fCPUData == fLockPtr);
+ // SkASSERT((0 == fDesc.fID) == (NULL != fCPUData));
+ SkASSERT(0 != fDesc.fID || !fDesc.fIsWrapped);
+ SkASSERT(NULL == fCPUData || NULL == fLockPtr || fCPUData == fLockPtr);
}
GrGLBufferImpl(GrGpuGL*, const Desc&, GrGLenum bufferType);
~GrGLBufferImpl() {
// either release or abandon should have been called by the owner of this object.
- GrAssert(0 == fDesc.fID);
+ SkASSERT(0 == fDesc.fID);
}
void abandon();
GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
&fMaxFragmentUniformVectors);
} else {
- GrAssert(kDesktop_GrGLBinding == binding);
+ SkASSERT(kDesktop_GrGLBinding == binding);
GrGLint max;
GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);
fMaxFragmentUniformVectors = max / 4;
fBGRAFormatSupport = true;
fBGRAIsInternalFormat = true;
}
- GrAssert(fBGRAFormatSupport ||
+ SkASSERT(fBGRAFormatSupport ||
kSkia8888_GrPixelConfig != kBGRA_8888_GrPixelConfig);
}
if (0 == fMSAACoverageModes.count()) {
return kNoneMode;
} else {
- GrAssert(kNone_CoverageAAType != fCoverageAAType);
+ SkASSERT(kNone_CoverageAAType != fCoverageAAType);
int max = (fMSAACoverageModes.end() - 1)->fCoverageSampleCnt;
desiredSampleCount = GrMin(desiredSampleCount, max);
MSAACoverageMode desiredMode = {desiredSampleCount, 0};
if (idx < 0) {
idx = ~idx;
}
- GrAssert(idx >= 0 && idx < fMSAACoverageModes.count());
+ SkASSERT(idx >= 0 && idx < fMSAACoverageModes.count());
return fMSAACoverageModes[idx];
}
}
fStencilFormats.push_back() = gS4;
}
}
- GrAssert(0 == fStencilVerifiedColorConfigs.count());
+ SkASSERT(0 == fStencilVerifiedColorConfigs.count());
fStencilVerifiedColorConfigs.push_back_n(fStencilFormats.count());
}
#if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT
return;
#endif
- GrAssert((unsigned)config < (unsigned)kGrPixelConfigCnt);
- GrAssert(fStencilFormats.count() == fStencilVerifiedColorConfigs.count());
+ SkASSERT((unsigned)config < (unsigned)kGrPixelConfigCnt);
+ SkASSERT(fStencilFormats.count() == fStencilVerifiedColorConfigs.count());
int count = fStencilFormats.count();
// we expect a really small number of possible formats so linear search
// should be OK
- GrAssert(count < 16);
+ SkASSERT(count < 16);
for (int i = 0; i < count; ++i) {
if (format.fInternalFormat ==
fStencilFormats[i].fInternalFormat) {
#if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT
return false;
#endif
- GrAssert((unsigned)config < (unsigned)kGrPixelConfigCnt);
+ SkASSERT((unsigned)config < (unsigned)kGrPixelConfigCnt);
int count = fStencilFormats.count();
// we expect a really small number of possible formats so linear search
// should be OK
- GrAssert(count < 16);
+ SkASSERT(count < 16);
for (int i = 0; i < count; ++i) {
if (format.fInternalFormat ==
fStencilFormats[i].fInternalFormat) {
void allocate(GrGLsizeiptr size, const GrGLchar* dataPtr) {
if (NULL != fDataPtr) {
- GrAssert(0 != fSize);
+ SkASSERT(0 != fSize);
SkDELETE_ARRAY(fDataPtr);
}
static GrBufferObj* look_up(GrGLuint id) {
GrBufferObj* buffer = gBuffers[id];
- GrAssert(NULL != buffer && buffer->id() == id);
+ SkASSERT(NULL != buffer && buffer->id() == id);
return buffer;
}
}
static void delete_buffer(GrBufferObj* buffer) {
- GrAssert(gBuffers.count() > 0);
+ SkASSERT(gBuffers.count() > 0);
GrGLuint id = buffer->id();
SkDELETE(buffer);
if (id > 0) {
GrBufferObj* buffer = look_up(id);
- GrAssert(!buffer->mapped());
+ SkASSERT(!buffer->mapped());
buffer->setMapped(true);
return buffer->dataPtr();
}
- GrAssert(false);
+ SkASSERT(false);
return NULL; // no buffer bound to target
}
}
if (id > 0) {
GrBufferObj* buffer = look_up(id);
- GrAssert(buffer->mapped());
+ SkASSERT(buffer->mapped());
buffer->setMapped(false);
return GR_GL_TRUE;
}
for (int index = 0; index < numTextures; ++index) {
const GrTextureAccess& access = (*drawEffect.effect())->textureAccess(index);
EffectKey value = GrGLShaderBuilder::KeyForTextureAccess(access, caps) << index;
- GrAssert(0 == (value & key)); // keys for each access ought not to overlap
+ SkASSERT(0 == (value & key)); // keys for each access ought not to overlap
key |= value;
}
return key;
EffectKey key = 0;
int numAttributes = drawEffect.getVertexAttribIndexCount();
- GrAssert(numAttributes <= 2);
+ SkASSERT(numAttributes <= 2);
const int* attributeIndices = drawEffect.getVertexAttribIndices();
for (int index = 0; index < numAttributes; ++index) {
EffectKey value = attributeIndices[index] << 3*index;
- GrAssert(0 == (value & key)); // keys for each attribute ought not to overlap
+ SkASSERT(0 == (value & key)); // keys for each attribute ought not to overlap
key |= value;
}
const GrGLShaderVar* coords;
switch (fCoordsType) {
case GrEffect::kLocal_CoordsType:
- GrAssert(!(kPositionCoords_Flag & key));
+ SkASSERT(!(kPositionCoords_Flag & key));
coords = &builder->localCoordsAttribute();
break;
case GrEffect::kPosition_CoordsType:
- GrAssert((kPositionCoords_Flag & key) || !builder->hasExplicitLocalCoords());
+ SkASSERT((kPositionCoords_Flag & key) || !builder->hasExplicitLocalCoords());
coords = &builder->positionAttribute();
break;
default:
// varying = matrix * coords (logically)
switch (fUniType) {
case kVoid_GrSLType:
- GrAssert(kVec2f_GrSLType == varyingType);
+ SkASSERT(kVec2f_GrSLType == varyingType);
builder->vsCodeAppendf("\t%s = %s;\n", vsVaryingName, coords->c_str());
break;
case kVec2f_GrSLType:
- GrAssert(kVec2f_GrSLType == varyingType);
+ SkASSERT(kVec2f_GrSLType == varyingType);
builder->vsCodeAppendf("\t%s = %s + %s;\n",
vsVaryingName, uniName, coords->c_str());
break;
case kMat33f_GrSLType: {
- GrAssert(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
+ SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
if (kVec2f_GrSLType == varyingType) {
builder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n",
vsVaryingName, uniName, coords->c_str());
const SkMatrix& matrix,
const GrDrawEffect& drawEffect,
const GrTexture* texture) {
- GrAssert(fUni.isValid() != (kVoid_GrSLType == fUniType));
+ SkASSERT(fUni.isValid() != (kVoid_GrSLType == fUniType));
const SkMatrix& coordChangeMatrix = GrEffect::kLocal_CoordsType == fCoordsType ?
drawEffect.getCoordChangeMatrix() :
SkMatrix::I();
switch (fUniType) {
case kVoid_GrSLType:
- GrAssert(matrix.isIdentity());
- GrAssert(coordChangeMatrix.isIdentity());
- GrAssert(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
+ SkASSERT(matrix.isIdentity());
+ SkASSERT(coordChangeMatrix.isIdentity());
+ SkASSERT(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
return;
case kVec2f_GrSLType: {
- GrAssert(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType()));
- GrAssert(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
+ SkASSERT(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType()));
+ SkASSERT(NULL == texture || kTopLeft_GrSurfaceOrigin == texture->origin());
SkScalar tx = matrix[SkMatrix::kMTransX] + (coordChangeMatrix)[SkMatrix::kMTransX];
SkScalar ty = matrix[SkMatrix::kMTransY] + (coordChangeMatrix)[SkMatrix::kMTransY];
if (fPrevMatrix.get(SkMatrix::kMTransX) != tx ||
GrGLEffectMatrix(CoordsType coordsType)
: fCoordsType(coordsType) {
- GrAssert(GrEffect::kLocal_CoordsType == coordsType ||
+ SkASSERT(GrEffect::kLocal_CoordsType == coordsType ||
GrEffect::kPosition_CoordsType == coordsType);
fPrevMatrix = SkMatrix::InvalidMatrix();
}
}
fHeight = height;
- GrAssert(fLeft >= 0);
- GrAssert(fWidth >= 0);
- GrAssert(fBottom >= 0);
- GrAssert(fHeight >= 0);
+ SkASSERT(fLeft >= 0);
+ SkASSERT(fWidth >= 0);
+ SkASSERT(fBottom >= 0);
+ SkASSERT(fHeight >= 0);
}
bool contains(const GrGLIRect& glRect) const {
private:
GrGpuGL* getGpuGL() const {
- GrAssert(this->isValid());
+ SkASSERT(this->isValid());
return (GrGpuGL*)(this->getGpu());
}
GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);
- GrAssert(verb >= 0 && (size_t)verb < GR_ARRAY_COUNT(gTable));
+ SkASSERT(verb >= 0 && (size_t)verb < GR_ARRAY_COUNT(gTable));
return gTable[verb];
}
GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);
- GrAssert(verb >= 0 && (size_t)verb < GR_ARRAY_COUNT(gTable));
+ SkASSERT(verb >= 0 && (size_t)verb < GR_ARRAY_COUNT(gTable));
return gTable[verb];
}
#endif
pathCommands[i] = verb_to_gl_path_cmd(v);
GR_DEBUGCODE(numPts += num_pts(v));
}
- GrAssert(pathPoints.count() == numPts);
+ SkASSERT(pathPoints.count() == numPts);
GL_CALL(PathCommands(fPathID,
verbCnt, &pathCommands[0],
break;
case GrGLProgramDesc::kCombineWithDst_CoverageOutput:
// We should only have set this if the blend was specified as (1, 0)
- GrAssert(kOne_GrBlendCoeff == *srcCoeff && kZero_GrBlendCoeff == *dstCoeff);
+ SkASSERT(kOne_GrBlendCoeff == *srcCoeff && kZero_GrBlendCoeff == *dstCoeff);
break;
default:
GrCrash("Unexpected coverage output");
#if GR_GL_EXPERIMENTAL_GS
// TODO: The builder should add all this glue code.
if (fDesc.getHeader().fExperimentalGS) {
- GrAssert(fContext.info().glslGeneration() >= k150_GrGLSLGeneration);
+ SkASSERT(fContext.info().glslGeneration() >= k150_GrGLSLGeneration);
builder->fGSHeader.append("layout(triangles) in;\n"
"layout(triangle_strip, max_vertices = 6) out;\n");
builder->gsCodeAppend("\tfor (int i = 0; i < 3; ++i) {\n"
if (fDesc.getHeader().fEmitsPointSize) {
builder->gsCodeAppend("\t\tgl_PointSize = 1.0;\n");
}
- GrAssert(builder->fGSInputs.count() == builder->fGSOutputs.count());
+ SkASSERT(builder->fGSInputs.count() == builder->fGSOutputs.count());
int count = builder->fGSInputs.count();
for (int i = 0; i < count; ++i) {
builder->gsCodeAppendf("\t\t%s = %s[i];\n",
print_shader(stringCnt, strings, stringLengths);
GrPrintf("\n%s", log.get());
}
- GrAssert(!"Shader compilation failed!");
+ SkASSERT(!"Shader compilation failed!");
GR_GL_CALL(gli, DeleteShader(shader));
return 0;
}
}
void expand_known_value4f(SkString* string, GrSLConstantVec vec) {
- GrAssert(string->isEmpty() == (vec != kNone_GrSLConstantVec));
+ SkASSERT(string->isEmpty() == (vec != kNone_GrSLConstantVec));
switch (vec) {
case kNone_GrSLConstantVec:
break;
bool GrGLProgram::genProgram(const GrEffectStage* colorStages[],
const GrEffectStage* coverageStages[]) {
- GrAssert(0 == fProgramID);
+ SkASSERT(0 == fProgramID);
const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
(char*)log.get()));
GrPrintf((char*)log.get());
}
- GrAssert(!"Error linking program");
+ SkASSERT(!"Error linking program");
GL_CALL(DeleteProgram(fProgramID));
fProgramID = 0;
return false;
// Bind the texures for the effect.
int numSamplers = effect.fSamplerUnis.count();
- GrAssert((*stage.getEffect())->numTextures() == numSamplers);
+ SkASSERT((*stage.getEffect())->numTextures() == numSamplers);
for (int s = 0; s < numSamplers; ++s) {
UniformHandle handle = effect.fSamplerUnis[s];
if (handle.isValid()) {
static GrTextureParams kParams; // the default is clamp, nearest filtering.
gpu->bindTexture(fDstCopyTexUnit, kParams, texture);
} else {
- GrAssert(!fUniformHandles.fDstCopyScaleUni.isValid());
- GrAssert(!fUniformHandles.fDstCopySamplerUni.isValid());
+ SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
+ SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
}
} else {
- GrAssert(!fUniformHandles.fDstCopyTopLeftUni.isValid());
- GrAssert(!fUniformHandles.fDstCopyScaleUni.isValid());
- GrAssert(!fUniformHandles.fDstCopySamplerUni.isValid());
+ SkASSERT(!fUniformHandles.fDstCopyTopLeftUni.isValid());
+ SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
+ SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
}
for (int e = 0; e < fColorEffects.count(); ++e) {
if (!drawState.hasColorVertexAttribute()) {
switch (header.fColorInput) {
case GrGLProgramDesc::kAttribute_ColorInput:
- GrAssert(-1 != header.fColorAttributeIndex);
+ SkASSERT(-1 != header.fColorAttributeIndex);
if (sharedState->fConstAttribColor != color ||
sharedState->fConstAttribColorIndex != header.fColorAttributeIndex) {
// OpenGL ES only supports the float varieties of glVertexAttrib
coverageStages->reset();
// This should already have been caught
- GrAssert(!(GrDrawState::kSkipDraw_BlendOptFlag & blendOpts));
+ SkASSERT(!(GrDrawState::kSkipDraw_BlendOptFlag & blendOpts));
bool skipCoverage = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag);
}
if (readsDst) {
- GrAssert(NULL != dstCopy || gpu->caps()->dstReadInShaderSupport());
+ SkASSERT(NULL != dstCopy || gpu->caps()->dstReadInShaderSupport());
const GrTexture* dstCopyTexture = NULL;
if (NULL != dstCopy) {
dstCopyTexture = dstCopy->texture();
}
header->fDstReadKey = GrGLShaderBuilder::KeyForDstRead(dstCopyTexture, gpu->glCaps());
- GrAssert(0 != header->fDstReadKey);
+ SkASSERT(0 != header->fDstReadKey);
} else {
header->fDstReadKey = 0;
}
if (requiresColorAttrib) {
header->fColorAttributeIndex = drawState.colorVertexAttributeIndex();
} else if (GrGLProgramDesc::kAttribute_ColorInput == header->fColorInput) {
- GrAssert(availableAttributeIndex < GrDrawState::kMaxVertexAttribCnt);
+ SkASSERT(availableAttributeIndex < GrDrawState::kMaxVertexAttribCnt);
header->fColorAttributeIndex = availableAttributeIndex;
availableAttributeIndex++;
} else {
if (requiresCoverageAttrib) {
header->fCoverageAttributeIndex = drawState.coverageVertexAttributeIndex();
} else if (GrGLProgramDesc::kAttribute_ColorInput == header->fCoverageInput) {
- GrAssert(availableAttributeIndex < GrDrawState::kMaxVertexAttribCnt);
+ SkASSERT(availableAttributeIndex < GrDrawState::kMaxVertexAttribCnt);
header->fCoverageAttributeIndex = availableAttributeIndex;
} else {
header->fCoverageAttributeIndex = -1;
// Returns this as a uint32_t array to be used as a key in the program cache.
const uint32_t* asKey() const {
- GrAssert(fInitialized);
+ SkASSERT(fInitialized);
return reinterpret_cast<const uint32_t*>(fKey.get());
}
GrGLProgramDesc* outDesc);
int numColorEffects() const {
- GrAssert(fInitialized);
+ SkASSERT(fInitialized);
return this->getHeader().fColorEffectCnt;
}
int numCoverageEffects() const {
- GrAssert(fInitialized);
+ SkASSERT(fInitialized);
return this->getHeader().fCoverageEffectCnt;
}
GrGLProgramDesc& operator= (const GrGLProgramDesc& other);
bool operator== (const GrGLProgramDesc& other) const {
- GrAssert(fInitialized && other.fInitialized);
+ SkASSERT(fInitialized && other.fInitialized);
// The length is masked as a hint to the compiler that the address will be 4 byte aligned.
return 0 == memcmp(this->asKey(), other.asKey(), this->keyLength() & ~0x3);
}
viewport.fWidth, viewport.fHeight,
desc.fConfig, desc.fSampleCnt,
desc.fOrigin)) {
- GrAssert(NULL != texID);
- GrAssert(NULL != texture);
+ SkASSERT(NULL != texID);
+ SkASSERT(NULL != texture);
// FBO 0 can't also be a texture, right?
- GrAssert(0 != desc.fRTFBOID);
- GrAssert(0 != desc.fTexFBOID);
+ SkASSERT(0 != desc.fRTFBOID);
+ SkASSERT(0 != desc.fTexFBOID);
// we assume this is true, TODO: get rid of viewport as a param.
- GrAssert(viewport.fWidth == texture->width());
- GrAssert(viewport.fHeight == texture->height());
+ SkASSERT(viewport.fWidth == texture->width());
+ SkASSERT(viewport.fHeight == texture->height());
this->init(desc, viewport, texID);
}
GrGLSLVersion ver = GrGLGetGLSLVersion(gl);
switch (binding) {
case kDesktop_GrGLBinding:
- GrAssert(ver >= GR_GLSL_VER(1,10));
+ SkASSERT(ver >= GR_GLSL_VER(1,10));
if (ver >= GR_GLSL_VER(1,50)) {
return k150_GrGLSLGeneration;
} else if (ver >= GR_GLSL_VER(1,40)) {
}
case kES_GrGLBinding:
// version 1.00 of ES GLSL based on ver 1.20 of desktop GLSL
- GrAssert(ver >= GR_GL_VER(1,00));
+ SkASSERT(ver >= GR_GL_VER(1,00));
return k110_GrGLSLGeneration;
default:
GrCrash("Unknown GL Binding");
// 1.00 of the ES language.
return "#version 100\n";
} else {
- GrAssert(kDesktop_GrGLBinding == binding);
+ SkASSERT(kDesktop_GrGLBinding == binding);
return "#version 110\n";
}
case k130_GrGLSLGeneration:
- GrAssert(kDesktop_GrGLBinding == binding);
+ SkASSERT(kDesktop_GrGLBinding == binding);
return "#version 130\n";
case k140_GrGLSLGeneration:
- GrAssert(kDesktop_GrGLBinding == binding);
+ SkASSERT(kDesktop_GrGLBinding == binding);
return "#version 140\n";
case k150_GrGLSLGeneration:
- GrAssert(kDesktop_GrGLBinding == binding);
+ SkASSERT(kDesktop_GrGLBinding == binding);
return "#version 150\n";
default:
GrCrash("Unknown GL version.");
const char* GrGLSLVectorHomogCoord(int count) {
static const char* HOMOGS[] = {"ERROR", "", ".y", ".z", ".w"};
- GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(HOMOGS));
+ SkASSERT(count >= 1 && count < (int)GR_ARRAY_COUNT(HOMOGS));
return HOMOGS[count];
}
const char* GrGLSLVectorNonhomogCoords(int count) {
static const char* NONHOMOGS[] = {"ERROR", "", ".x", ".xy", ".xyz"};
- GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(NONHOMOGS));
+ SkASSERT(count >= 1 && count < (int)GR_ARRAY_COUNT(NONHOMOGS));
return NONHOMOGS[count];
}
GrSLConstantVec mulFactorDefault) {
bool haveFactor = NULL != mulFactor && '\0' != *mulFactor;
- GrAssert(NULL != outAppend);
- GrAssert(NULL != vec4VarName);
- GrAssert(kNone_GrSLConstantVec != mulFactorDefault || haveFactor);
+ SkASSERT(NULL != outAppend);
+ SkASSERT(NULL != vec4VarName);
+ SkASSERT(kNone_GrSLConstantVec != mulFactorDefault || haveFactor);
if (!haveFactor) {
if (kOnes_GrSLConstantVec == mulFactorDefault) {
return kNone_GrSLConstantVec;
} else {
- GrAssert(kZeros_GrSLConstantVec == mulFactorDefault);
+ SkASSERT(kZeros_GrSLConstantVec == mulFactorDefault);
append_tabs(outAppend, tabCnt);
outAppend->appendf("%s = vec4(0, 0, 0, 0);\n", vec4VarName);
return kZeros_GrSLConstantVec;
GrSLConstantVec defaultExpr,
bool omitIfConst) {
if (NULL == expr || '\0' == *expr) {
- GrAssert(defaultExpr != kNone_GrSLConstantVec);
+ SkASSERT(defaultExpr != kNone_GrSLConstantVec);
if (!omitIfConst) {
if (kOnes_GrSLConstantVec == defaultExpr) {
outAppend->append("1.0");
} else {
- GrAssert(kZeros_GrSLConstantVec == defaultExpr);
+ SkASSERT(kZeros_GrSLConstantVec == defaultExpr);
outAppend->append("0.0");
}
}
static inline const char* GrGLSLOnesVecf(int count) {
static const char* kONESVEC[] = {"ERROR", "1.0", "vec2(1,1)",
"vec3(1,1,1)", "vec4(1,1,1,1)"};
- GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(kONESVEC));
+ SkASSERT(count >= 1 && count < (int)GR_ARRAY_COUNT(kONESVEC));
return kONESVEC[count];
}
static inline const char* GrGLSLZerosVecf(int count) {
static const char* kZEROSVEC[] = {"ERROR", "0.0", "vec2(0,0)",
"vec3(0,0,0)", "vec4(0,0,0,0)"};
- GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(kZEROSVEC));
+ SkASSERT(count >= 1 && count < (int)GR_ARRAY_COUNT(kZEROSVEC));
return kZEROSVEC[count];
}
}
namespace {
template<int N>
GrSLConstantVec return_const_vecf(GrSLConstantVec constVec, SkString* outAppend, bool omitAppend) {
- GrAssert(kNone_GrSLConstantVec != constVec);
+ SkASSERT(kNone_GrSLConstantVec != constVec);
if (!omitAppend) {
if (kZeros_GrSLConstantVec == constVec) {
outAppend->append(GrGLSLZerosVecf(N));
GrSLConstantVec default0,
GrSLConstantVec default1,
bool omitIfConstVec) {
- GrAssert(N > 0 && N <= 4);
- GrAssert(NULL != outAppend);
+ SkASSERT(N > 0 && N <= 4);
+ SkASSERT(NULL != outAppend);
bool has0 = NULL != in0 && '\0' != *in0;
bool has1 = NULL != in1 && '\0' != *in1;
- GrAssert(has0 || kNone_GrSLConstantVec != default0);
- GrAssert(has1 || kNone_GrSLConstantVec != default1);
+ SkASSERT(has0 || kNone_GrSLConstantVec != default0);
+ SkASSERT(has1 || kNone_GrSLConstantVec != default1);
if (!has0 && !has1) {
- GrAssert(kZeros_GrSLConstantVec == default0 || kOnes_GrSLConstantVec == default0);
- GrAssert(kZeros_GrSLConstantVec == default1 || kOnes_GrSLConstantVec == default1);
+ SkASSERT(kZeros_GrSLConstantVec == default0 || kOnes_GrSLConstantVec == default0);
+ SkASSERT(kZeros_GrSLConstantVec == default1 || kOnes_GrSLConstantVec == default1);
if (kZeros_GrSLConstantVec == default0 || kZeros_GrSLConstantVec == default1) {
return return_const_vecf<N>(kZeros_GrSLConstantVec, outAppend, omitIfConstVec);
} else {
return return_const_vecf<N>(kOnes_GrSLConstantVec, outAppend, omitIfConstVec);
}
} else if (!has0) {
- GrAssert(kZeros_GrSLConstantVec == default0 || kOnes_GrSLConstantVec == default0);
+ SkASSERT(kZeros_GrSLConstantVec == default0 || kOnes_GrSLConstantVec == default0);
if (kZeros_GrSLConstantVec == default0) {
return return_const_vecf<N>(kZeros_GrSLConstantVec, outAppend, omitIfConstVec);
} else {
return kNone_GrSLConstantVec;
}
} else if (!has1) {
- GrAssert(kZeros_GrSLConstantVec == default1 || kOnes_GrSLConstantVec == default1);
+ SkASSERT(kZeros_GrSLConstantVec == default1 || kOnes_GrSLConstantVec == default1);
if (kZeros_GrSLConstantVec == default1) {
return return_const_vecf<N>(kZeros_GrSLConstantVec, outAppend, omitIfConstVec);
} else {
GrSLConstantVec default0,
GrSLConstantVec default1,
bool omitIfConstVec) {
- GrAssert(N > 0 && N <= 4);
- GrAssert(NULL != outAppend);
+ SkASSERT(N > 0 && N <= 4);
+ SkASSERT(NULL != outAppend);
bool has0 = NULL != in0 && '\0' != *in0;
bool has1 = NULL != in1 && '\0' != *in1;
if (!has0 && !has1) {
- GrAssert(kNone_GrSLConstantVec != default0);
- GrAssert(kNone_GrSLConstantVec != default1);
+ SkASSERT(kNone_GrSLConstantVec != default0);
+ SkASSERT(kNone_GrSLConstantVec != default1);
int sum = (kOnes_GrSLConstantVec == default0) + (kOnes_GrSLConstantVec == default1);
if (0 == sum) {
return return_const_vecf<N>(kZeros_GrSLConstantVec, outAppend, omitIfConstVec);
outAppend->append(GrGLSLOnesVecf(N));
return return_const_vecf<N>(kOnes_GrSLConstantVec, outAppend, omitIfConstVec);
} else {
- GrAssert(2 == sum);
+ SkASSERT(2 == sum);
outAppend->appendf("%s(2)", GrGLSLFloatVectorTypeString(N));
return kNone_GrSLConstantVec;
}
} else if (!has0) {
- GrAssert(kNone_GrSLConstantVec != default0);
+ SkASSERT(kNone_GrSLConstantVec != default0);
if (kZeros_GrSLConstantVec == default0) {
outAppend->appendf("%s(%s)", GrGLSLFloatVectorTypeString(N), in1);
} else {
}
return kNone_GrSLConstantVec;
} else if (!has1) {
- GrAssert(kNone_GrSLConstantVec != default1);
+ SkASSERT(kNone_GrSLConstantVec != default1);
if (kZeros_GrSLConstantVec == default1) {
outAppend->appendf("%s(%s)", GrGLSLFloatVectorTypeString(N), in0);
} else {
GrSLConstantVec default0,
GrSLConstantVec default1,
bool omitIfConstVec) {
- GrAssert(N > 0 && N <= 4);
- GrAssert(NULL != outAppend);
+ SkASSERT(N > 0 && N <= 4);
+ SkASSERT(NULL != outAppend);
bool has0 = NULL != in0 && '\0' != *in0;
bool has1 = NULL != in1 && '\0' != *in1;
if (!has0 && !has1) {
- GrAssert(kNone_GrSLConstantVec != default0);
- GrAssert(kNone_GrSLConstantVec != default1);
+ SkASSERT(kNone_GrSLConstantVec != default0);
+ SkASSERT(kNone_GrSLConstantVec != default1);
int diff = (kOnes_GrSLConstantVec == default0) - (kOnes_GrSLConstantVec == default1);
if (-1 == diff) {
outAppend->appendf("%s(-1)", GrGLSLFloatVectorTypeString(N));
} else if (0 == diff) {
return return_const_vecf<N>(kZeros_GrSLConstantVec, outAppend, omitIfConstVec);
} else {
- GrAssert(1 == diff);
+ SkASSERT(1 == diff);
return return_const_vecf<N>(kOnes_GrSLConstantVec, outAppend, omitIfConstVec);
}
} else if (!has0) {
- GrAssert(kNone_GrSLConstantVec != default0);
+ SkASSERT(kNone_GrSLConstantVec != default0);
if (kZeros_GrSLConstantVec == default0) {
outAppend->appendf("-%s(%s)", GrGLSLFloatVectorTypeString(N), in1);
} else {
}
return kNone_GrSLConstantVec;
} else if (!has1) {
- GrAssert(kNone_GrSLConstantVec != default1);
+ SkASSERT(kNone_GrSLConstantVec != default1);
if (kZeros_GrSLConstantVec == default1) {
outAppend->appendf("%s(%s)", GrGLSLFloatVectorTypeString(N), in0);
} else {
if (kVec2f_GrSLType == type) {
return glslGen >= k130_GrGLSLGeneration ? "texture" : "texture2D";
} else {
- GrAssert(kVec3f_GrSLType == type);
+ SkASSERT(kVec3f_GrSLType == type);
return glslGen >= k130_GrGLSLGeneration ? "textureProj" : "texture2DProj";
}
}
const GrGLShaderBuilder::TextureSampler& sampler,
const char* coordName,
GrSLType varyingType) const {
- GrAssert(NULL != coordName);
+ SkASSERT(NULL != coordName);
out->appendf("%s(%s, %s)",
sample_function_name(varyingType, fCtxInfo.glslGeneration()),
const GrGLShaderBuilder::TextureSampler& sampler,
const char* coordName,
GrSLType varyingType) {
- GrAssert(kFragment_ShaderType == type);
+ SkASSERT(kFragment_ShaderType == type);
this->appendTextureLookup(&fFSCode, sampler, coordName, varyingType);
}
const GrGLShaderBuilder::TextureSampler& sampler,
const char* coordName,
GrSLType varyingType) {
- GrAssert(kFragment_ShaderType == type);
+ SkASSERT(kFragment_ShaderType == type);
SkString lookup;
this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
GrGLSLModulatef<4>(&fFSCode, modulation, lookup.c_str());
if (GrGLCaps::kNone_FBFetchType != caps.fbFetchType()) {
return key;
}
- GrAssert(NULL != dstCopy);
+ SkASSERT(NULL != dstCopy);
if (!caps.textureSwizzleSupport() && GrPixelConfigIsAlphaOnly(dstCopy->config())) {
// The fact that the config is alpha-only must be considered when generating code.
key |= kUseAlphaConfig_DstReadKeyBit;
if (kTopLeft_GrSurfaceOrigin == dstCopy->origin()) {
key |= kTopLeftOrigin_DstReadKeyBit;
}
- GrAssert(static_cast<DstReadKey>(key) == key);
+ SkASSERT(static_cast<DstReadKey>(key) == key);
return static_cast<DstReadKey>(key);
}
const char* name,
int count,
const char** outName) {
- GrAssert(name && strlen(name));
+ SkASSERT(name && strlen(name));
SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_ShaderType | kFragment_ShaderType);
- GrAssert(0 == (~kVisibilityMask & visibility));
- GrAssert(0 != visibility);
+ SkASSERT(0 == (~kVisibilityMask & visibility));
+ SkASSERT(0 != visibility);
BuilderUniform& uni = fUniforms.push_back();
UniformHandle h = GrGLUniformManager::UniformHandle::CreateFromUniformIndex(fUniforms.count() - 1);
fUniformManager.appendUniform(type, count);
// We expect the uniform manager to initially have no uniforms and that all uniforms are added
// by this function. Therefore, the handles should match.
- GrAssert(h2 == h);
+ SkASSERT(h2 == h);
uni.fVariable.setType(type);
uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
this->nameVariable(uni.fVariable.accessName(), 'u', name);
const GrGLShaderVar& attr = fVSAttrs[i];
// if attribute already added, don't add it again
if (attr.getName().equals(name)) {
- GrAssert(attr.getType() == type);
+ SkASSERT(attr.getType() == type);
return false;
}
}
// temporarily change the stage index because we're inserting non-stage code.
CodeStage::AutoStageRestore csar(&fCodeStage, NULL);
- GrAssert(!fRTHeightUniform.isValid());
+ SkASSERT(!fRTHeightUniform.isValid());
const char* rtHeightName;
fRTHeightUniform = this->addUniform(kFragment_ShaderType,
kCoordName, rtHeightName);
fSetupFragPosition = true;
}
- GrAssert(fRTHeightUniform.isValid());
+ SkASSERT(fRTHeightUniform.isValid());
return kCoordName;
}
}
const GrGLShaderVar* args,
const char* body,
SkString* outName) {
- GrAssert(kFragment_ShaderType == shader);
+ SkASSERT(kFragment_ShaderType == shader);
fFSFunctions.append(GrGLSLTypeString(returnType));
this->nameVariable(outName, '\0', name);
fFSFunctions.appendf(" %s", outName->c_str());
this->appendUniformDecls(kFragment_ShaderType, shaderStr);
this->appendDecls(fFSInputs, shaderStr);
// We shouldn't have declared outputs on 1.10
- GrAssert(k110_GrGLSLGeneration != fCtxInfo.glslGeneration() || fFSOutputs.empty());
+ SkASSERT(k110_GrGLSLGeneration != fCtxInfo.glslGeneration() || fFSOutputs.empty());
this->appendDecls(fFSOutputs, shaderStr);
shaderStr->append(fFSFunctions);
shaderStr->append("void main() {\n");
SkString outColor;
for (int e = 0; e < effectCnt; ++e) {
- GrAssert(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());
+ SkASSERT(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());
const GrEffectStage& stage = *effectStages[e];
const GrEffectRef& effect = *stage.getEffect();
TextureSampler(const TextureSampler& other) { *this = other; }
TextureSampler& operator= (const TextureSampler& other) {
- GrAssert(0 == fConfigComponentMask);
- GrAssert(!fSamplerUniform.isValid());
+ SkASSERT(0 == fConfigComponentMask);
+ SkASSERT(!fSamplerUniform.isValid());
fConfigComponentMask = other.fConfigComponentMask;
fSamplerUniform = other.fSamplerUniform;
uint32_t configComponentMask,
const char* swizzle,
int idx) {
- GrAssert(!this->isInitialized());
- GrAssert(0 != configComponentMask);
- GrAssert(!fSamplerUniform.isValid());
+ SkASSERT(!this->isInitialized());
+ SkASSERT(0 != configComponentMask);
+ SkASSERT(!fSamplerUniform.isValid());
- GrAssert(NULL != builder);
+ SkASSERT(NULL != builder);
SkString name;
name.printf("Sampler%d", idx);
fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
kSampler2D_GrSLType,
name.c_str());
- GrAssert(fSamplerUniform.isValid());
+ SkASSERT(fSamplerUniform.isValid());
fConfigComponentMask = configComponentMask;
memcpy(fSwizzle, swizzle, 4);
}
void init(GrGLShaderBuilder* builder, const GrTextureAccess* access, int idx) {
- GrAssert(NULL != access);
+ SkASSERT(NULL != access);
this->init(builder,
GrPixelConfigComponentMask(access->getTexture()->config()),
access->getSwizzle(),
class AutoStageRestore : GrNoncopyable {
public:
AutoStageRestore(CodeStage* codeStage, const GrEffectStage* newStage) {
- GrAssert(NULL != codeStage);
+ SkASSERT(NULL != codeStage);
fSavedIndex = codeStage->fCurrentIndex;
fSavedEffectStage = codeStage->fEffectStage;
const GrEffectStage* fSavedEffectStage;
};
private:
- void validate() const { GrAssert((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
+ void validate() const { SkASSERT((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
int fNextIndex;
int fCurrentIndex;
const GrEffectStage* fEffectStage;
GrGLShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray,
Precision precision = kDefault_Precision) {
- GrAssert(kVoid_GrSLType != type);
+ SkASSERT(kVoid_GrSLType != type);
fType = type;
fTypeModifier = kNone_TypeModifier;
fCount = arrayCount;
, fPrecision(var.fPrecision)
, fOrigin(var.fOrigin)
, fUseUniformFloatArrays(var.fUseUniformFloatArrays) {
- GrAssert(kVoid_GrSLType != var.fType);
+ SkASSERT(kVoid_GrSLType != var.fType);
}
/**
Precision precision = kDefault_Precision,
Origin origin = kDefault_Origin,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
- GrAssert(kVoid_GrSLType != type);
+ SkASSERT(kVoid_GrSLType != type);
fType = type;
fTypeModifier = typeModifier;
fName = name;
Precision precision = kDefault_Precision,
Origin origin = kDefault_Origin,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
- GrAssert(kVoid_GrSLType != type);
+ SkASSERT(kVoid_GrSLType != type);
fType = type;
fTypeModifier = typeModifier;
fName = name;
Precision precision = kDefault_Precision,
Origin origin = kDefault_Origin,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
- GrAssert(kVoid_GrSLType != type);
+ SkASSERT(kVoid_GrSLType != type);
fType = type;
fTypeModifier = typeModifier;
fName = name;
Precision precision = kDefault_Precision,
Origin origin = kDefault_Origin,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
- GrAssert(kVoid_GrSLType != type);
+ SkASSERT(kVoid_GrSLType != type);
fType = type;
fTypeModifier = typeModifier;
fName = name;
GrGLSLTypeString(effectiveType),
this->getName().c_str());
} else {
- GrAssert(this->getArrayCount() > 0);
+ SkASSERT(this->getArrayCount() > 0);
out->appendf("%s %s[%d]",
GrGLSLTypeString(effectiveType),
this->getName().c_str(),
const Desc& textureDesc,
const GrGLRenderTarget::Desc* rtDesc) {
- GrAssert(0 != textureDesc.fTextureID);
+ SkASSERT(0 != textureDesc.fTextureID);
fTexParams.invalidate();
fTexParamsTimestamp = GrGpu::kExpiredTimestamp;
#include "SkMatrix.h"
#define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, OFFSET, COUNT) \
- GrAssert(offset + arrayCount <= uni.fArrayCount || \
+ SkASSERT(offset + arrayCount <= uni.fArrayCount || \
(0 == offset && 1 == arrayCount && GrGLShaderVar::kNonArray == uni.fArrayCount))
GrGLUniformManager::UniformHandle GrGLUniformManager::appendUniform(GrSLType type, int arrayCount) {
int idx = fUniforms.count();
Uniform& uni = fUniforms.push_back();
- GrAssert(GrGLShaderVar::kNonArray == arrayCount || arrayCount > 0);
+ SkASSERT(GrGLShaderVar::kNonArray == arrayCount || arrayCount > 0);
uni.fArrayCount = arrayCount;
uni.fType = type;
uni.fVSLocation = kUnusedUniform;
void GrGLUniformManager::setSampler(UniformHandle u, GrGLint texUnit) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kSampler2D_GrSLType);
- GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+ SkASSERT(uni.fType == kSampler2D_GrSLType);
+ SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
// FIXME: We still insert a single sampler uniform for every stage. If the shader does not
// reference the sampler then the compiler may have optimized it out. Uncomment this assert
// once stages insert their own samplers.
- // GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ // SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform1i(uni.fFSLocation, texUnit));
}
void GrGLUniformManager::set1f(UniformHandle u, GrGLfloat v0) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kFloat_GrSLType);
- GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(uni.fType == kFloat_GrSLType);
+ SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform1f(uni.fFSLocation, v0));
}
int arrayCount,
const GrGLfloat v[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kFloat_GrSLType);
- GrAssert(arrayCount > 0);
+ SkASSERT(uni.fType == kFloat_GrSLType);
+ SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
// This assert fires in some instances of the two-pt gradient for its VSParams.
// Once the uniform manager is responsible for inserting the duplicate uniform
// arrays in VS and FS driver bug workaround, this can be enabled.
- //GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ //SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform1fv(uni.fFSLocation + offset, arrayCount, v));
}
void GrGLUniformManager::set2f(UniformHandle u, GrGLfloat v0, GrGLfloat v1) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kVec2f_GrSLType);
- GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(uni.fType == kVec2f_GrSLType);
+ SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform2f(uni.fFSLocation, v0, v1));
}
int arrayCount,
const GrGLfloat v[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kVec2f_GrSLType);
- GrAssert(arrayCount > 0);
+ SkASSERT(uni.fType == kVec2f_GrSLType);
+ SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform2fv(uni.fFSLocation + offset, arrayCount, v));
}
void GrGLUniformManager::set3f(UniformHandle u, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kVec3f_GrSLType);
- GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(uni.fType == kVec3f_GrSLType);
+ SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform3f(uni.fFSLocation, v0, v1, v2));
}
int arrayCount,
const GrGLfloat v[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kVec3f_GrSLType);
- GrAssert(arrayCount > 0);
+ SkASSERT(uni.fType == kVec3f_GrSLType);
+ SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform3fv(uni.fFSLocation + offset, arrayCount, v));
}
GrGLfloat v2,
GrGLfloat v3) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kVec4f_GrSLType);
- GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(uni.fType == kVec4f_GrSLType);
+ SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform4f(uni.fFSLocation, v0, v1, v2, v3));
}
int arrayCount,
const GrGLfloat v[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kVec4f_GrSLType);
- GrAssert(arrayCount > 0);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(uni.fType == kVec4f_GrSLType);
+ SkASSERT(arrayCount > 0);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), Uniform4fv(uni.fFSLocation + offset, arrayCount, v));
}
void GrGLUniformManager::setMatrix3f(UniformHandle u, const GrGLfloat matrix[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kMat33f_GrSLType);
- GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
+ SkASSERT(uni.fType == kMat33f_GrSLType);
+ SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
// TODO: Re-enable this assert once texture matrices aren't forced on all effects
- // GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ // SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), UniformMatrix3fv(uni.fFSLocation, 1, false, matrix));
}
void GrGLUniformManager::setMatrix4f(UniformHandle u, const GrGLfloat matrix[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kMat44f_GrSLType);
- GrAssert(GrGLShaderVar::kNonArray == uni.fArrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(uni.fType == kMat44f_GrSLType);
+ SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(), UniformMatrix4fv(uni.fFSLocation, 1, false, matrix));
}
int arrayCount,
const GrGLfloat matrices[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kMat33f_GrSLType);
- GrAssert(arrayCount > 0);
+ SkASSERT(uni.fType == kMat33f_GrSLType);
+ SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(),
UniformMatrix3fv(uni.fFSLocation + offset, arrayCount, false, matrices));
int arrayCount,
const GrGLfloat matrices[]) const {
const Uniform& uni = fUniforms[u.toUniformIndex()];
- GrAssert(uni.fType == kMat44f_GrSLType);
- GrAssert(arrayCount > 0);
+ SkASSERT(uni.fType == kMat44f_GrSLType);
+ SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, offset, arrayCount);
- GrAssert(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
+ SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
if (kUnusedUniform != uni.fFSLocation) {
GR_GL_CALL(fContext.interface(),
UniformMatrix4fv(uni.fFSLocation + offset, arrayCount, false, matrices));
void GrGLUniformManager::getUniformLocations(GrGLuint programID, const BuilderUniformArray& uniforms) {
- GrAssert(uniforms.count() == fUniforms.count());
+ SkASSERT(uniforms.count() == fUniforms.count());
int count = fUniforms.count();
for (int i = 0; i < count; ++i) {
- GrAssert(uniforms[i].fVariable.getType() == fUniforms[i].fType);
- GrAssert(uniforms[i].fVariable.getArrayCount() == fUniforms[i].fArrayCount);
+ SkASSERT(uniforms[i].fVariable.getType() == fUniforms[i].fType);
+ SkASSERT(uniforms[i].fVariable.getArrayCount() == fUniforms[i].fArrayCount);
GrGLint location;
// TODO: Move the Xoom uniform array in both FS and VS bug workaround here.
GR_GL_CALL_RET(fContext.interface(), location,
private:
UniformHandle(int value)
: fValue(~value) {
- GrAssert(isValid());
+ SkASSERT(isValid());
}
- int toUniformIndex() const { GrAssert(isValid()); return ~fValue; }
+ int toUniformIndex() const { SkASSERT(isValid()); return ~fValue; }
int fValue;
friend class GrGLUniformManager; // For accessing toUniformIndex().
GrGLBinding GrGLGetBindingInUseFromString(const char* versionString) {
if (NULL == versionString) {
- GrAssert(!"NULL GL version string.");
+ SkASSERT(!"NULL GL version string.");
return kNone_GrGLBinding;
}
GrGLVersion GrGLGetVersionFromString(const char* versionString) {
if (NULL == versionString) {
- GrAssert(!"NULL GL version string.");
+ SkASSERT(!"NULL GL version string.");
return 0;
}
GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString) {
if (NULL == versionString) {
- GrAssert(!"NULL GLSL version string.");
+ SkASSERT(!"NULL GLSL version string.");
return 0;
}
GrGLboolean normalized,
GrGLsizei stride,
GrGLvoid* offset) {
- GrAssert(index >= 0 && index < fAttribArrayStates.count());
+ SkASSERT(index >= 0 && index < fAttribArrayStates.count());
AttribArrayState* array = &fAttribArrayStates[index];
if (!array->fEnableIsValid || !array->fEnabled) {
GR_GL_CALL(gpu->glInterface(), EnableVertexAttribArray(index));
};
static inline const GrGLAttribLayout& GrGLAttribTypeToLayout(GrVertexAttribType type) {
- GrAssert(type >= 0 && type < kGrVertexAttribTypeCount);
+ SkASSERT(type >= 0 && type < kGrVertexAttribTypeCount);
static const GrGLAttribLayout kLayouts[kGrVertexAttribTypeCount] = {
{1, GR_GL_FLOAT, false}, // kFloat_GrVertexAttribType
{2, GR_GL_FLOAT, false}, // kVec2f_GrVertexAttribType
private:
GrGpuGL* getGpuGL() const {
- GrAssert(this->isValid());
+ SkASSERT(this->isValid());
return (GrGpuGL*)(this->getGpu());
}
: GrGpu(context)
, fGLContext(ctx) {
- GrAssert(ctx.isInitialized());
+ SkASSERT(ctx.isInitialized());
fCaps.reset(SkRef(ctx.info().caps()));
fProgramCache = SkNEW_ARGS(ProgramCache, (this->glContext()));
- GrAssert(this->glCaps().maxVertexAttributes() >= GrDrawState::kMaxVertexAttribCnt);
+ SkASSERT(this->glCaps().maxVertexAttributes() >= GrDrawState::kMaxVertexAttribCnt);
fLastSuccessfulStencilFmtIdx = 0;
fHWProgramID = 0;
if (0 != fHWProgramID) {
// detach the current program so there is no confusion on OpenGL's part
// that we want it to be deleted
- GrAssert(fHWProgramID == fCurrentProgram->programID());
+ SkASSERT(fHWProgramID == fCurrentProgram->programID());
GL_CALL(UseProgram(0));
}
GrPixelConfig dataConfig,
const void* data,
size_t rowBytes) {
- GrAssert(NULL != data || isNewTexture);
+ SkASSERT(NULL != data || isNewTexture);
size_t bpp = GrBytesPerPixel(dataConfig);
if (!adjust_pixel_ops_params(desc.fWidth, desc.fHeight, bpp, &left, &top,
}
if (restoreGLRowLength) {
- GrAssert(this->glCaps().unpackRowLengthSupport());
+ SkASSERT(this->glCaps().unpackRowLengthSupport());
GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
}
if (glFlipY) {
GrGLenum format,
int width, int height) {
CLEAR_ERROR_BEFORE_ALLOC(ctx.interface());
- GrAssert(GrGLCaps::kNone_MSFBOType != ctx.info().caps()->msFBOType());
+ SkASSERT(GrGLCaps::kNone_MSFBOType != ctx.info().caps()->msFBOType());
bool created = false;
if (GrGLCaps::kNVDesktop_CoverageAAType ==
ctx.info().caps()->coverageAAType()) {
// below here we may bind the FBO
fHWBoundRenderTarget = NULL;
if (desc->fRTFBOID != desc->fTexFBOID) {
- GrAssert(desc->fSampleCnt > 0);
+ SkASSERT(desc->fSampleCnt > 0);
GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER,
desc->fMSColorRenderbufferID));
if (!renderbuffer_storage_msaa(fGLContext,
// good to set a break-point here to know when createTexture fails
static GrTexture* return_null_texture() {
-// GrAssert(!"null texture");
+// SkASSERT(!"null texture");
return NULL;
}
GrGLRenderTarget::Desc glRTDesc;
// Attempt to catch un- or wrongly initialized sample counts;
- GrAssert(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
+ SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
// We fail if the MSAA was requested and is not available.
if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType() && desc.fSampleCnt) {
//GrPrintf("MSAA RT requested but not supported on this platform.");
GrGLStencilBuffer::Format* format) {
// we shouldn't ever know one size and not the other
- GrAssert((kUnknownBitCount == format->fStencilBits) ==
+ SkASSERT((kUnknownBitCount == format->fStencilBits) ==
(kUnknownBitCount == format->fTotalBits));
if (kUnknownBitCount == format->fStencilBits) {
GR_GL_GetRenderbufferParameteriv(gl, GR_GL_RENDERBUFFER,
// All internally created RTs are also textures. We don't create
// SBs for a client's standalone RT (that is a RT that isn't also a texture).
- GrAssert(rt->asTexture());
- GrAssert(width >= rt->width());
- GrAssert(height >= rt->height());
+ SkASSERT(rt->asTexture());
+ SkASSERT(width >= rt->width());
+ SkASSERT(height >= rt->height());
int samples = rt->numSamples();
GrGLuint sbID;
#if GR_DEBUG
GrGLenum status;
GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
- GrAssert(GR_GL_FRAMEBUFFER_COMPLETE == status);
+ SkASSERT(GR_GL_FRAMEBUFFER_COMPLETE == status);
#endif
}
return true;
}
GrPath* GrGpuGL::onCreatePath(const SkPath& inPath) {
- GrAssert(this->caps()->pathStencilingSupport());
+ SkASSERT(this->caps()->pathStencilingSupport());
return SkNEW_ARGS(GrGLPath, (this, inPath));
}
const GrGLRenderTarget* rt =
static_cast<const GrGLRenderTarget*>(drawState.getRenderTarget());
- GrAssert(NULL != rt);
+ SkASSERT(NULL != rt);
const GrGLIRect& vp = rt->getViewport();
if (fScissorState.fEnabled) {
const GrDrawState& drawState = this->getDrawState();
const GrRenderTarget* rt = drawState.getRenderTarget();
// parent class should never let us get here with no RT
- GrAssert(NULL != rt);
+ SkASSERT(NULL != rt);
SkIRect clippedRect;
if (NULL != rect) {
void GrGpuGL::clearStencilClip(const SkIRect& rect, bool insideClip) {
const GrDrawState& drawState = this->getDrawState();
const GrRenderTarget* rt = drawState.getRenderTarget();
- GrAssert(NULL != rt);
+ SkASSERT(NULL != rt);
// this should only be called internally when we know we have a
// stencil buffer.
- GrAssert(NULL != rt->getStencilBuffer());
+ SkASSERT(NULL != rt->getStencilBuffer());
GrGLint stencilBitCount = rt->getStencilBuffer()->bits();
#if 0
- GrAssert(stencilBitCount > 0);
+ SkASSERT(stencilBitCount > 0);
GrGLint clipStencilMask = (1 << (stencilBitCount - 1));
#else
// we could just clear the clip bit but when we go through
SkAutoSMalloc<32 * sizeof(GrColor)> scratch;
if (rowBytes != tightRowBytes) {
if (this->glCaps().packRowLengthSupport()) {
- GrAssert(!(rowBytes % sizeof(GrColor)));
+ SkASSERT(!(rowBytes % sizeof(GrColor)));
GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, rowBytes / sizeof(GrColor)));
readDstRowBytes = rowBytes;
} else {
readRect.fWidth, readRect.fHeight,
format, type, readDst));
if (readDstRowBytes != tightRowBytes) {
- GrAssert(this->glCaps().packRowLengthSupport());
+ SkASSERT(this->glCaps().packRowLengthSupport());
GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
}
if (flipY && this->glCaps().packFlipYSupport()) {
// API presents top-to-bottom. We must preserve the padding contents. Note
// that the above readPixels did not overwrite the padding.
if (readDst == buffer) {
- GrAssert(rowBytes == readDstRowBytes);
+ SkASSERT(rowBytes == readDstRowBytes);
if (flipY) {
scratch.reset(tightRowBytes);
void* tmpRow = scratch.get();
}
}
} else {
- GrAssert(readDst != buffer); GrAssert(rowBytes != tightRowBytes);
+ SkASSERT(readDst != buffer); SkASSERT(rowBytes != tightRowBytes);
// copy from readDst to buffer while flipping y
// const int halfY = height >> 1;
const char* src = reinterpret_cast<const char*>(readDst);
GrGLRenderTarget* rt =
static_cast<GrGLRenderTarget*>(this->drawState()->getRenderTarget());
- GrAssert(NULL != rt);
+ SkASSERT(NULL != rt);
if (fHWBoundRenderTarget != rt) {
GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, rt->renderFBOID()));
size_t indexOffsetInBytes;
this->setupGeometry(info, &indexOffsetInBytes);
- GrAssert((size_t)info.primitiveType() < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
+ SkASSERT((size_t)info.primitiveType() < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
if (info.isIndexed()) {
GrGLvoid* indices =
}
void GrGpuGL::onGpuStencilPath(const GrPath* path, SkPath::FillType fill) {
- GrAssert(this->caps()->pathStencilingSupport());
+ SkASSERT(this->caps()->pathStencilingSupport());
GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
GrDrawState* drawState = this->drawState();
- GrAssert(NULL != drawState->getRenderTarget());
+ SkASSERT(NULL != drawState->getRenderTarget());
if (NULL == drawState->getRenderTarget()->getStencilBuffer()) {
return;
}
// Decide how to manipulate the stencil buffer based on the fill rule.
// Also, assert that the stencil settings we set in setStencilPathSettings
// are present.
- GrAssert(!fStencilSettings.isTwoSided());
+ SkASSERT(!fStencilSettings.isTwoSided());
GrGLenum fillMode;
switch (fill) {
case SkPath::kWinding_FillType:
fillMode = GR_GL_COUNT_UP;
- GrAssert(kIncClamp_StencilOp ==
+ SkASSERT(kIncClamp_StencilOp ==
fStencilSettings.passOp(GrStencilSettings::kFront_Face));
- GrAssert(kIncClamp_StencilOp ==
+ SkASSERT(kIncClamp_StencilOp ==
fStencilSettings.failOp(GrStencilSettings::kFront_Face));
break;
case SkPath::kEvenOdd_FillType:
fillMode = GR_GL_INVERT;
- GrAssert(kInvert_StencilOp ==
+ SkASSERT(kInvert_StencilOp ==
fStencilSettings.passOp(GrStencilSettings::kFront_Face));
- GrAssert(kInvert_StencilOp ==
+ SkASSERT(kInvert_StencilOp ==
fStencilSettings.failOp(GrStencilSettings::kFront_Face));
break;
default:
if (rt->needsResolve()) {
// Some extensions automatically resolves the texture when it is read.
if (this->glCaps().usesMSAARenderBuffers()) {
- GrAssert(rt->textureFBOID() != rt->renderFBOID());
+ SkASSERT(rt->textureFBOID() != rt->renderFBOID());
GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER, rt->renderFBOID()));
GL_CALL(BindFramebuffer(GR_GL_DRAW_FRAMEBUFFER, rt->textureFBOID()));
// make sure we go through flushRenderTarget() since we've modified
GR_STATIC_ASSERT(5 == kLEqual_StencilFunc);
GR_STATIC_ASSERT(6 == kEqual_StencilFunc);
GR_STATIC_ASSERT(7 == kNotEqual_StencilFunc);
- GrAssert((unsigned) basicFunc < kBasicStencilFuncCount);
+ SkASSERT((unsigned) basicFunc < kBasicStencilFuncCount);
return gTable[basicFunc];
}
GR_STATIC_ASSERT(5 == kDecClamp_StencilOp);
GR_STATIC_ASSERT(6 == kZero_StencilOp);
GR_STATIC_ASSERT(7 == kInvert_StencilOp);
- GrAssert((unsigned) op < kStencilOpCount);
+ SkASSERT((unsigned) op < kStencilOpCount);
return gTable[op];
}
void GrGpuGL::flushStencil(DrawType type) {
if (kStencilPath_DrawType == type) {
- GrAssert(!fStencilSettings.isTwoSided());
+ SkASSERT(!fStencilSettings.isTwoSided());
// Just the func, ref, and mask is set here. The op and write mask are params to the call
// that draws the path to the SB (glStencilFillPath)
GrGLenum func =
}
void GrGpuGL::bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture) {
- GrAssert(NULL != texture);
+ SkASSERT(NULL != texture);
// If we created a rt/tex and rendered to it without using a texture and now we're texturing
// from the rt it will still be the last bound texture, but it needs resolving. So keep this
}
void GrGpuGL::notifyRenderTargetDelete(GrRenderTarget* renderTarget) {
- GrAssert(NULL != renderTarget);
+ SkASSERT(NULL != renderTarget);
if (fHWBoundRenderTarget == renderTarget) {
fHWBoundRenderTarget = NULL;
}
}
void GrGpuGL::setTextureUnit(int unit) {
- GrAssert(unit >= 0 && unit < fHWBoundTextures.count());
+ SkASSERT(unit >= 0 && unit < fHWBoundTextures.count());
if (unit != fHWActiveTextureUnitIdx) {
GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + unit));
fHWActiveTextureUnitIdx = unit;
GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(surface->asRenderTarget());
GrGLuint tempFBOID;
if (NULL == rt) {
- GrAssert(NULL != surface->asTexture());
+ SkASSERT(NULL != surface->asTexture());
GrGLuint texID = static_cast<GrGLTexture*>(surface->asTexture())->textureID();
GR_GL_CALL(gl, GenFramebuffers(1, &tempFBOID));
GR_GL_CALL(gl, BindFramebuffer(fboTarget, tempFBOID));
GrGLIRect srcVP;
srcFBO = bind_surface_as_fbo(this->glInterface(), src, GR_GL_FRAMEBUFFER, &srcVP);
GrGLTexture* dstTex = static_cast<GrGLTexture*>(dst->asTexture());
- GrAssert(NULL != dstTex);
+ SkASSERT(NULL != dstTex);
// We modified the bound FBO
fHWBoundRenderTarget = NULL;
GrGLIRect srcGLRect;
}
if (!copied && inheritedCouldCopy) {
copied = INHERITED::onCopySurface(dst, src, srcRect, dstPoint);
- GrAssert(copied);
+ SkASSERT(copied);
}
return copied;
}
GrGpuGL* gpu,
const GrGLVertexBuffer* vbuffer,
const GrGLIndexBuffer* ibuffer) {
- GrAssert(NULL != vbuffer);
+ SkASSERT(NULL != vbuffer);
GrGLAttribArrayState* attribState;
// We use a vertex array if we're on a core profile and the verts are in a VBO.
void setVertexArrayID(GrGpuGL* gpu, GrGLuint arrayID) {
if (!gpu->glCaps().vertexArrayObjectSupport()) {
- GrAssert(0 == arrayID);
+ SkASSERT(0 == arrayID);
return;
}
if (!fBoundVertexArrayIDIsValid || arrayID != fBoundVertexArrayID) {
struct GrGpuGL::ProgramCache::ProgDescLess {
bool operator() (const GrGLProgramDesc& desc, const Entry* entry) {
- GrAssert(NULL != entry->fProgram.get());
+ SkASSERT(NULL != entry->fProgram.get());
return GrGLProgramDesc::Less(desc, entry->fProgram->getDesc());
}
bool operator() (const Entry* entry, const GrGLProgramDesc& desc) {
- GrAssert(NULL != entry->fProgram.get());
+ SkASSERT(NULL != entry->fProgram.get());
return GrGLProgramDesc::Less(entry->fProgram->getDesc(), desc);
}
};
void GrGpuGL::ProgramCache::abandon() {
for (int i = 0; i < fCount; ++i) {
- GrAssert(NULL != fEntries[i]->fProgram.get());
+ SkASSERT(NULL != fEntries[i]->fProgram.get());
fEntries[i]->fProgram->abandon();
fEntries[i]->fProgram.reset(NULL);
}
hashIdx &=((1 << kHashBits) - 1);
Entry* hashedEntry = fHashTable[hashIdx];
if (NULL != hashedEntry && hashedEntry->fProgram->getDesc() == desc) {
- GrAssert(NULL != hashedEntry->fProgram);
+ SkASSERT(NULL != hashedEntry->fProgram);
entry = hashedEntry;
}
purgeIdx = fCount++;
fEntries[purgeIdx] = entry;
} else {
- GrAssert(fCount == kMaxEntries);
+ SkASSERT(fCount == kMaxEntries);
purgeIdx = 0;
for (int i = 1; i < kMaxEntries; ++i) {
if (fEntries[i]->fLRUStamp < fEntries[purgeIdx]->fLRUStamp) {
fHashTable[purgedHashIdx] = NULL;
}
}
- GrAssert(fEntries[purgeIdx] == entry);
+ SkASSERT(fEntries[purgeIdx] == entry);
entry->fProgram.reset(program);
// We need to shift fEntries around so that the entry currently at purgeIdx is placed
// just before the entry at ~entryIdx (in order to keep fEntries sorted by descriptor).
fEntries[entryIdx - 1] = entry;
}
#if GR_DEBUG
- GrAssert(NULL != fEntries[0]->fProgram.get());
+ SkASSERT(NULL != fEntries[0]->fProgram.get());
for (int i = 0; i < fCount - 1; ++i) {
- GrAssert(NULL != fEntries[i + 1]->fProgram.get());
+ SkASSERT(NULL != fEntries[i + 1]->fProgram.get());
const GrGLProgramDesc& a = fEntries[i]->fProgram->getDesc();
const GrGLProgramDesc& b = fEntries[i + 1]->fProgram->getDesc();
- GrAssert(GrGLProgramDesc::Less(a, b));
- GrAssert(!GrGLProgramDesc::Less(b, a));
+ SkASSERT(GrGLProgramDesc::Less(a, b));
+ SkASSERT(!GrGLProgramDesc::Less(b, a));
}
#endif
}
const GrDrawState& drawState = this->getDrawState();
// GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
- GrAssert(NULL != drawState.getRenderTarget());
+ SkASSERT(NULL != drawState.getRenderTarget());
if (kStencilPath_DrawType == type) {
this->flushPathStencilMatrix();
colorStages.begin(),
coverageStages.begin()));
if (NULL == fCurrentProgram.get()) {
- GrAssert(!"Failed to create program!");
+ SkASSERT(!"Failed to create program!");
return false;
}
fCurrentProgram.get()->ref();
GrCrash("Unknown geometry src type!");
}
- GrAssert(NULL != vbuf);
- GrAssert(!vbuf->isLocked());
+ SkASSERT(NULL != vbuf);
+ SkASSERT(!vbuf->isLocked());
vertexOffsetInBytes += vbuf->baseOffset();
GrGLIndexBuffer* ibuf = NULL;
if (info.isIndexed()) {
- GrAssert(NULL != indexOffsetInBytes);
+ SkASSERT(NULL != indexOffsetInBytes);
switch (this->getGeomSrc().fIndexSrc) {
case kBuffer_GeometrySrcType:
GrCrash("Unknown geometry src type!");
}
- GrAssert(NULL != ibuf);
- GrAssert(!ibuf->isLocked());
+ SkASSERT(NULL != ibuf);
+ SkASSERT(!ibuf->isLocked());
*indexOffsetInBytes += ibuf->baseOffset();
}
GrGLAttribArrayState* attribState =
void GrDebugGL::setVertexArray(GrVertexArrayObj* vertexArray) {
if (NULL != vertexArray) {
- GrAssert(!vertexArray->getDeleted());
+ SkASSERT(!vertexArray->getDeleted());
}
SkRefCnt_SafeAssign(fVertexArray, vertexArray);
}
static GrDebugGL *getInstance() {
// someone should admit to actually using this class
- GrAssert(0 < gStaticRefCount);
+ SkASSERT(0 < gStaticRefCount);
if (NULL == gObj) {
gObj = SkNEW(GrDebugGL);
}
static void staticUnRef() {
- GrAssert(gStaticRefCount > 0);
+ SkASSERT(gStaticRefCount > 0);
gStaticRefCount--;
if (0 == gStaticRefCount) {
SkDELETE(gObj);
for (size_t n = 0; n < GR_ARRAY_COUNT(array); n++) {
for (size_t i = 0; i < n; i++) {
int index = GrTBSearch<int, int>(array, n, array[i]);
- GrAssert(index == (int) i);
+ SkASSERT(index == (int) i);
index = GrTBSearch<int, int>(array, n, -array[i]);
- GrAssert(index < 0);
+ SkASSERT(index < 0);
}
}
}
keyA.setKeyData(testStringA);
// test copy constructor and comparison
GrTBinHashKey<BogusEntry, kDataLenUsedForKey> keyA2(keyA);
- GrAssert(keyA.compare(keyA2) == 0);
- GrAssert(keyA.getHash() == keyA2.getHash());
+ SkASSERT(keyA.compare(keyA2) == 0);
+ SkASSERT(keyA.getHash() == keyA2.getHash());
// test re-init
keyA2.setKeyData(testStringA);
- GrAssert(keyA.compare(keyA2) == 0);
- GrAssert(keyA.getHash() == keyA2.getHash());
+ SkASSERT(keyA.compare(keyA2) == 0);
+ SkASSERT(keyA.getHash() == keyA2.getHash());
// test sorting
GrTBinHashKey<BogusEntry, kDataLenUsedForKey> keyB;
keyB.setKeyData(testStringB);
- GrAssert(keyA.compare(keyB) < 0);
- GrAssert(keyA.getHash() != keyB.getHash());
+ SkASSERT(keyA.compare(keyB) < 0);
+ SkASSERT(keyA.getHash() != keyB.getHash());
}
projects / platform / upstream / libSkiaSharp.git / commitdiff