void setReader(SkFlattenableReadBuffer* reader) { fReader = reader; }
- const SkPaint& getPaint(uint32_t drawOp32) const;
+ const SkPaint& paint() const { return fPaint; }
+ SkPaint* editPaint() { return &fPaint; }
- // Extracts index from DrawOp_unpackData().
- // Returns the specified paint from our list, or creates a new paint if
- // index == count. If index > count, return NULL
- SkPaint* editPaint(uint32_t drawOp32);
-
SkFlattenable* getFlat(unsigned index) const {
if (0 == index) {
return NULL;
}
SkFlattenableReadBuffer* fReader;
- SkTDArray<SkFlattenable*> fFlatArray;
private:
-
- SkTDArray<SkPaint*> fPaints;
-
- SkRefCntTDArray<SkColorFilter*> fColorFilters;
- SkRefCntTDArray<SkDrawLooper*> fDrawLoopers;
- SkRefCntTDArray<SkMaskFilter*> fMaskFilters;
- SkRefCntTDArray<SkPathEffect*> fPathEffects;
- SkRefCntTDArray<SkRasterizer*> fRasterizers;
- SkRefCntTDArray<SkShader*> fShaders;
- SkRefCntTDArray<SkTypeface*> fTypefaces;
- SkRefCntTDArray<SkXfermode*> fXfermodes;
+ SkPaint fPaint;
+ SkTDArray<SkFlattenable*> fFlatArray;
+ SkTDArray<SkTypeface*> fTypefaces;
};
///////////////////////////////////////////////////////////////////////////////
return reinterpret_cast<const T*>(reader->skip(size));
}
-const SkPaint& SkGPipeState::getPaint(uint32_t op32) const {
- unsigned index = DrawOp_unpackData(op32);
- if (index >= fPaints.count()) {
- SkASSERT(!"paint index out of range");
- index = 0; // we always have at least 1 paint
- }
- return *fPaints[index];
-}
-
-SkPaint* SkGPipeState::editPaint(uint32_t op32) {
- unsigned index = DrawOp_unpackData(op32);
-
- if (index > fPaints.count()) {
- SkASSERT(!"paint index out of range");
- return NULL;
- }
-
- if (index == fPaints.count()) {
- *fPaints.append() = SkNEW(SkPaint);
- }
- return fPaints[index];
-}
-
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
}
const SkPaint* paint = NULL;
if (flags & kSaveLayer_HasPaint_DrawOpFlag) {
- paint = &state->getPaint(reader->readU32());
+ paint = &state->paint();
}
canvas->saveLayer(bounds, paint, saveFlags);
}
static void drawPaint_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
SkGPipeState* state) {
- canvas->drawPaint(state->getPaint(op32));
+ canvas->drawPaint(state->paint());
}
static void drawPoints_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
SkCanvas::PointMode mode = (SkCanvas::PointMode)DrawOp_unpackFlags(op32);
size_t count = reader->readU32();
const SkPoint* pts = skip<SkPoint>(reader, count);
- canvas->drawPoints(mode, count, pts, state->getPaint(op32));
+ canvas->drawPoints(mode, count, pts, state->paint());
}
static void drawRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
SkGPipeState* state) {
- canvas->drawRect(*skip<SkRect>(reader), state->getPaint(op32));
+ canvas->drawRect(*skip<SkRect>(reader), state->paint());
}
static void drawPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
SkGPipeState* state) {
SkPath path;
path.unflatten(*reader);
- canvas->drawPath(path, state->getPaint(op32));
+ canvas->drawPath(path, state->paint());
}
static void drawVertices_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
}
canvas->drawVertices(mode, vertexCount, verts, texs, colors, xfer,
- indices, indexCount, state->getPaint(op32));
+ indices, indexCount, state->paint());
}
///////////////////////////////////////////////////////////////////////////////
size_t len = reader->readU32();
const void* text = reader->skip(SkAlign4(len));
const SkScalar* xy = skip<SkScalar>(reader, 2);
- canvas->drawText(text, len, xy[0], xy[1], state->getPaint(op32));
+ canvas->drawText(text, len, xy[0], xy[1], state->paint());
}
static void drawPosText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
const void* text = reader->skip(SkAlign4(len));
size_t posCount = reader->readU32(); // compute by our writer
const SkPoint* pos = skip<SkPoint>(reader, posCount);
- canvas->drawPosText(text, len, pos, state->getPaint(op32));
+ canvas->drawPosText(text, len, pos, state->paint());
}
static void drawPosTextH_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
size_t posCount = reader->readU32(); // compute by our writer
const SkScalar* xpos = skip<SkScalar>(reader, posCount);
SkScalar constY = reader->readScalar();
- canvas->drawPosTextH(text, len, xpos, constY, state->getPaint(op32));
+ canvas->drawPosTextH(text, len, xpos, constY, state->paint());
}
static void drawTextOnPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
matrix = &matrixStorage;
}
- canvas->drawTextOnPath(text, len, path, matrix, state->getPaint(op32));
+ canvas->drawTextOnPath(text, len, path, matrix, state->paint());
}
///////////////////////////////////////////////////////////////////////////////
SkGPipeState* state) {
size_t offset = reader->offset();
size_t stop = offset + PaintOp_unpackData(op32);
- SkPaint* p = state->editPaint(0);
- int done;
+ SkPaint* p = state->editPaint();
do {
uint32_t p32 = reader->readU32();
unsigned op = PaintOp_unpackOp(p32);
unsigned data = PaintOp_unpackData(p32);
- done = PaintOp_unpackFlags(p32) & kLastOp_PaintOpFlag;
// SkDebugf(" read %08X op=%d flags=%d data=%d\n", p32, op, done, data);
default: SkASSERT(!"bad paintop"); return;
}
SkASSERT(reader->offset() <= stop);
- done = (reader->offset() >= stop);
- } while (!done);
+ } while (reader->offset() < stop);
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-SkGPipeState::SkGPipeState() {
- // start out with one paint in default state
- *fPaints.append() = SkNEW(SkPaint);
-}
+SkGPipeState::SkGPipeState() {}
SkGPipeState::~SkGPipeState() {
+ fTypefaces.unrefAll();
fFlatArray.unrefAll();
- fPaints.deleteAll();
}
///////////////////////////////////////////////////////////////////////////////
int fCurrFlatIndex[kCount_PaintFlats];
int flattenToIndex(SkFlattenable* obj, PaintFlats);
- SkTDArray<SkPaint*> fPaints;
- unsigned writePaint(const SkPaint&);
+ SkPaint fPaint;
+ void writePaint(const SkPaint&);
class AutoPipeNotify {
public:
fBlockSize = 0; // need first block from controller
sk_bzero(fCurrFlatIndex, sizeof(fCurrFlatIndex));
- // always begin with 1 default paint
- *fPaints.append() = SkNEW(SkPaint);
-
// we need a device to limit our clip
// should the caller give us the bounds?
SkBitmap bitmap;
SkGPipeCanvas::~SkGPipeCanvas() {
this->finish();
- fPaints.deleteAll();
fFlatArray.freeAll();
}
SaveFlags saveFlags) {
NOTIFY_SETUP(this);
size_t size = 0;
- unsigned index = 0; // just to avoid the warning
unsigned opFlags = 0;
if (bounds) {
}
if (paint) {
opFlags |= kSaveLayer_HasPaint_DrawOpFlag;
- index = this->writePaint(*paint);
- size += 4;
+ this->writePaint(*paint);
}
if (this->needOpBytes(size)) {
if (bounds) {
fWriter.writeRect(*bounds);
}
- if (paint) {
- fWriter.write32(index);
- }
}
// we just pass on the save, so we don't create a layer
void SkGPipeCanvas::drawPaint(const SkPaint& paint) {
NOTIFY_SETUP(this);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
if (this->needOpBytes()) {
- this->writeOp(kDrawPaint_DrawOp, 0, paintIndex);
+ this->writeOp(kDrawPaint_DrawOp);
}
}
const SkPoint pts[], const SkPaint& paint) {
if (count) {
NOTIFY_SETUP(this);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
if (this->needOpBytes(4 + count * sizeof(SkPoint))) {
- this->writeOp(kDrawPoints_DrawOp, mode, paintIndex);
+ this->writeOp(kDrawPoints_DrawOp, mode, 0);
fWriter.write32(count);
fWriter.write(pts, count * sizeof(SkPoint));
}
void SkGPipeCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
NOTIFY_SETUP(this);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
if (this->needOpBytes(sizeof(SkRect))) {
- this->writeOp(kDrawRect_DrawOp, 0, paintIndex);
+ this->writeOp(kDrawRect_DrawOp);
fWriter.writeRect(rect);
}
}
void SkGPipeCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
NOTIFY_SETUP(this);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
if (this->needOpBytes(estimateFlattenSize(path))) {
- this->writeOp(kDrawPath_DrawOp, 0, paintIndex);
+ this->writeOp(kDrawPath_DrawOp);
path.flatten(fWriter);
}
}
SkScalar y, const SkPaint& paint) {
if (byteLength) {
NOTIFY_SETUP(this);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
- this->writeOp(kDrawText_DrawOp, 0, paintIndex);
+ this->writeOp(kDrawText_DrawOp);
fWriter.write32(byteLength);
fWriter.writePad(text, byteLength);
fWriter.writeScalar(x);
const SkPoint pos[], const SkPaint& paint) {
if (byteLength) {
NOTIFY_SETUP(this);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
int count = paint.textToGlyphs(text, byteLength, NULL);
if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
- this->writeOp(kDrawPosText_DrawOp, 0, paintIndex);
+ this->writeOp(kDrawPosText_DrawOp);
fWriter.write32(byteLength);
fWriter.writePad(text, byteLength);
fWriter.write32(count);
const SkPaint& paint) {
if (byteLength) {
NOTIFY_SETUP(this);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
int count = paint.textToGlyphs(text, byteLength, NULL);
if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
- this->writeOp(kDrawPosTextH_DrawOp, 0, paintIndex);
+ this->writeOp(kDrawPosTextH_DrawOp);
fWriter.write32(byteLength);
fWriter.writePad(text, byteLength);
fWriter.write32(count);
flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
size += matrix->flatten(NULL);
}
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
if (this->needOpBytes(size)) {
- this->writeOp(kDrawTextOnPath_DrawOp, flags, paintIndex);
+ this->writeOp(kDrawTextOnPath_DrawOp, flags, 0);
fWriter.write32(byteLength);
fWriter.writePad(text, byteLength);
NOTIFY_SETUP(this);
size_t size = 4 + vertexCount * sizeof(SkPoint);
- unsigned paintIndex = this->writePaint(paint);
+ this->writePaint(paint);
unsigned flags = 0;
if (texs) {
flags |= kDrawVertices_HasTexs_DrawOpFlag;
}
if (this->needOpBytes(size)) {
- this->writeOp(kDrawVertices_DrawOp, flags, paintIndex);
+ this->writeOp(kDrawVertices_DrawOp, flags, 0);
fWriter.write32(mode);
fWriter.write32(vertexCount);
fWriter.write(vertices, vertexCount * sizeof(SkPoint));
return data.fDst;
}
-unsigned SkGPipeCanvas::writePaint(const SkPaint& paint) {
- SkPaint& base = *fPaints[0];
+void SkGPipeCanvas::writePaint(const SkPaint& paint) {
+ SkPaint& base = fPaint;
uint32_t storage[32];
uint32_t* ptr = storage;
- uint32_t* last = NULL;
if (base.getFlags() != paint.getFlags()) {
- last = ptr;
*ptr++ = PaintOp_packOpData(kFlags_PaintOp, paint.getFlags());
base.setFlags(paint.getFlags());
}
if (base.getColor() != paint.getColor()) {
- last = ptr;
*ptr++ = PaintOp_packOp(kColor_PaintOp);
*ptr++ = paint.getColor();
base.setColor(paint.getColor());
}
if (base.getStyle() != paint.getStyle()) {
- last = ptr;
*ptr++ = PaintOp_packOpData(kStyle_PaintOp, paint.getStyle());
base.setStyle(paint.getStyle());
}
if (base.getStrokeJoin() != paint.getStrokeJoin()) {
- last = ptr;
*ptr++ = PaintOp_packOpData(kJoin_PaintOp, paint.getStrokeJoin());
base.setStrokeJoin(paint.getStrokeJoin());
}
if (base.getStrokeCap() != paint.getStrokeCap()) {
- last = ptr;
*ptr++ = PaintOp_packOpData(kCap_PaintOp, paint.getStrokeCap());
base.setStrokeCap(paint.getStrokeCap());
}
if (base.getStrokeWidth() != paint.getStrokeWidth()) {
- last = ptr;
*ptr++ = PaintOp_packOp(kWidth_PaintOp);
*ptr++ = castToU32(paint.getStrokeWidth());
base.setStrokeWidth(paint.getStrokeWidth());
}
if (base.getStrokeMiter() != paint.getStrokeMiter()) {
- last = ptr;
*ptr++ = PaintOp_packOp(kMiter_PaintOp);
*ptr++ = castToU32(paint.getStrokeMiter());
base.setStrokeMiter(paint.getStrokeMiter());
}
if (base.getTextEncoding() != paint.getTextEncoding()) {
- last = ptr;
*ptr++ = PaintOp_packOpData(kEncoding_PaintOp, paint.getTextEncoding());
base.setTextEncoding(paint.getTextEncoding());
}
if (base.getHinting() != paint.getHinting()) {
- last = ptr;
*ptr++ = PaintOp_packOpData(kHinting_PaintOp, paint.getHinting());
base.setHinting(paint.getHinting());
}
if (base.getTextAlign() != paint.getTextAlign()) {
- last = ptr;
*ptr++ = PaintOp_packOpData(kAlign_PaintOp, paint.getTextAlign());
base.setTextAlign(paint.getTextAlign());
}
if (base.getTextSize() != paint.getTextSize()) {
- last = ptr;
*ptr++ = PaintOp_packOp(kTextSize_PaintOp);
*ptr++ = castToU32(paint.getTextSize());
base.setTextSize(paint.getTextSize());
}
if (base.getTextScaleX() != paint.getTextScaleX()) {
- last = ptr;
*ptr++ = PaintOp_packOp(kTextScaleX_PaintOp);
*ptr++ = castToU32(paint.getTextScaleX());
base.setTextScaleX(paint.getTextScaleX());
}
if (base.getTextSkewX() != paint.getTextSkewX()) {
- last = ptr;
*ptr++ = PaintOp_packOp(kTextSkewX_PaintOp);
*ptr++ = castToU32(paint.getTextSkewX());
base.setTextSkewX(paint.getTextSkewX());
if (!SkTypeface::Equal(base.getTypeface(), paint.getTypeface())) {
uint32_t id = this->getTypefaceID(paint.getTypeface());
- last = ptr;
*ptr++ = PaintOp_packOpData(kTypeface_PaintOp, id);
base.setTypeface(paint.getTypeface());
}
int index = this->flattenToIndex(get_paintflat(paint, i), (PaintFlats)i);
SkASSERT(index >= 0 && index <= fFlatArray.count());
if (index != fCurrFlatIndex[i]) {
- last = ptr;
*ptr++ = PaintOp_packOpFlagData(kFlatIndex_PaintOp, i, index);
fCurrFlatIndex[i] = index;
}
size_t size = (char*)ptr - (char*)storage;
if (size && this->needOpBytes(size)) {
this->writeOp(kPaintOp_DrawOp, 0, size);
-// *last |= kLastOp_PaintOpFlag << PAINTOPS_DATA_BITS;
fWriter.write(storage, size);
for (size_t i = 0; i < size/4; i++) {
// SkDebugf("[%d] %08X\n", i, storage[i]);
}
}
- return 0;
}
///////////////////////////////////////////////////////////////////////////////
projects / platform / upstream / libSkiaSharp.git / commitdiff