// Draws
/**
- * Erase the entire render target, ignoring any clips
+ * Clear the entire render target, ignoring any clips
*/
- void eraseColor(GrColor color);
+ void clear(GrColor color);
/**
* Draw everywhere (respecting the clip) with the paint.
GrIndexBuffer* createIndexBuffer(uint32_t size, bool dynamic);
/**
- * Erase the entire render target, ignoring any clips/scissors.
+ * Clear the entire render target, ignoring any clips/scissors.
*
* This is issued to the GPU driver immediately.
*/
- void eraseColor(GrColor color);
+ void clear(GrColor color);
/**
* Are 8 bit paletted textures supported.
virtual GrIndexBuffer* onCreateIndexBuffer(uint32_t size,
bool dynamic) = 0;
- // overridden by API-specific derivated class to perform the erase.
- virtual void onEraseColor(GrColor color) = 0;
+ // overridden by API-specific derivated class to perform the clear.
+ virtual void onClear(GrColor color) = 0;
// overridden by API-specific derived class to perform the draw call.
virtual void onDrawIndexed(GrPrimitiveType type,
virtual void flushScissor(const GrIRect* rect) = 0;
// GrGpu subclass removes the clip from the stencil buffer
- virtual void eraseStencilClip(const GrIRect& rect) = 0;
+ virtual void clearStencilClip(const GrIRect& rect) = 0;
private:
GrContext* fContext; // not reffed (context refs gpu)
////////////////////////////////////////////////////////////////////////////////
-void GrContext::eraseColor(GrColor color) {
- fGpu->eraseColor(color);
+void GrContext::clear(GrColor color) {
+ // gpu flush call is immediate, must flush.
+ // (could in theory skip draws to current render target.)
+ this->flush();
+ fGpu->clear(color);
}
void GrContext::drawPaint(const GrPaint& paint) {
return this->onCreateIndexBuffer(size, dynamic);
}
-void GrGpu::eraseColor(GrColor color) {
+void GrGpu::clear(GrColor color) {
this->handleDirtyContext();
- this->onEraseColor(color);
+ this->onClear(color);
}
void GrGpu::forceRenderTargetFlush() {
AutoInternalDrawGeomRestore aidgr(this);
this->setViewMatrix(GrMatrix::I());
- this->eraseStencilClip(clipRect);
+ this->clearStencilClip(clipRect);
this->flushScissor(NULL);
#if !VISUALIZE_COMPLEX_CLIP
this->enableState(kNoColorWrites_StateBit);
if (!(desc.fFlags & kNoStencil_TextureFlag)) {
GrRenderTarget* rtSave = fCurrDrawState.fRenderTarget;
fCurrDrawState.fRenderTarget = rt;
- eraseStencil(0, ~0);
+ this->clearStencil(0, ~0);
fCurrDrawState.fRenderTarget = rtSave;
}
}
}
}
-void GrGpuGL::onEraseColor(GrColor color) {
+void GrGpuGL::onClear(GrColor color) {
if (NULL == fCurrDrawState.fRenderTarget) {
return;
}
GR_GL(Clear(GR_GL_COLOR_BUFFER_BIT));
}
-void GrGpuGL::eraseStencil(uint32_t value, uint32_t mask) {
+void GrGpuGL::clearStencil(uint32_t value, uint32_t mask) {
if (NULL == fCurrDrawState.fRenderTarget) {
return;
}
fHWDrawState.fStencilSettings.invalidate();
}
-void GrGpuGL::eraseStencilClip(const GrIRect& rect) {
+void GrGpuGL::clearStencilClip(const GrIRect& rect) {
GrAssert(NULL != fCurrDrawState.fRenderTarget);
#if 0
GrGLint stencilBitCount = fCurrDrawState.fRenderTarget->stencilBits();
int width, int height);
virtual GrRenderTarget* onCreateRenderTargetFrom3DApiState();
- virtual void onEraseColor(GrColor color);
+ virtual void onClear(GrColor color);
virtual void onForceRenderTargetFlush();
uint32_t vertexCount,
uint32_t numVertices);
virtual void flushScissor(const GrIRect* rect);
- void eraseStencil(uint32_t value, uint32_t mask);
- virtual void eraseStencilClip(const GrIRect& rect);
+ void clearStencil(uint32_t value, uint32_t mask);
+ virtual void clearStencilClip(const GrIRect& rect);
// binds texture unit in GL
void setTextureUnit(int unitIdx);
*/
const SkBitmap& accessBitmap(bool changePixels);
- /** Helper to erase the entire device to the specified color (including
- alpha).
- */
- void eraseColor(SkColor eraseColor);
+ /** Clears the entire device to the specified color (including alpha).
+ * Ignores the clip.
+ */
+ virtual void clear(SkColor color);
+
+ /**
+ * Deprecated name for clear.
+ */
+ void eraseColor(SkColor eraseColor) { this->clear(eraseColor); }
/** Called when this device is installed into a Canvas. Balanaced by a call
to unlockPixels() when the device is removed from a Canvas.
// overrides from SkDevice
+ virtual void clear(SkColor color);
virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);
virtual void writePixels(const SkBitmap& bitmap, int x, int y);
return sect ? sect->intersect(r, bounds) : SkIRect::Intersects(r, bounds);
}
-void SkDevice::eraseColor(SkColor eraseColor) {
- fBitmap.eraseColor(eraseColor);
+void SkDevice::clear(SkColor color) {
+ fBitmap.eraseColor(color);
}
void SkDevice::onAccessBitmap(SkBitmap* bitmap) {}
convert_matrixclip(fContext, matrix, clipStack, clip, this->getOrigin());
if (fNeedClear) {
- fContext->eraseColor(0x0);
+ fContext->clear(0x0);
fNeedClear = false;
}
}
///////////////////////////////////////////////////////////////////////////////
+void SkGpuDevice::clear(SkColor color) {
+ fContext->clear(color);
+}
+
void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
CHECK_SHOULD_DRAW(draw);