#include "SkDraw.h"
#include "SkBlitter.h"
-#include "SkBounder.h"
#include "SkCanvas.h"
#include "SkColorPriv.h"
#include "SkDevice.h"
#include "SkPathEffect.h"
#include "SkRasterClip.h"
#include "SkRasterizer.h"
+#include "SkRRect.h"
#include "SkScan.h"
#include "SkShader.h"
+#include "SkSmallAllocator.h"
#include "SkString.h"
#include "SkStroke.h"
-#include "SkTemplatesPriv.h"
+#include "SkTextMapStateProc.h"
#include "SkTLazy.h"
#include "SkUtils.h"
+#include "SkVertState.h"
#include "SkAutoKern.h"
#include "SkBitmapProcShader.h"
#include "SkDrawProcs.h"
#include "SkMatrixUtils.h"
-bool SkDraw::ShouldDrawTextAsPaths(const SkPaint& paint, const SkMatrix& ctm) {
- // we don't cache hairlines in the cache
- if (SkPaint::kStroke_Style == paint.getStyle() &&
- 0 == paint.getStrokeWidth()) {
- return true;
- }
-
- // we don't cache perspective
- if (ctm.hasPerspective()) {
- return true;
- }
-
- SkMatrix textM;
- return SkPaint::TooBigToUseCache(ctm, *paint.setTextMatrix(&textM));
-}
//#define TRACE_BITMAP_DRAWS
-#define kBlitterStorageLongCount (sizeof(SkBitmapProcShader) >> 2)
/** Helper for allocating small blitters on the stack.
*/
fBlitter = NULL;
}
SkAutoBlitterChoose(const SkBitmap& device, const SkMatrix& matrix,
- const SkPaint& paint) {
- fBlitter = SkBlitter::Choose(device, matrix, paint,
- fStorage, sizeof(fStorage));
+ const SkPaint& paint, bool drawCoverage = false) {
+ fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator,
+ drawCoverage);
}
- ~SkAutoBlitterChoose();
-
SkBlitter* operator->() { return fBlitter; }
SkBlitter* get() const { return fBlitter; }
void choose(const SkBitmap& device, const SkMatrix& matrix,
- const SkPaint& paint) {
+ const SkPaint& paint, bool drawCoverage = false) {
SkASSERT(!fBlitter);
- fBlitter = SkBlitter::Choose(device, matrix, paint,
- fStorage, sizeof(fStorage));
+ fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator,
+ drawCoverage);
}
private:
- SkBlitter* fBlitter;
- uint32_t fStorage[kBlitterStorageLongCount];
+ // Owned by fAllocator, which will handle the delete.
+ SkBlitter* fBlitter;
+ SkTBlitterAllocator fAllocator;
};
-
-SkAutoBlitterChoose::~SkAutoBlitterChoose() {
- if ((void*)fBlitter == (void*)fStorage) {
- fBlitter->~SkBlitter();
- } else {
- SkDELETE(fBlitter);
- }
-}
+#define SkAutoBlitterChoose(...) SK_REQUIRE_LOCAL_VAR(SkAutoBlitterChoose)
/**
* Since we are providing the storage for the shader (to avoid the perf cost
*/
class SkAutoBitmapShaderInstall : SkNoncopyable {
public:
- SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint)
+ SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint,
+ const SkMatrix* localMatrix = NULL)
: fPaint(paint) /* makes a copy of the paint */ {
- fPaint.setShader(SkShader::CreateBitmapShader(src,
- SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
- fStorage, sizeof(fStorage)));
+ fPaint.setShader(CreateBitmapShader(src, SkShader::kClamp_TileMode,
+ SkShader::kClamp_TileMode,
+ localMatrix, &fAllocator));
// we deliberately left the shader with an owner-count of 2
SkASSERT(2 == fPaint.getShader()->getRefCnt());
}
~SkAutoBitmapShaderInstall() {
- SkShader* shader = fPaint.getShader();
- // since we manually destroy shader, we insist that owners == 2
- SkASSERT(2 == shader->getRefCnt());
+ // since fAllocator will destroy shader, we insist that owners == 2
+ SkASSERT(2 == fPaint.getShader()->getRefCnt());
fPaint.setShader(NULL); // unref the shader by 1
- // now destroy to take care of the 2nd owner-count
- if ((void*)shader == (void*)fStorage) {
- shader->~SkShader();
- } else {
- SkDELETE(shader);
- }
}
// return the new paint that has the shader applied
const SkPaint& paintWithShader() const { return fPaint; }
private:
- SkPaint fPaint; // copy of caller's paint (which we then modify)
- uint32_t fStorage[kBlitterStorageLongCount];
+ // copy of caller's paint (which we then modify)
+ SkPaint fPaint;
+ // Stores the shader.
+ SkTBlitterAllocator fAllocator;
};
+#define SkAutoBitmapShaderInstall(...) SK_REQUIRE_LOCAL_VAR(SkAutoBitmapShaderInstall)
///////////////////////////////////////////////////////////////////////////////
static void D_Dst_BitmapXferProc(void*, size_t, uint32_t data) {}
static void D32_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
- sk_memset32((uint32_t*)pixels, data, bytes >> 2);
+ sk_memset32((uint32_t*)pixels, data, SkToInt(bytes >> 2));
}
static void D16_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
- sk_memset16((uint16_t*)pixels, data, bytes >> 1);
+ sk_memset16((uint16_t*)pixels, data, SkToInt(bytes >> 1));
}
static void DA8_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
should I worry about dithering for the lower depths?
*/
SkPMColor pmc = SkPreMultiplyColor(color);
- switch (bitmap.config()) {
- case SkBitmap::kARGB_8888_Config:
+ switch (bitmap.colorType()) {
+ case kN32_SkColorType:
if (data) {
*data = pmc;
}
// SkDebugf("--- D32_Src_BitmapXferProc\n");
return D32_Src_BitmapXferProc;
- case SkBitmap::kRGB_565_Config:
+ case kRGB_565_SkColorType:
if (data) {
*data = SkPixel32ToPixel16(pmc);
}
// SkDebugf("--- D16_Src_BitmapXferProc\n");
return D16_Src_BitmapXferProc;
- case SkBitmap::kA8_Config:
+ case kAlpha_8_SkColorType:
if (data) {
*data = SkGetPackedA32(pmc);
}
static void CallBitmapXferProc(const SkBitmap& bitmap, const SkIRect& rect,
BitmapXferProc proc, uint32_t procData) {
int shiftPerPixel;
- switch (bitmap.config()) {
- case SkBitmap::kARGB_8888_Config:
+ switch (bitmap.colorType()) {
+ case kN32_SkColorType:
shiftPerPixel = 2;
break;
- case SkBitmap::kRGB_565_Config:
+ case kRGB_565_SkColorType:
shiftPerPixel = 1;
break;
- case SkBitmap::kA8_Config:
+ case kAlpha_8_SkColorType:
shiftPerPixel = 0;
break;
default:
SkIRect devRect;
devRect.set(0, 0, fBitmap->width(), fBitmap->height());
- if (fBounder && !fBounder->doIRect(devRect)) {
- return;
- }
if (fRC->isBW()) {
/* If we don't have a shader (i.e. we're just a solid color) we may
static void bw_pt_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
for (int i = 0; i < count; i++) {
- int x = SkScalarFloor(devPts[i].fX);
- int y = SkScalarFloor(devPts[i].fY);
+ int x = SkScalarFloorToInt(devPts[i].fX);
+ int y = SkScalarFloorToInt(devPts[i].fY);
if (rec.fClip->contains(x, y)) {
blitter->blitH(x, y, 1);
}
return true;
}
if (paint.getStrokeCap() != SkPaint::kRound_Cap &&
- matrix->rectStaysRect() && SkCanvas::kPoints_PointMode == mode) {
+ matrix->isScaleTranslate() && SkCanvas::kPoints_PointMode == mode) {
SkScalar sx = matrix->get(SkMatrix::kMScaleX);
SkScalar sy = matrix->get(SkMatrix::kMScaleY);
if (SkScalarNearlyZero(sx - sy)) {
if (SkCanvas::kPoints_PointMode == fMode && fClip->isRect()) {
uint32_t value;
const SkBitmap* bm = blitter->justAnOpaqueColor(&value);
- if (bm && SkBitmap::kRGB_565_Config == bm->config()) {
+ if (bm && kRGB_565_SkColorType == bm->colorType()) {
proc = bw_pt_rect_16_hair_proc;
- } else if (bm && SkBitmap::kARGB_8888_Config == bm->config()) {
+ } else if (bm && kN32_SkColorType == bm->colorType()) {
proc = bw_pt_rect_32_hair_proc;
} else {
proc = bw_pt_rect_hair_proc;
return proc;
}
-static bool bounder_points(SkBounder* bounder, SkCanvas::PointMode mode,
- size_t count, const SkPoint pts[],
- const SkPaint& paint, const SkMatrix& matrix) {
- SkIRect ibounds;
- SkRect bounds;
- SkScalar inset = paint.getStrokeWidth();
-
- bounds.set(pts, count);
- bounds.inset(-inset, -inset);
- matrix.mapRect(&bounds);
-
- bounds.roundOut(&ibounds);
- return bounder->doIRect(ibounds);
-}
-
// each of these costs 8-bytes of stack space, so don't make it too large
// must be even for lines/polygon to work
#define MAX_DEV_PTS 32
return;
}
- if (fBounder) {
- if (!bounder_points(fBounder, mode, count, pts, paint, *fMatrix)) {
- return;
- }
-
- // clear the bounder and call this again, so we don't invoke the bounder
- // later if we happen to call ourselves for drawRect, drawPath, etc.
- SkDraw noBounder(*this);
- noBounder.fBounder = NULL;
- noBounder.drawPoints(mode, count, pts, paint, forceUseDevice);
- return;
- }
-
PtProcRec rec;
if (!forceUseDevice && rec.init(mode, paint, fMatrix, fRC)) {
SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
const size_t backup = (SkCanvas::kPolygon_PointMode == mode);
do {
- size_t n = count;
+ int n = SkToInt(count);
if (n > MAX_DEV_PTS) {
n = MAX_DEV_PTS;
}
matrix->mapPoints(devPts, pts, n);
proc(rec, devPts, n, bltr);
pts += n - backup;
- SkASSERT(count >= n);
+ SkASSERT(SkToInt(count) >= n);
count -= n;
if (count > 0) {
count += backup;
}
case SkCanvas::kLines_PointMode:
#ifndef SK_DISABLE_DASHING_OPTIMIZATION
- if (2 == count && NULL != paint.getPathEffect()) {
+ if (2 == count && paint.getPathEffect()) {
// most likely a dashed line - see if it is one of the ones
// we can accelerate
SkStrokeRec rec(paint);
matrix.mapPoints(rect_points(devRect), rect_points(rect), 2);
devRect.sort();
- if (fBounder && !fBounder->doRect(devRect, paint)) {
- return;
- }
-
// look for the quick exit, before we build a blitter
SkIRect ir;
devRect.roundOut(&ir);
if (paint.getStyle() != SkPaint::kFill_Style) {
// extra space for hairlines
- ir.inset(-1, -1);
+ if (paint.getStrokeWidth() == 0) {
+ ir.outset(1, 1);
+ } else {
+ SkScalar radius = SkScalarHalf(paint.getStrokeWidth());
+ ir.outset(radius, radius);
+ }
}
if (fRC->quickReject(ir)) {
return;
}
SkAutoMaskFreeImage ami(dstM.fImage);
- if (fBounder && !fBounder->doIRect(mask->fBounds)) {
- return;
- }
-
SkAutoBlitterChoose blitterChooser(*fBitmap, *fMatrix, paint);
SkBlitter* blitter = blitterChooser.get();
}
}
-bool SkDrawTreatAsHairline(const SkPaint& paint, const SkMatrix& matrix,
- SkScalar* coverage) {
- SkASSERT(coverage);
- if (SkPaint::kStroke_Style != paint.getStyle()) {
- return false;
- }
- SkScalar strokeWidth = paint.getStrokeWidth();
- if (0 == strokeWidth) {
- *coverage = SK_Scalar1;
- return true;
- }
-
- // if we get here, we need to try to fake a thick-stroke with a modulated
- // hairline
+bool SkDrawTreatAAStrokeAsHairline(SkScalar strokeWidth, const SkMatrix& matrix,
+ SkScalar* coverage) {
+ SkASSERT(strokeWidth > 0);
+ // We need to try to fake a thick-stroke with a modulated hairline.
- if (!paint.isAntiAlias()) {
- return false;
- }
if (matrix.hasPerspective()) {
return false;
}
SkScalar len0 = fast_len(dst[0]);
SkScalar len1 = fast_len(dst[1]);
if (len0 <= SK_Scalar1 && len1 <= SK_Scalar1) {
- *coverage = SkScalarAve(len0, len1);
+ if (coverage) {
+ *coverage = SkScalarAve(len0, len1);
+ }
return true;
}
return false;
}
+void SkDraw::drawRRect(const SkRRect& rrect, const SkPaint& paint) const {
+ SkDEBUGCODE(this->validate());
+
+ if (fRC->isEmpty()) {
+ return;
+ }
+
+ {
+ // TODO: Investigate optimizing these options. They are in the same
+ // order as SkDraw::drawPath, which handles each case. It may be
+ // that there is no way to optimize for these using the SkRRect path.
+ SkScalar coverage;
+ if (SkDrawTreatAsHairline(paint, *fMatrix, &coverage)) {
+ goto DRAW_PATH;
+ }
+
+ if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
+ goto DRAW_PATH;
+ }
+
+ if (paint.getRasterizer()) {
+ goto DRAW_PATH;
+ }
+ }
+
+ if (paint.getMaskFilter()) {
+ // Transform the rrect into device space.
+ SkRRect devRRect;
+ if (rrect.transform(*fMatrix, &devRRect)) {
+ SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
+ if (paint.getMaskFilter()->filterRRect(devRRect, *fMatrix, *fRC, blitter.get(),
+ SkPaint::kFill_Style)) {
+ return; // filterRRect() called the blitter, so we're done
+ }
+ }
+ }
+
+DRAW_PATH:
+ // Now fall back to the default case of using a path.
+ SkPath path;
+ path.addRRect(rrect);
+ this->drawPath(path, paint, NULL, true);
+}
+
void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint,
- const SkMatrix* prePathMatrix, bool pathIsMutable) const {
+ const SkMatrix* prePathMatrix, bool pathIsMutable,
+ bool drawCoverage, SkBlitter* customBlitter) const {
SkDEBUGCODE(this->validate();)
// nothing to draw
pathPtr->transform(*prePathMatrix, result);
pathPtr = result;
} else {
- if (!tmpMatrix.setConcat(*matrix, *prePathMatrix)) {
- // overflow
- return;
- }
+ tmpMatrix.setConcat(*matrix, *prePathMatrix);
matrix = &tmpMatrix;
}
}
// transform the path into device space
pathPtr->transform(*matrix, devPathPtr);
- SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, *paint);
+ SkBlitter* blitter = NULL;
+ SkAutoBlitterChoose blitterStorage;
+ if (NULL == customBlitter) {
+ blitterStorage.choose(*fBitmap, *fMatrix, *paint, drawCoverage);
+ blitter = blitterStorage.get();
+ } else {
+ blitter = customBlitter;
+ }
if (paint->getMaskFilter()) {
SkPaint::Style style = doFill ? SkPaint::kFill_Style :
SkPaint::kStroke_Style;
- if (paint->getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fRC,
- fBounder, blitter.get(),
- style)) {
+ if (paint->getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fRC, blitter, style)) {
return; // filterPath() called the blitter, so we're done
}
}
- if (fBounder && !fBounder->doPath(*devPathPtr, *paint, doFill)) {
- return;
- }
-
void (*proc)(const SkPath&, const SkRasterClip&, SkBlitter*);
if (doFill) {
if (paint->isAntiAlias()) {
proc = SkScan::HairPath;
}
}
- proc(*devPathPtr, *fRC, blitter.get());
+ proc(*devPathPtr, *fRC, blitter);
}
/** For the purposes of drawing bitmaps, if a matrix is "almost" translate
void SkDraw::drawBitmapAsMask(const SkBitmap& bitmap,
const SkPaint& paint) const {
- SkASSERT(bitmap.config() == SkBitmap::kA8_Config);
+ SkASSERT(bitmap.colorType() == kAlpha_8_SkColorType);
if (just_translate(*fMatrix, bitmap)) {
- int ix = SkScalarRound(fMatrix->getTranslateX());
- int iy = SkScalarRound(fMatrix->getTranslateY());
+ int ix = SkScalarRoundToInt(fMatrix->getTranslateX());
+ int iy = SkScalarRoundToInt(fMatrix->getTranslateY());
SkAutoLockPixels alp(bitmap);
if (!bitmap.readyToDraw()) {
// now draw our bitmap(src) into mask(dst), transformed by the matrix
{
SkBitmap device;
- device.setConfig(SkBitmap::kA8_Config, mask.fBounds.width(),
- mask.fBounds.height(), mask.fRowBytes);
- device.setPixels(mask.fImage);
+ device.installPixels(SkImageInfo::MakeA8(mask.fBounds.width(), mask.fBounds.height()),
+ mask.fImage, mask.fRowBytes);
SkCanvas c(device);
// need the unclipped top/left for the translate
// nothing to draw
if (fRC->isEmpty() ||
bitmap.width() == 0 || bitmap.height() == 0 ||
- bitmap.config() == SkBitmap::kNo_Config) {
+ bitmap.colorType() == kUnknown_SkColorType) {
return;
}
paint.setStyle(SkPaint::kFill_Style);
SkMatrix matrix;
- if (!matrix.setConcat(*fMatrix, prematrix)) {
- return;
- }
+ matrix.setConcat(*fMatrix, prematrix);
if (clipped_out(matrix, *fRC, bitmap.width(), bitmap.height())) {
return;
}
- if (fBounder && just_translate(matrix, bitmap)) {
- SkIRect ir;
- int32_t ix = SkScalarRound(matrix.getTranslateX());
- int32_t iy = SkScalarRound(matrix.getTranslateY());
- ir.set(ix, iy, ix + bitmap.width(), iy + bitmap.height());
- if (!fBounder->doIRect(ir)) {
- return;
- }
- }
-
- if (bitmap.config() != SkBitmap::kA8_Config &&
- just_translate(matrix, bitmap)) {
+ if (bitmap.colorType() != kAlpha_8_SkColorType && just_translate(matrix, bitmap)) {
//
// It is safe to call lock pixels now, since we know the matrix is
// (more or less) identity.
if (!bitmap.readyToDraw()) {
return;
}
- int ix = SkScalarRound(matrix.getTranslateX());
- int iy = SkScalarRound(matrix.getTranslateY());
+ int ix = SkScalarRoundToInt(matrix.getTranslateX());
+ int iy = SkScalarRoundToInt(matrix.getTranslateY());
if (clipHandlesSprite(*fRC, ix, iy, bitmap)) {
- uint32_t storage[kBlitterStorageLongCount];
- SkBlitter* blitter = SkBlitter::ChooseSprite(*fBitmap, paint, bitmap,
- ix, iy, storage, sizeof(storage));
+ SkTBlitterAllocator allocator;
+ // blitter will be owned by the allocator.
+ SkBlitter* blitter = SkBlitter::ChooseSprite(*fBitmap, paint, bitmap,
+ ix, iy, &allocator);
if (blitter) {
- SkAutoTPlacementDelete<SkBlitter> ad(blitter, storage);
-
SkIRect ir;
ir.set(ix, iy, ix + bitmap.width(), iy + bitmap.height());
SkDraw draw(*this);
draw.fMatrix = &matrix;
- if (bitmap.config() == SkBitmap::kA8_Config) {
+ if (bitmap.colorType() == kAlpha_8_SkColorType) {
draw.drawBitmapAsMask(bitmap, paint);
} else {
SkAutoBitmapShaderInstall install(bitmap, paint);
// nothing to draw
if (fRC->isEmpty() ||
bitmap.width() == 0 || bitmap.height() == 0 ||
- bitmap.config() == SkBitmap::kNo_Config) {
+ bitmap.colorType() == kUnknown_SkColorType) {
return;
}
paint.setStyle(SkPaint::kFill_Style);
if (NULL == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, bitmap)) {
- uint32_t storage[kBlitterStorageLongCount];
- SkBlitter* blitter = SkBlitter::ChooseSprite(*fBitmap, paint, bitmap,
- x, y, storage, sizeof(storage));
+ SkTBlitterAllocator allocator;
+ // blitter will be owned by the allocator.
+ SkBlitter* blitter = SkBlitter::ChooseSprite(*fBitmap, paint, bitmap,
+ x, y, &allocator);
if (blitter) {
- SkAutoTPlacementDelete<SkBlitter> ad(blitter, storage);
-
- if (fBounder && !fBounder->doIRect(bounds)) {
- return;
- }
-
SkScan::FillIRect(bounds, *fRC, blitter);
return;
}
}
- SkAutoBitmapShaderInstall install(bitmap, paint);
- const SkPaint& shaderPaint = install.paintWithShader();
-
SkMatrix matrix;
SkRect r;
// get a scalar version of our rect
r.set(bounds);
- // tell the shader our offset
+ // create shader with offset
matrix.setTranslate(r.fLeft, r.fTop);
- shaderPaint.getShader()->setLocalMatrix(matrix);
+ SkAutoBitmapShaderInstall install(bitmap, paint, &matrix);
+ const SkPaint& shaderPaint = install.paintWithShader();
SkDraw draw(*this);
matrix.reset();
SkASSERT(text == stop);
}
+bool SkDraw::ShouldDrawTextAsPaths(const SkPaint& paint, const SkMatrix& ctm) {
+ // hairline glyphs are fast enough so we don't need to cache them
+ if (SkPaint::kStroke_Style == paint.getStyle() && 0 == paint.getStrokeWidth()) {
+ return true;
+ }
+
+ // we don't cache perspective
+ if (ctm.hasPerspective()) {
+ return true;
+ }
+
+ SkMatrix textM;
+ return SkPaint::TooBigToUseCache(ctm, *paint.setTextMatrix(&textM));
+}
+
void SkDraw::drawText_asPaths(const char text[], size_t byteLength,
SkScalar x, SkScalar y,
const SkPaint& paint) const {
//////////////////////////////////////////////////////////////////////////////
-static void D1G_NoBounder_RectClip(const SkDraw1Glyph& state,
- SkFixed fx, SkFixed fy,
- const SkGlyph& glyph) {
- int left = SkFixedFloor(fx);
- int top = SkFixedFloor(fy);
+static void D1G_RectClip(const SkDraw1Glyph& state, SkFixed fx, SkFixed fy, const SkGlyph& glyph) {
+ int left = SkFixedFloorToInt(fx);
+ int top = SkFixedFloorToInt(fy);
SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
- SkASSERT(NULL == state.fBounder);
SkASSERT((NULL == state.fClip && state.fAAClip) ||
(state.fClip && NULL == state.fAAClip && state.fClip->isRect()));
state.blitMask(mask, *bounds);
}
-static void D1G_NoBounder_RgnClip(const SkDraw1Glyph& state,
- SkFixed fx, SkFixed fy,
- const SkGlyph& glyph) {
- int left = SkFixedFloor(fx);
- int top = SkFixedFloor(fy);
+static void D1G_RgnClip(const SkDraw1Glyph& state, SkFixed fx, SkFixed fy, const SkGlyph& glyph) {
+ int left = SkFixedFloorToInt(fx);
+ int top = SkFixedFloorToInt(fy);
SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
SkASSERT(!state.fClip->isRect());
- SkASSERT(NULL == state.fBounder);
SkMask mask;
}
}
-static void D1G_Bounder(const SkDraw1Glyph& state,
- SkFixed fx, SkFixed fy,
- const SkGlyph& glyph) {
- int left = SkFixedFloor(fx);
- int top = SkFixedFloor(fy);
- SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
-
- SkMask mask;
-
- left += glyph.fLeft;
- top += glyph.fTop;
-
- mask.fBounds.set(left, top, left + glyph.fWidth, top + glyph.fHeight);
- SkRegion::Cliperator clipper(*state.fClip, mask.fBounds);
-
- if (!clipper.done()) {
- const SkIRect& cr = clipper.rect();
- const uint8_t* aa = (const uint8_t*)glyph.fImage;
- if (NULL == aa) {
- aa = (uint8_t*)state.fCache->findImage(glyph);
- if (NULL == aa) {
- return;
- }
- }
-
- // we need to pass the origin, which we approximate with our
- // (unadjusted) left,top coordinates (the caller called fixedfloor)
- if (state.fBounder->doIRectGlyph(cr,
- left - glyph.fLeft,
- top - glyph.fTop, glyph)) {
- mask.fRowBytes = glyph.rowBytes();
- mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
- mask.fImage = (uint8_t*)aa;
- do {
- state.blitMask(mask, cr);
- clipper.next();
- } while (!clipper.done());
- }
- }
-}
-
-static void D1G_Bounder_AAClip(const SkDraw1Glyph& state,
- SkFixed fx, SkFixed fy,
- const SkGlyph& glyph) {
- int left = SkFixedFloor(fx);
- int top = SkFixedFloor(fy);
- SkIRect bounds;
- bounds.set(left, top, left + glyph.fWidth, top + glyph.fHeight);
-
- if (state.fBounder->doIRectGlyph(bounds, left, top, glyph)) {
- D1G_NoBounder_RectClip(state, fx, fy, glyph);
- }
-}
-
static bool hasCustomD1GProc(const SkDraw& draw) {
return draw.fProcs && draw.fProcs->fD1GProc;
}
return !hasCustomD1GProc(draw);
}
-SkDraw1Glyph::Proc SkDraw1Glyph::init(const SkDraw* draw, SkBlitter* blitter,
- SkGlyphCache* cache, const SkPaint& pnt) {
+SkDraw1Glyph::Proc SkDraw1Glyph::init(const SkDraw* draw, SkBlitter* blitter, SkGlyphCache* cache,
+ const SkPaint& pnt) {
fDraw = draw;
- fBounder = draw->fBounder;
fBlitter = blitter;
fCache = cache;
fPaint = &pnt;
fAAClip = NULL;
fClip = &draw->fRC->bwRgn();
fClipBounds = fClip->getBounds();
- if (NULL == fBounder) {
- if (fClip->isRect()) {
- return D1G_NoBounder_RectClip;
- } else {
- return D1G_NoBounder_RgnClip;
- }
+ if (fClip->isRect()) {
+ return D1G_RectClip;
} else {
- return D1G_Bounder;
+ return D1G_RgnClip;
}
} else { // aaclip
fAAClip = &draw->fRC->aaRgn();
fClip = NULL;
fClipBounds = fAAClip->getBounds();
- if (NULL == fBounder) {
- return D1G_NoBounder_RectClip;
- } else {
- return D1G_Bounder_AAClip;
- }
+ return D1G_RectClip;
}
}
SkASSERT(SkMask::kARGB32_Format == mask.fFormat);
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config,
- mask.fBounds.width(), mask.fBounds.height(), mask.fRowBytes);
- bm.setPixels((SkPMColor*)mask.fImage);
+ bm.installPixels(SkImageInfo::MakeN32Premul(mask.fBounds.width(), mask.fBounds.height()),
+ (SkPMColor*)mask.fImage, mask.fRowBytes);
fDraw->drawSprite(bm, mask.fBounds.x(), mask.fBounds.y(), *fPaint);
}
SkDrawCacheProc glyphCacheProc = paint.getDrawCacheProc();
- SkAutoGlyphCache autoCache(paint, &fDevice->fLeakyProperties, fMatrix);
+ SkAutoGlyphCache autoCache(paint, &fDevice->getLeakyProperties(), fMatrix);
SkGlyphCache* cache = autoCache.getCache();
// transform our starting point
if (glyph.fWidth) {
proc(d1g, fx, fy, glyph);
}
+
fx += glyph.fAdvanceX;
fy += glyph.fAdvanceY;
}
}
-// last parameter is interpreted as SkFixed [x, y]
-// return the fixed position, which may be rounded or not by the caller
-// e.g. subpixel doesn't round
-typedef void (*AlignProc)(const SkPoint&, const SkGlyph&, SkIPoint*);
-
-static void leftAlignProc(const SkPoint& loc, const SkGlyph& glyph,
- SkIPoint* dst) {
- dst->set(SkScalarToFixed(loc.fX), SkScalarToFixed(loc.fY));
-}
-
-static void centerAlignProc(const SkPoint& loc, const SkGlyph& glyph,
- SkIPoint* dst) {
- dst->set(SkScalarToFixed(loc.fX) - (glyph.fAdvanceX >> 1),
- SkScalarToFixed(loc.fY) - (glyph.fAdvanceY >> 1));
-}
-
-static void rightAlignProc(const SkPoint& loc, const SkGlyph& glyph,
- SkIPoint* dst) {
- dst->set(SkScalarToFixed(loc.fX) - glyph.fAdvanceX,
- SkScalarToFixed(loc.fY) - glyph.fAdvanceY);
-}
-
-static AlignProc pick_align_proc(SkPaint::Align align) {
- static const AlignProc gProcs[] = {
- leftAlignProc, centerAlignProc, rightAlignProc
- };
-
- SkASSERT((unsigned)align < SK_ARRAY_COUNT(gProcs));
-
- return gProcs[align];
-}
-
-class TextMapState {
-public:
- mutable SkPoint fLoc;
-
- TextMapState(const SkMatrix& matrix, SkScalar y)
- : fMatrix(matrix), fProc(matrix.getMapXYProc()), fY(y) {}
-
- typedef void (*Proc)(const TextMapState&, const SkScalar pos[]);
-
- Proc pickProc(int scalarsPerPosition);
-
-private:
- const SkMatrix& fMatrix;
- SkMatrix::MapXYProc fProc;
- SkScalar fY; // ignored by MapXYProc
- // these are only used by Only... procs
- SkScalar fScaleX, fTransX, fTransformedY;
-
- static void MapXProc(const TextMapState& state, const SkScalar pos[]) {
- state.fProc(state.fMatrix, *pos, state.fY, &state.fLoc);
- }
-
- static void MapXYProc(const TextMapState& state, const SkScalar pos[]) {
- state.fProc(state.fMatrix, pos[0], pos[1], &state.fLoc);
- }
-
- static void MapOnlyScaleXProc(const TextMapState& state,
- const SkScalar pos[]) {
- state.fLoc.set(SkScalarMul(state.fScaleX, *pos) + state.fTransX,
- state.fTransformedY);
- }
-
- static void MapOnlyTransXProc(const TextMapState& state,
- const SkScalar pos[]) {
- state.fLoc.set(*pos + state.fTransX, state.fTransformedY);
- }
-};
-
-TextMapState::Proc TextMapState::pickProc(int scalarsPerPosition) {
- SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
-
- if (1 == scalarsPerPosition) {
- unsigned mtype = fMatrix.getType();
- if (mtype & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
- return MapXProc;
- } else {
- fScaleX = fMatrix.getScaleX();
- fTransX = fMatrix.getTranslateX();
- fTransformedY = SkScalarMul(fY, fMatrix.getScaleY()) +
- fMatrix.getTranslateY();
- return (mtype & SkMatrix::kScale_Mask) ?
- MapOnlyScaleXProc : MapOnlyTransXProc;
- }
- } else {
- return MapXYProc;
- }
-}
-
//////////////////////////////////////////////////////////////////////////////
void SkDraw::drawPosText_asPaths(const char text[], size_t byteLength,
SkMatrix matrix;
matrix.setScale(matrixScale, matrixScale);
+ // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache.
+ paint.setStyle(SkPaint::kFill_Style);
+ paint.setPathEffect(NULL);
+
SkDrawCacheProc glyphCacheProc = paint.getDrawCacheProc();
SkAutoGlyphCache autoCache(paint, NULL, NULL);
SkGlyphCache* cache = autoCache.getCache();
const char* stop = text + byteLength;
- AlignProc alignProc = pick_align_proc(paint.getTextAlign());
- TextMapState tms(SkMatrix::I(), constY);
- TextMapState::Proc tmsProc = tms.pickProc(scalarsPerPosition);
+ SkTextAlignProcScalar alignProc(paint.getTextAlign());
+ SkTextMapStateProc tmsProc(SkMatrix::I(), constY, scalarsPerPosition);
+
+ // Now restore the original settings, so we "draw" with whatever style/stroking.
+ paint.setStyle(origPaint.getStyle());
+ paint.setPathEffect(origPaint.getPathEffect());
while (text < stop) {
const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
if (glyph.fWidth) {
const SkPath* path = cache->findPath(glyph);
if (path) {
- tmsProc(tms, pos);
- SkIPoint fixedLoc;
- alignProc(tms.fLoc, glyph, &fixedLoc);
+ SkPoint tmsLoc;
+ tmsProc(pos, &tmsLoc);
+ SkPoint loc;
+ alignProc(tmsLoc, glyph, &loc);
- matrix[SkMatrix::kMTransX] = SkFixedToScalar(fixedLoc.fX);
- matrix[SkMatrix::kMTransY] = SkFixedToScalar(fixedLoc.fY);
+ matrix[SkMatrix::kMTransX] = loc.fX;
+ matrix[SkMatrix::kMTransY] = loc.fY;
if (fDevice) {
fDevice->drawPath(*this, *path, paint, &matrix, false);
} else {
}
SkDrawCacheProc glyphCacheProc = paint.getDrawCacheProc();
- SkAutoGlyphCache autoCache(paint, &fDevice->fLeakyProperties, fMatrix);
+ SkAutoGlyphCache autoCache(paint, &fDevice->getLeakyProperties(), fMatrix);
SkGlyphCache* cache = autoCache.getCache();
SkAAClipBlitterWrapper wrapper;
}
const char* stop = text + byteLength;
- AlignProc alignProc = pick_align_proc(paint.getTextAlign());
+ SkTextAlignProc alignProc(paint.getTextAlign());
SkDraw1Glyph d1g;
SkDraw1Glyph::Proc proc = d1g.init(this, blitter, cache, paint);
- TextMapState tms(*fMatrix, constY);
- TextMapState::Proc tmsProc = tms.pickProc(scalarsPerPosition);
+ SkTextMapStateProc tmsProc(*fMatrix, constY, scalarsPerPosition);
if (cache->isSubpixel()) {
// maybe we should skip the rounding if linearText is set
if (SkPaint::kLeft_Align == paint.getTextAlign()) {
while (text < stop) {
- tmsProc(tms, pos);
-
- SkFixed fx = SkScalarToFixed(tms.fLoc.fX) + d1g.fHalfSampleX;
- SkFixed fy = SkScalarToFixed(tms.fLoc.fY) + d1g.fHalfSampleY;
+ SkPoint tmsLoc;
+ tmsProc(pos, &tmsLoc);
+ SkFixed fx = SkScalarToFixed(tmsLoc.fX) + d1g.fHalfSampleX;
+ SkFixed fy = SkScalarToFixed(tmsLoc.fY) + d1g.fHalfSampleY;
const SkGlyph& glyph = glyphCacheProc(cache, &text,
fx & fxMask, fy & fyMask);
if (metricGlyph.fWidth) {
SkDEBUGCODE(SkFixed prevAdvX = metricGlyph.fAdvanceX;)
SkDEBUGCODE(SkFixed prevAdvY = metricGlyph.fAdvanceY;)
-
- tmsProc(tms, pos);
+ SkPoint tmsLoc;
+ tmsProc(pos, &tmsLoc);
SkIPoint fixedLoc;
- alignProc(tms.fLoc, metricGlyph, &fixedLoc);
+ alignProc(tmsLoc, metricGlyph, &fixedLoc);
SkFixed fx = fixedLoc.fX + d1g.fHalfSampleX;
SkFixed fy = fixedLoc.fY + d1g.fHalfSampleY;
const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
if (glyph.fWidth) {
- tmsProc(tms, pos);
+ SkPoint tmsLoc;
+ tmsProc(pos, &tmsLoc);
proc(d1g,
- SkScalarToFixed(tms.fLoc.fX) + SK_FixedHalf, //d1g.fHalfSampleX,
- SkScalarToFixed(tms.fLoc.fY) + SK_FixedHalf, //d1g.fHalfSampleY,
+ SkScalarToFixed(tmsLoc.fX) + SK_FixedHalf, //d1g.fHalfSampleX,
+ SkScalarToFixed(tmsLoc.fY) + SK_FixedHalf, //d1g.fHalfSampleY,
glyph);
}
pos += scalarsPerPosition;
const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
if (glyph.fWidth) {
- tmsProc(tms, pos);
+ SkPoint tmsLoc;
+ tmsProc(pos, &tmsLoc);
SkIPoint fixedLoc;
- alignProc(tms.fLoc, glyph, &fixedLoc);
+ alignProc(tmsLoc, glyph, &fixedLoc);
proc(d1g,
fixedLoc.fX + SK_FixedHalf, //d1g.fHalfSampleX,
}
}
-#ifdef SK_BUILD_FOR_ANDROID
-void SkDraw::drawPosTextOnPath(const char text[], size_t byteLength,
- const SkPoint pos[], const SkPaint& paint,
- const SkPath& path, const SkMatrix* matrix) const {
- // nothing to draw
- if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
- return;
- }
-
- SkMatrix scaledMatrix;
- SkPathMeasure meas(path, false);
-
- SkMeasureCacheProc glyphCacheProc = paint.getMeasureCacheProc(
- SkPaint::kForward_TextBufferDirection, true);
-
- // Copied (modified) from SkTextToPathIter constructor to setup paint
- SkPaint tempPaint(paint);
-
- tempPaint.setLinearText(true);
- tempPaint.setMaskFilter(NULL); // don't want this affecting our path-cache lookup
-
- if (tempPaint.getPathEffect() == NULL && !(tempPaint.getStrokeWidth() > 0
- && tempPaint.getStyle() != SkPaint::kFill_Style)) {
- tempPaint.setStyle(SkPaint::kFill_Style);
- tempPaint.setPathEffect(NULL);
- }
- // End copied from SkTextToPathIter constructor
-
- // detach cache
- SkGlyphCache* cache = tempPaint.detachCache(NULL, NULL);
-
- // Must set scale, even if 1
- SkScalar scale = SK_Scalar1;
- scaledMatrix.setScale(scale, scale);
-
- // Loop over all glyph ids
- for (const char* stop = text + byteLength; text < stop; pos++) {
-
- const SkGlyph& glyph = glyphCacheProc(cache, &text);
- SkPath tmp;
-
- const SkPath* glyphPath = cache->findPath(glyph);
- if (glyphPath == NULL) {
- continue;
- }
-
- SkMatrix m(scaledMatrix);
- m.postTranslate(pos->fX, 0);
-
- if (matrix) {
- m.postConcat(*matrix);
- }
-
- morphpath(&tmp, *glyphPath, meas, m);
- this->drawPath(tmp, tempPaint);
-
- }
-
- // re-attach cache
- SkGlyphCache::AttachCache(cache);
-}
-#endif
-
///////////////////////////////////////////////////////////////////////////////
-struct VertState {
- int f0, f1, f2;
-
- VertState(int vCount, const uint16_t indices[], int indexCount)
- : fIndices(indices) {
- fCurrIndex = 0;
- if (indices) {
- fCount = indexCount;
- } else {
- fCount = vCount;
- }
- }
-
- typedef bool (*Proc)(VertState*);
- Proc chooseProc(SkCanvas::VertexMode mode);
-
-private:
- int fCount;
- int fCurrIndex;
- const uint16_t* fIndices;
-
- static bool Triangles(VertState*);
- static bool TrianglesX(VertState*);
- static bool TriangleStrip(VertState*);
- static bool TriangleStripX(VertState*);
- static bool TriangleFan(VertState*);
- static bool TriangleFanX(VertState*);
-};
-
-bool VertState::Triangles(VertState* state) {
- int index = state->fCurrIndex;
- if (index + 3 > state->fCount) {
- return false;
- }
- state->f0 = index + 0;
- state->f1 = index + 1;
- state->f2 = index + 2;
- state->fCurrIndex = index + 3;
- return true;
-}
-
-bool VertState::TrianglesX(VertState* state) {
- const uint16_t* indices = state->fIndices;
- int index = state->fCurrIndex;
- if (index + 3 > state->fCount) {
- return false;
- }
- state->f0 = indices[index + 0];
- state->f1 = indices[index + 1];
- state->f2 = indices[index + 2];
- state->fCurrIndex = index + 3;
- return true;
-}
-
-bool VertState::TriangleStrip(VertState* state) {
- int index = state->fCurrIndex;
- if (index + 3 > state->fCount) {
- return false;
- }
- state->f2 = index + 2;
- if (index & 1) {
- state->f0 = index + 1;
- state->f1 = index + 0;
- } else {
- state->f0 = index + 0;
- state->f1 = index + 1;
- }
- state->fCurrIndex = index + 1;
- return true;
-}
-
-bool VertState::TriangleStripX(VertState* state) {
- const uint16_t* indices = state->fIndices;
- int index = state->fCurrIndex;
- if (index + 3 > state->fCount) {
- return false;
- }
- state->f2 = indices[index + 2];
- if (index & 1) {
- state->f0 = indices[index + 1];
- state->f1 = indices[index + 0];
- } else {
- state->f0 = indices[index + 0];
- state->f1 = indices[index + 1];
- }
- state->fCurrIndex = index + 1;
- return true;
-}
-
-bool VertState::TriangleFan(VertState* state) {
- int index = state->fCurrIndex;
- if (index + 3 > state->fCount) {
- return false;
- }
- state->f0 = 0;
- state->f1 = index + 1;
- state->f2 = index + 2;
- state->fCurrIndex = index + 1;
- return true;
-}
-
-bool VertState::TriangleFanX(VertState* state) {
- const uint16_t* indices = state->fIndices;
- int index = state->fCurrIndex;
- if (index + 3 > state->fCount) {
- return false;
- }
- state->f0 = indices[0];
- state->f1 = indices[index + 1];
- state->f2 = indices[index + 2];
- state->fCurrIndex = index + 1;
- return true;
-}
-
-VertState::Proc VertState::chooseProc(SkCanvas::VertexMode mode) {
- switch (mode) {
- case SkCanvas::kTriangles_VertexMode:
- return fIndices ? TrianglesX : Triangles;
- case SkCanvas::kTriangleStrip_VertexMode:
- return fIndices ? TriangleStripX : TriangleStrip;
- case SkCanvas::kTriangleFan_VertexMode:
- return fIndices ? TriangleFanX : TriangleFan;
- default:
- return NULL;
- }
-}
-
typedef void (*HairProc)(const SkPoint&, const SkPoint&, const SkRasterClip&,
SkBlitter*);
public:
SkTriColorShader() {}
- bool setup(const SkPoint pts[], const SkColor colors[], int, int, int);
+ virtual size_t contextSize() const SK_OVERRIDE;
+
+ class TriColorShaderContext : public SkShader::Context {
+ public:
+ TriColorShaderContext(const SkTriColorShader& shader, const ContextRec&);
+ virtual ~TriColorShaderContext();
- virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
+ bool setup(const SkPoint pts[], const SkColor colors[], int, int, int);
- SK_DEVELOPER_TO_STRING()
- SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTriColorShader)
+ virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
+
+ private:
+ SkMatrix fDstToUnit;
+ SkPMColor fColors[3];
+
+ typedef SkShader::Context INHERITED;
+ };
+
+ SK_TO_STRING_OVERRIDE()
+ SK_DECLARE_NOT_FLATTENABLE_PROCS(SkTriColorShader)
protected:
- SkTriColorShader(SkFlattenableReadBuffer& buffer) : SkShader(buffer) {}
+ virtual Context* onCreateContext(const ContextRec& rec, void* storage) const SK_OVERRIDE {
+ return SkNEW_PLACEMENT_ARGS(storage, TriColorShaderContext, (*this, rec));
+ }
private:
- SkMatrix fDstToUnit;
- SkPMColor fColors[3];
-
typedef SkShader INHERITED;
};
-bool SkTriColorShader::setup(const SkPoint pts[], const SkColor colors[],
- int index0, int index1, int index2) {
+bool SkTriColorShader::TriColorShaderContext::setup(const SkPoint pts[], const SkColor colors[],
+ int index0, int index1, int index2) {
fColors[0] = SkPreMultiplyColor(colors[index0]);
fColors[1] = SkPreMultiplyColor(colors[index1]);
if (!m.invert(&im)) {
return false;
}
- return fDstToUnit.setConcat(im, this->getTotalInverse());
+ // We can't call getTotalInverse(), because we explicitly don't want to look at the localmatrix
+ // as our interators are intrinsically tied to the vertices, and nothing else.
+ SkMatrix ctmInv;
+ if (!this->getCTM().invert(&ctmInv)) {
+ return false;
+ }
+ fDstToUnit.setConcat(im, ctmInv);
+ return true;
}
#include "SkColorPriv.h"
return SkAlpha255To256(scale);
}
-void SkTriColorShader::shadeSpan(int x, int y, SkPMColor dstC[], int count) {
+
+SkTriColorShader::TriColorShaderContext::TriColorShaderContext(const SkTriColorShader& shader,
+ const ContextRec& rec)
+ : INHERITED(shader, rec) {}
+
+SkTriColorShader::TriColorShaderContext::~TriColorShaderContext() {}
+
+size_t SkTriColorShader::contextSize() const {
+ return sizeof(TriColorShaderContext);
+}
+void SkTriColorShader::TriColorShaderContext::shadeSpan(int x, int y, SkPMColor dstC[], int count) {
+ const int alphaScale = Sk255To256(this->getPaintAlpha());
+
SkPoint src;
for (int i = 0; i < count; i++) {
scale0 = 0;
}
+ if (256 != alphaScale) {
+ scale0 = SkAlphaMul(scale0, alphaScale);
+ scale1 = SkAlphaMul(scale1, alphaScale);
+ scale2 = SkAlphaMul(scale2, alphaScale);
+ }
+
dstC[i] = SkAlphaMulQ(fColors[0], scale0) +
- SkAlphaMulQ(fColors[1], scale1) +
- SkAlphaMulQ(fColors[2], scale2);
+ SkAlphaMulQ(fColors[1], scale1) +
+ SkAlphaMulQ(fColors[2], scale2);
}
}
-#ifdef SK_DEVELOPER
+#ifndef SK_IGNORE_TO_STRING
void SkTriColorShader::toString(SkString* str) const {
str->append("SkTriColorShader: (");
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) const {
- SkASSERT(0 == count || NULL != vertices);
+ SkASSERT(0 == count || vertices);
// abort early if there is nothing to draw
if (count < 3 || (indices && indexCount < 3) || fRC->isEmpty()) {
SkPoint* devVerts = storage.get();
fMatrix->mapPoints(devVerts, vertices, count);
- if (fBounder) {
- SkRect bounds;
- bounds.set(devVerts, count);
- if (!fBounder->doRect(bounds, paint)) {
- return;
- }
- }
-
/*
We can draw the vertices in 1 of 4 ways:
}
// setup the custom shader (if needed)
- if (NULL != colors) {
+ SkAutoTUnref<SkComposeShader> composeShader;
+ if (colors) {
if (NULL == textures) {
// just colors (no texture)
shader = p.setShader(&triShader);
xmode = SkXfermode::Create(SkXfermode::kModulate_Mode);
releaseMode = true;
}
- SkShader* compose = SkNEW_ARGS(SkComposeShader,
- (&triShader, shader, xmode));
- p.setShader(compose)->unref();
+ composeShader.reset(SkNEW_ARGS(SkComposeShader, (&triShader, shader, xmode)));
+ p.setShader(composeShader);
if (releaseMode) {
xmode->unref();
}
- shader = compose;
}
}
SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, p);
- // important that we abort early, as below we may manipulate the shader
- // and that is only valid if the shader returned true from setContext.
- // If it returned false, then our blitter will be the NullBlitter.
+ // Abort early if we failed to create a shader context.
if (blitter->isNullBlitter()) {
return;
}
VertState state(count, indices, indexCount);
VertState::Proc vertProc = state.chooseProc(vmode);
- if (NULL != textures || NULL != colors) {
- SkMatrix tempM;
- SkMatrix savedLocalM;
- if (shader) {
- savedLocalM = shader->getLocalMatrix();
- }
-
- // setContext has already been called and verified to return true
- // by the constructor of SkAutoBlitterChoose
- bool prevContextSuccess = true;
+ if (textures || colors) {
while (vertProc(&state)) {
- if (NULL != textures) {
+ if (textures) {
+ SkMatrix tempM;
if (texture_to_matrix(state, vertices, textures, &tempM)) {
- tempM.postConcat(savedLocalM);
- shader->setLocalMatrix(tempM);
- // Need to recall setContext since we changed the local matrix.
- // However, we also need to balance the calls this with a
- // call to endContext which requires tracking the result of
- // the previous call to setContext.
- if (prevContextSuccess) {
- shader->endContext();
- }
- prevContextSuccess = shader->setContext(*fBitmap, p, *fMatrix);
- if (!prevContextSuccess) {
+ SkShader::ContextRec rec(*fBitmap, p, *fMatrix);
+ rec.fLocalMatrix = &tempM;
+ if (!blitter->resetShaderContext(rec)) {
continue;
}
}
}
- if (NULL != colors) {
- if (!triShader.setup(vertices, colors,
- state.f0, state.f1, state.f2)) {
+ if (colors) {
+ // Find the context for triShader.
+ SkTriColorShader::TriColorShaderContext* triColorShaderContext;
+
+ SkShader::Context* shaderContext = blitter->getShaderContext();
+ SkASSERT(shaderContext);
+ if (p.getShader() == &triShader) {
+ triColorShaderContext =
+ static_cast<SkTriColorShader::TriColorShaderContext*>(shaderContext);
+ } else {
+ // The shader is a compose shader and triShader is its first shader.
+ SkASSERT(p.getShader() == composeShader);
+ SkASSERT(composeShader->getShaderA() == &triShader);
+ SkComposeShader::ComposeShaderContext* composeShaderContext =
+ static_cast<SkComposeShader::ComposeShaderContext*>(shaderContext);
+ SkShader::Context* shaderContextA = composeShaderContext->getShaderContextA();
+ triColorShaderContext =
+ static_cast<SkTriColorShader::TriColorShaderContext*>(shaderContextA);
+ }
+
+ if (!triColorShaderContext->setup(vertices, colors,
+ state.f0, state.f1, state.f2)) {
continue;
}
}
};
SkScan::FillTriangle(tmp, *fRC, blitter.get());
}
-
- // now restore the shader's original local matrix
- if (NULL != shader) {
- shader->setLocalMatrix(savedLocalM);
- }
-
- // If the final call to setContext fails we must make it suceed so that the
- // call to endContext in the destructor for SkAutoBlitterChoose is balanced.
- if (!prevContextSuccess) {
- prevContextSuccess = shader->setContext(*fBitmap, paint, SkMatrix::I());
- SkASSERT(prevContextSuccess);
- }
} else {
- // no colors[] and no texture
+ // no colors[] and no texture, stroke hairlines with paint's color.
HairProc hairProc = ChooseHairProc(paint.isAntiAlias());
const SkRasterClip& clip = *fRC;
while (vertProc(&state)) {
#endif
-///////////////////////////////////////////////////////////////////////////////
-
-SkBounder::SkBounder() {
- // initialize up front. This gets reset by SkCanvas before each draw call.
- fClip = &SkRegion::GetEmptyRegion();
-}
-
-bool SkBounder::doIRect(const SkIRect& r) {
- SkIRect rr;
- return rr.intersect(fClip->getBounds(), r) && this->onIRect(rr);
-}
-
-// TODO: change the prototype to take fixed, and update the callers
-bool SkBounder::doIRectGlyph(const SkIRect& r, int x, int y,
- const SkGlyph& glyph) {
- SkIRect rr;
- if (!rr.intersect(fClip->getBounds(), r)) {
- return false;
- }
- GlyphRec rec;
- rec.fLSB.set(SkIntToFixed(x), SkIntToFixed(y));
- rec.fRSB.set(rec.fLSB.fX + glyph.fAdvanceX,
- rec.fLSB.fY + glyph.fAdvanceY);
- rec.fGlyphID = glyph.getGlyphID();
- rec.fFlags = 0;
- return this->onIRectGlyph(rr, rec);
-}
-
-bool SkBounder::doHairline(const SkPoint& pt0, const SkPoint& pt1,
- const SkPaint& paint) {
- SkIRect r;
- SkScalar v0, v1;
-
- v0 = pt0.fX;
- v1 = pt1.fX;
- if (v0 > v1) {
- SkTSwap<SkScalar>(v0, v1);
- }
- r.fLeft = SkScalarFloor(v0);
- r.fRight = SkScalarCeil(v1);
-
- v0 = pt0.fY;
- v1 = pt1.fY;
- if (v0 > v1) {
- SkTSwap<SkScalar>(v0, v1);
- }
- r.fTop = SkScalarFloor(v0);
- r.fBottom = SkScalarCeil(v1);
-
- if (paint.isAntiAlias()) {
- r.inset(-1, -1);
- }
- return this->doIRect(r);
-}
-
-bool SkBounder::doRect(const SkRect& rect, const SkPaint& paint) {
- SkIRect r;
-
- if (paint.getStyle() == SkPaint::kFill_Style) {
- rect.round(&r);
- } else {
- int rad = -1;
- rect.roundOut(&r);
- if (paint.isAntiAlias()) {
- rad = -2;
- }
- r.inset(rad, rad);
- }
- return this->doIRect(r);
-}
-
-bool SkBounder::doPath(const SkPath& path, const SkPaint& paint, bool doFill) {
- SkIRect r;
- const SkRect& bounds = path.getBounds();
-
- if (doFill) {
- bounds.round(&r);
- } else { // hairline
- bounds.roundOut(&r);
- }
-
- if (paint.isAntiAlias()) {
- r.inset(-1, -1);
- }
- return this->doIRect(r);
-}
-
-void SkBounder::commit() {
- // override in subclass
-}
-
////////////////////////////////////////////////////////////////////////////////////////////////
#include "SkPath.h"
SkMatrix matrix;
SkPaint paint;
- bm.setConfig(SkBitmap::kA8_Config, mask.fBounds.width(), mask.fBounds.height(), mask.fRowBytes);
- bm.setPixels(mask.fImage);
+ bm.installPixels(SkImageInfo::MakeA8(mask.fBounds.width(), mask.fBounds.height()),
+ mask.fImage, mask.fRowBytes);
clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height()));
matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
draw.fRC = &clip;
draw.fClip = &clip.bwRgn();
draw.fMatrix = &matrix;
- draw.fBounder = NULL;
paint.setAntiAlias(true);
paint.setStyle(style);
draw.drawPath(devPath, paint);
projects / platform / framework / web / crosswalk.git / blobdiff