// These objects should always be allocated with a LinearAllocator, and never destroyed/deleted.
// standard new() intentionally not implemented, and delete/deconstructor should never be used.
virtual ~DisplayListOp() { CRASH(); }
- static void operator delete(void* /* ptr */) { CRASH(); }
+ static void operator delete(void* ptr) { CRASH(); }
/** static void* operator new(size_t size); PURPOSELY OMITTED **/
static void* operator new(size_t size, LinearAllocator& allocator) {
return allocator.alloc(size);
virtual ~StateOp() {}
- virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
- bool /* useQuickReject */) {
+ virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+ bool useQuickReject) {
// default behavior only affects immediate, deferrable state, issue directly to renderer
applyState(deferStruct.mRenderer, saveCount);
}
* State operations are applied directly to the renderer, but can cause the deferred drawing op
* list to flush
*/
- virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int /* level */,
- bool /* useQuickReject */) {
+ virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
+ bool useQuickReject) {
applyState(replayStruct.mRenderer, saveCount);
}
DrawOp(const SkPaint* paint)
: mPaint(paint), mQuickRejected(false) {}
- virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
+ virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
if (mQuickRejected && CC_LIKELY(useQuickReject)) {
return;
deferStruct.mDeferredList.addDrawOp(deferStruct.mRenderer, this);
}
- virtual void replay(ReplayStateStruct& replayStruct, int /* saveCount */, int /* level */,
+ virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
bool useQuickReject) {
if (mQuickRejected && CC_LIKELY(useQuickReject)) {
return;
* reducing which operations are tagged as mergeable.
*/
virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
- const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
+ const Vector<OpStatePair>& ops, const Rect& bounds) {
status_t status = DrawGlInfo::kStatusDone;
for (unsigned int i = 0; i < ops.size(); i++) {
renderer.restoreDisplayState(*(ops[i].state), true);
*
* if a subclass can set deferInfo.mergeable to true, it should implement multiDraw()
*/
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& /* deferInfo */,
- const DeferredDisplayState& /* state */) {}
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+ const DeferredDisplayState& state) {}
/**
* Query the conservative, local bounds (unmapped) bounds of the op.
*
* returns true if bounds exist
*/
- virtual bool getLocalBounds(Rect& /* localBounds */) {
+ virtual bool getLocalBounds(Rect& localBounds) {
return false;
}
SaveOp(int flags)
: mFlags(flags) {}
- virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
- bool /* useQuickReject */) {
+ virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+ bool useQuickReject) {
int newSaveCount = deferStruct.mRenderer.save(mFlags);
deferStruct.mDeferredList.addSave(deferStruct.mRenderer, this, newSaveCount);
}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.save(mFlags);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Save flags %x", mFlags);
}
RestoreToCountOp(int count)
: mCount(count) {}
- virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
- bool /* useQuickReject */) {
+ virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+ bool useQuickReject) {
deferStruct.mDeferredList.addRestoreToCount(deferStruct.mRenderer,
this, saveCount + mCount);
deferStruct.mRenderer.restoreToCount(saveCount + mCount);
renderer.restoreToCount(saveCount + mCount);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Restore to count %d", mCount);
}
, mConvexMask(NULL)
{}
- virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int /* level */,
- bool /* useQuickReject */) {
+ virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+ bool useQuickReject) {
// NOTE: don't bother with actual saveLayer, instead issuing it at flush time
int newSaveCount = deferStruct.mRenderer.getSaveCount();
deferStruct.mDeferredList.addSaveLayer(deferStruct.mRenderer, this, newSaveCount);
mPaint, mFlags);
}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.saveLayer(mArea.left, mArea.top, mArea.right, mArea.bottom,
mPaint, mFlags, mConvexMask);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("SaveLayer%s of area " RECT_STRING,
(isSaveLayerAlpha() ? "Alpha" : ""),RECT_ARGS(mArea));
}
TranslateOp(float dx, float dy)
: mDx(dx), mDy(dy) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.translate(mDx, mDy);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Translate by %f %f", mDx, mDy);
}
RotateOp(float degrees)
: mDegrees(degrees) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.rotate(mDegrees);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Rotate by %f degrees", mDegrees);
}
ScaleOp(float sx, float sy)
: mSx(sx), mSy(sy) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.scale(mSx, mSy);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Scale by %f %f", mSx, mSy);
}
SkewOp(float sx, float sy)
: mSx(sx), mSy(sy) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.skew(mSx, mSy);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Skew by %f %f", mSx, mSy);
}
SetMatrixOp(const SkMatrix& matrix)
: mMatrix(matrix) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.setMatrix(mMatrix);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
if (mMatrix.isIdentity()) {
OP_LOGS("SetMatrix (reset)");
} else {
ConcatMatrixOp(const SkMatrix& matrix)
: mMatrix(matrix) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.concatMatrix(mMatrix);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("ConcatMatrix " SK_MATRIX_STRING, SK_MATRIX_ARGS(&mMatrix));
}
public:
ClipOp(SkRegion::Op op) : mOp(op) {}
- virtual void defer(DeferStateStruct& deferStruct, int saveCount, int /* level */,
- bool /* useQuickReject */) {
+ virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+ bool useQuickReject) {
// NOTE: must defer op BEFORE applying state, since it may read clip
deferStruct.mDeferredList.addClip(deferStruct.mRenderer, this);
ClipRectOp(float left, float top, float right, float bottom, SkRegion::Op op)
: ClipOp(op), mArea(left, top, right, bottom) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.clipRect(mArea.left, mArea.top, mArea.right, mArea.bottom, mOp);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("ClipRect " RECT_STRING, RECT_ARGS(mArea));
}
ClipPathOp(const SkPath* path, SkRegion::Op op)
: ClipOp(op), mPath(path) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.clipPath(mPath, mOp);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
SkRect bounds = mPath->getBounds();
OP_LOG("ClipPath bounds " RECT_STRING,
bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
ClipRegionOp(const SkRegion* region, SkRegion::Op op)
: ClipOp(op), mRegion(region) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.clipRegion(mRegion, mOp);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
SkIRect bounds = mRegion->getBounds();
OP_LOG("ClipRegion bounds %d %d %d %d",
bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
class ResetPaintFilterOp : public StateOp {
public:
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.resetPaintFilter();
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOGS("ResetPaintFilter");
}
SetupPaintFilterOp(int clearBits, int setBits)
: mClearBits(clearBits), mSetBits(setBits) {}
- virtual void applyState(OpenGLRenderer& renderer, int /* saveCount */) const {
+ virtual void applyState(OpenGLRenderer& renderer, int saveCount) const {
renderer.setupPaintFilter(mClearBits, mSetBits);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("SetupPaintFilter, clear %#x, set %#x", mClearBits, mSetBits);
}
}
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawBitmap(mBitmap, getPaint(renderer));
}
* for each bitmap in the batch. This method is also responsible for dirtying
* the current layer, if any.
*/
- virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
+ virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
const Vector<OpStatePair>& ops, const Rect& bounds) {
const DeferredDisplayState& firstState = *(ops[0].state);
renderer.restoreDisplayState(firstState, true); // restore all but the clip
pureTranslate, bounds, mPaint);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw bitmap %p at %f %f", mBitmap, mLocalBounds.left, mLocalBounds.top);
}
virtual const char* name() { return "DrawBitmap"; }
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
deferInfo.mergeId = getAtlasEntry() ?
: DrawBoundedOp(dstLeft, dstTop, dstRight, dstBottom, paint),
mBitmap(bitmap), mSrc(srcLeft, srcTop, srcRight, srcBottom) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawBitmap(mBitmap, mSrc.left, mSrc.top, mSrc.right, mSrc.bottom,
mLocalBounds.left, mLocalBounds.top, mLocalBounds.right, mLocalBounds.bottom,
getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw bitmap %p src=" RECT_STRING ", dst=" RECT_STRING,
mBitmap, RECT_ARGS(mSrc), RECT_ARGS(mLocalBounds));
}
virtual const char* name() { return "DrawBitmapRect"; }
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+ const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
}
DrawBitmapDataOp(const SkBitmap* bitmap, const SkPaint* paint)
: DrawBitmapOp(bitmap, paint) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawBitmapData(mBitmap, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw bitmap %p", mBitmap);
}
virtual const char* name() { return "DrawBitmapData"; }
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+ const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
}
};
mBitmap(bitmap), mMeshWidth(meshWidth), mMeshHeight(meshHeight),
mVertices(vertices), mColors(colors) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawBitmapMesh(mBitmap, mMeshWidth, mMeshHeight,
mVertices, mColors, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw bitmap %p mesh %d x %d", mBitmap, mMeshWidth, mMeshHeight);
}
virtual const char* name() { return "DrawBitmapMesh"; }
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+ const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap;
}
* and transforming the vertices of each 9-patch in the batch. This method
* is also responsible for dirtying the current layer, if any.
*/
- virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
- const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
+ virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+ const Vector<OpStatePair>& ops, const Rect& bounds) {
const DeferredDisplayState& firstState = *(ops[0].state);
renderer.restoreDisplayState(firstState, true); // restore all but the clip
&vertices[0], indexCount, getPaint(renderer));
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
// We're not calling the public variant of drawPatch() here
// This method won't perform the quickReject() since we've already done it at this point
return renderer.drawPatch(mBitmap, getMesh(renderer), getAtlasEntry(),
getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw patch " RECT_STRING, RECT_ARGS(mLocalBounds));
}
virtual const char* name() { return "DrawPatch"; }
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Patch;
deferInfo.mergeId = getAtlasEntry() ? (mergeid_t) mEntry->getMergeId() : (mergeid_t) mBitmap;
DrawColorOp(int color, SkXfermode::Mode mode)
: DrawOp(NULL), mColor(color), mMode(mode) {};
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawColor(mColor, mMode);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw color %#x, mode %d", mColor, mMode);
}
return true;
}
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+ const DeferredDisplayState& state) {
if (mPaint->getPathEffect()) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture;
} else {
DrawRectOp(float left, float top, float right, float bottom, const SkPaint* paint)
: DrawStrokableOp(left, top, right, bottom, paint) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawRect(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Rect " RECT_STRING, RECT_ARGS(mLocalBounds));
}
: DrawBoundedOp(rects, count, paint),
mRects(rects), mCount(count) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawRects(mRects, mCount, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Rects count %d", mCount);
}
virtual const char* name() { return "DrawRects"; }
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+ const DeferredDisplayState& state) {
deferInfo.batchId = DeferredDisplayList::kOpBatch_Vertices;
}
float rx, float ry, const SkPaint* paint)
: DrawStrokableOp(left, top, right, bottom, paint), mRx(rx), mRy(ry) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawRoundRect(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom, mRx, mRy, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw RoundRect " RECT_STRING ", rx %f, ry %f", RECT_ARGS(mLocalBounds), mRx, mRy);
}
: DrawOp(paint), mLeft(left), mTop(top), mRight(right), mBottom(bottom),
mRx(rx), mRy(ry) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawRoundRect(*mLeft, *mTop, *mRight, *mBottom,
*mRx, *mRy, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw RoundRect Props " RECT_STRING ", rx %f, ry %f",
*mLeft, *mTop, *mRight, *mBottom, *mRx, *mRy);
}
: DrawStrokableOp(x - radius, y - radius, x + radius, y + radius, paint),
mX(x), mY(y), mRadius(radius) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawCircle(mX, mY, mRadius, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Circle x %f, y %f, r %f", mX, mY, mRadius);
}
DrawCirclePropsOp(float* x, float* y, float* radius, const SkPaint* paint)
: DrawOp(paint), mX(x), mY(y), mRadius(radius) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawCircle(*mX, *mY, *mRadius, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Circle Props x %p, y %p, r %p", mX, mY, mRadius);
}
DrawOvalOp(float left, float top, float right, float bottom, const SkPaint* paint)
: DrawStrokableOp(left, top, right, bottom, paint) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawOval(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Oval " RECT_STRING, RECT_ARGS(mLocalBounds));
}
: DrawStrokableOp(left, top, right, bottom, paint),
mStartAngle(startAngle), mSweepAngle(sweepAngle), mUseCenter(useCenter) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawArc(mLocalBounds.left, mLocalBounds.top,
mLocalBounds.right, mLocalBounds.bottom,
mStartAngle, mSweepAngle, mUseCenter, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Arc " RECT_STRING ", start %f, sweep %f, useCenter %d",
RECT_ARGS(mLocalBounds), mStartAngle, mSweepAngle, mUseCenter);
}
mLocalBounds.set(left, top, left + width, top + height);
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawPath(mPath, getPaint(renderer));
}
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ const DeferredDisplayState& state) {
const SkPaint* paint = getPaint(renderer);
renderer.getCaches().pathCache.precache(mPath, paint);
deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture;
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Path %p in " RECT_STRING, mPath, RECT_ARGS(mLocalBounds));
}
mLocalBounds.outset(strokeWidthOutset());
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawLines(mPoints, mCount, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Lines count %d", mCount);
}
virtual const char* name() { return "DrawLines"; }
- virtual void onDefer(OpenGLRenderer& /* renderer */, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
+ const DeferredDisplayState& state) {
deferInfo.batchId = mPaint->isAntiAlias() ?
DeferredDisplayList::kOpBatch_AlphaVertices :
DeferredDisplayList::kOpBatch_Vertices;
DrawPointsOp(const float* points, int count, const SkPaint* paint)
: DrawLinesOp(points, count, paint) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawPoints(mPoints, mCount, getPaint(renderer));
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Points count %d", mCount);
}
DrawSomeTextOp(const char* text, int bytesCount, int count, const SkPaint* paint)
: DrawOp(paint), mText(text), mBytesCount(bytesCount), mCount(count) {};
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw some text, %d bytes", mBytesCount);
}
}
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
- const DeferredDisplayState& /* state */) {
+ const DeferredDisplayState& state) {
const SkPaint* paint = getPaint(renderer);
FontRenderer& fontRenderer = renderer.getCaches().fontRenderer->getFontRenderer(paint);
fontRenderer.precache(paint, mText, mCount, SkMatrix::I());
/* TODO: inherit from DrawBounded and init mLocalBounds */
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawTextOnPath(mText, mBytesCount, mCount, mPath,
mHOffset, mVOffset, getPaint(renderer));
}
/* TODO: inherit from DrawBounded and init mLocalBounds */
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawPosText(mText, mBytesCount, mCount, mPositions, getPaint(renderer));
}
&& OpenGLRenderer::getXfermodeDirect(mPaint) == SkXfermode::kSrcOver_Mode;
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
Rect bounds;
getLocalBounds(bounds);
return renderer.drawText(mText, mBytesCount, mCount, mX, mY,
mPositions, getPaint(renderer), mTotalAdvance, bounds);
}
- virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& /* dirty */,
- const Vector<OpStatePair>& ops, const Rect& /* bounds */) {
+ virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+ const Vector<OpStatePair>& ops, const Rect& bounds) {
status_t status = DrawGlInfo::kStatusDone;
for (unsigned int i = 0; i < ops.size(); i++) {
const DeferredDisplayState& state = *(ops[i].state);
return status;
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Text of count %d, bytes %d", mCount, mBytesCount);
}
return ret;
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Functor %p", mFunctor);
}
: DrawBoundedOp(0, 0, renderNode->getWidth(), renderNode->getHeight(), 0),
mRenderNode(renderNode), mFlags(flags), mTransformFromParent(transformFromParent) {}
- virtual void defer(DeferStateStruct& deferStruct, int /* saveCount */, int level,
- bool /* useQuickReject */) {
+ virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
+ bool useQuickReject) {
if (mRenderNode->isRenderable() && !mSkipInOrderDraw) {
mRenderNode->defer(deferStruct, level + 1);
}
}
- virtual void replay(ReplayStateStruct& replayStruct, int /* saveCount */, int level,
- bool /* useQuickReject */) {
+ virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
+ bool useQuickReject) {
if (mRenderNode->isRenderable() && !mSkipInOrderDraw) {
mRenderNode->replay(replayStruct, level + 1);
}
}
- virtual status_t applyDraw(OpenGLRenderer& /* renderer */, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
LOG_ALWAYS_FATAL("should not be called, because replay() is overridden");
return 0;
}
, mCasterOutline(casterOutline) {
}
- virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& /* deferInfo */,
+ virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) {
renderer.getCaches().tessellationCache.precacheShadows(&state.mMatrix,
renderer.getLocalClipBounds(), isCasterOpaque(), mCasterOutline,
&mTransformXY, &mTransformZ, renderer.getLightCenter(), renderer.getLightRadius());
}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
TessellationCache::vertexBuffer_pair_t buffers;
Matrix4 drawTransform(*(renderer.currentTransform()));
renderer.getCaches().tessellationCache.getShadowBuffers(&drawTransform,
return renderer.drawShadow(mCasterAlpha, buffers.first, buffers.second);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOGS("DrawShadow");
}
DrawLayerOp(Layer* layer, float x, float y)
: DrawOp(NULL), mLayer(layer), mX(x), mY(y) {}
- virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& /* dirty */) {
+ virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
return renderer.drawLayer(mLayer, mX, mY);
}
- virtual void output(int level, uint32_t /* logFlags */) const {
+ virtual void output(int level, uint32_t logFlags) const {
OP_LOG("Draw Layer %p at %f %f", mLayer, mX, mY);
}