/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkDraw.h"
#include "SkBlitter.h"
#include "SkBounder.h"
#include "SkCanvas.h"
#include "SkColorPriv.h"
#include "SkDevice.h"
#include "SkFixed.h"
#include "SkMaskFilter.h"
#include "SkPaint.h"
#include "SkPathEffect.h"
#include "SkRasterClip.h"
#include "SkRasterizer.h"
#include "SkScan.h"
#include "SkShader.h"
#include "SkStroke.h"
#include "SkTemplatesPriv.h"
#include "SkTLazy.h"
#include "SkUtils.h"
#include "SkAutoKern.h"
#include "SkBitmapProcShader.h"
#include "SkDrawProcs.h"
//#define TRACE_BITMAP_DRAWS
#define kBlitterStorageLongCount (sizeof(SkBitmapProcShader) >> 2)
/** Helper for allocating small blitters on the stack.
*/
class SkAutoBlitterChoose : SkNoncopyable {
public:
SkAutoBlitterChoose() {
fBlitter = NULL;
}
SkAutoBlitterChoose(const SkBitmap& device, const SkMatrix& matrix,
const SkPaint& paint) {
fBlitter = SkBlitter::Choose(device, matrix, paint,
fStorage, sizeof(fStorage));
}
~SkAutoBlitterChoose();
SkBlitter* operator->() { return fBlitter; }
SkBlitter* get() const { return fBlitter; }
void choose(const SkBitmap& device, const SkMatrix& matrix,
const SkPaint& paint) {
SkASSERT(!fBlitter);
fBlitter = SkBlitter::Choose(device, matrix, paint,
fStorage, sizeof(fStorage));
}
private:
SkBlitter* fBlitter;
uint32_t fStorage[kBlitterStorageLongCount];
};
SkAutoBlitterChoose::~SkAutoBlitterChoose() {
if ((void*)fBlitter == (void*)fStorage) {
fBlitter->~SkBlitter();
} else {
SkDELETE(fBlitter);
}
}
/**
* Since we are providing the storage for the shader (to avoid the perf cost
* of calling new) we insist that in our destructor we can account for all
* owners of the shader.
*/
class SkAutoBitmapShaderInstall : SkNoncopyable {
public:
SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint)
: fPaint(paint) /* makes a copy of the paint */ {
fPaint.setShader(SkShader::CreateBitmapShader(src,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
fStorage, sizeof(fStorage)));
// 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());
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];
};
///////////////////////////////////////////////////////////////////////////////
SkDraw::SkDraw() {
sk_bzero(this, sizeof(*this));
}
SkDraw::SkDraw(const SkDraw& src) {
memcpy(this, &src, sizeof(*this));
}
///////////////////////////////////////////////////////////////////////////////
typedef void (*BitmapXferProc)(void* pixels, size_t bytes, uint32_t data);
static void D_Clear_BitmapXferProc(void* pixels, size_t bytes, uint32_t) {
sk_bzero(pixels, bytes);
}
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);
}
static void D16_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
sk_memset16((uint16_t*)pixels, data, bytes >> 1);
}
static void DA8_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
memset(pixels, data, bytes);
}
static BitmapXferProc ChooseBitmapXferProc(const SkBitmap& bitmap,
const SkPaint& paint,
uint32_t* data) {
// todo: we can apply colorfilter up front if no shader, so we wouldn't
// need to abort this fastpath
if (paint.getShader() || paint.getColorFilter()) {
return NULL;
}
SkXfermode::Mode mode;
if (!SkXfermode::AsMode(paint.getXfermode(), &mode)) {
return NULL;
}
SkColor color = paint.getColor();
// collaps modes based on color...
if (SkXfermode::kSrcOver_Mode == mode) {
unsigned alpha = SkColorGetA(color);
if (0 == alpha) {
mode = SkXfermode::kDst_Mode;
} else if (0xFF == alpha) {
mode = SkXfermode::kSrc_Mode;
}
}
switch (mode) {
case SkXfermode::kClear_Mode:
// SkDebugf("--- D_Clear_BitmapXferProc\n");
return D_Clear_BitmapXferProc; // ignore data
case SkXfermode::kDst_Mode:
// SkDebugf("--- D_Dst_BitmapXferProc\n");
return D_Dst_BitmapXferProc; // ignore data
case SkXfermode::kSrc_Mode: {
/*
should I worry about dithering for the lower depths?
*/
SkPMColor pmc = SkPreMultiplyColor(color);
switch (bitmap.config()) {
case SkBitmap::kARGB_8888_Config:
if (data) {
*data = pmc;
}
// SkDebugf("--- D32_Src_BitmapXferProc\n");
return D32_Src_BitmapXferProc;
case SkBitmap::kARGB_4444_Config:
if (data) {
*data = SkPixel32ToPixel4444(pmc);
}
// SkDebugf("--- D16_Src_BitmapXferProc\n");
return D16_Src_BitmapXferProc;
case SkBitmap::kRGB_565_Config:
if (data) {
*data = SkPixel32ToPixel16(pmc);
}
// SkDebugf("--- D16_Src_BitmapXferProc\n");
return D16_Src_BitmapXferProc;
case SkBitmap::kA8_Config:
if (data) {
*data = SkGetPackedA32(pmc);
}
// SkDebugf("--- DA8_Src_BitmapXferProc\n");
return DA8_Src_BitmapXferProc;
default:
break;
}
break;
}
default:
break;
}
return NULL;
}
static void CallBitmapXferProc(const SkBitmap& bitmap, const SkIRect& rect,
BitmapXferProc proc, uint32_t procData) {
int shiftPerPixel;
switch (bitmap.config()) {
case SkBitmap::kARGB_8888_Config:
shiftPerPixel = 2;
break;
case SkBitmap::kARGB_4444_Config:
case SkBitmap::kRGB_565_Config:
shiftPerPixel = 1;
break;
case SkBitmap::kA8_Config:
shiftPerPixel = 0;
break;
default:
SkDEBUGFAIL("Can't use xferproc on this config");
return;
}
uint8_t* pixels = (uint8_t*)bitmap.getPixels();
SkASSERT(pixels);
const size_t rowBytes = bitmap.rowBytes();
const int widthBytes = rect.width() << shiftPerPixel;
// skip down to the first scanline and X position
pixels += rect.fTop * rowBytes + (rect.fLeft << shiftPerPixel);
for (int scans = rect.height() - 1; scans >= 0; --scans) {
proc(pixels, widthBytes, procData);
pixels += rowBytes;
}
}
void SkDraw::drawPaint(const SkPaint& paint) const {
SkDEBUGCODE(this->validate();)
if (fRC->isEmpty()) {
return;
}
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
be faster to operate directly on the device bitmap, rather than invoking
a blitter. Esp. true for xfermodes, which require a colorshader to be
present, which is just redundant work. Since we're drawing everywhere
in the clip, we don't have to worry about antialiasing.
*/
uint32_t procData = 0; // to avoid the warning
BitmapXferProc proc = ChooseBitmapXferProc(*fBitmap, paint, &procData);
if (proc) {
if (D_Dst_BitmapXferProc == proc) { // nothing to do
return;
}
SkRegion::Iterator iter(fRC->bwRgn());
while (!iter.done()) {
CallBitmapXferProc(*fBitmap, iter.rect(), proc, procData);
iter.next();
}
return;
}
}
// normal case: use a blitter
SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
SkScan::FillIRect(devRect, *fRC, blitter.get());
}
///////////////////////////////////////////////////////////////////////////////
struct PtProcRec {
SkCanvas::PointMode fMode;
const SkPaint* fPaint;
const SkRegion* fClip;
const SkRasterClip* fRC;
// computed values
SkFixed fRadius;
typedef void (*Proc)(const PtProcRec&, const SkPoint devPts[], int count,
SkBlitter*);
bool init(SkCanvas::PointMode, const SkPaint&, const SkMatrix* matrix,
const SkRasterClip*);
Proc chooseProc(SkBlitter** blitter);
private:
SkAAClipBlitterWrapper fWrapper;
};
static void bw_pt_rect_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
SkASSERT(rec.fClip->isRect());
const SkIRect& r = rec.fClip->getBounds();
for (int i = 0; i < count; i++) {
int x = SkScalarFloor(devPts[i].fX);
int y = SkScalarFloor(devPts[i].fY);
if (r.contains(x, y)) {
blitter->blitH(x, y, 1);
}
}
}
static void bw_pt_rect_16_hair_proc(const PtProcRec& rec,
const SkPoint devPts[], int count,
SkBlitter* blitter) {
SkASSERT(rec.fRC->isRect());
const SkIRect& r = rec.fRC->getBounds();
uint32_t value;
const SkBitmap* bitmap = blitter->justAnOpaqueColor(&value);
SkASSERT(bitmap);
uint16_t* addr = bitmap->getAddr16(0, 0);
int rb = bitmap->rowBytes();
for (int i = 0; i < count; i++) {
int x = SkScalarFloor(devPts[i].fX);
int y = SkScalarFloor(devPts[i].fY);
if (r.contains(x, y)) {
// *bitmap->getAddr16(x, y) = SkToU16(value);
((uint16_t*)((char*)addr + y * rb))[x] = SkToU16(value);
}
}
}
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);
if (rec.fClip->contains(x, y)) {
blitter->blitH(x, y, 1);
}
}
}
static void bw_line_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
for (int i = 0; i < count; i += 2) {
SkScan::HairLine(devPts[i], devPts[i+1], *rec.fRC, blitter);
}
}
static void bw_poly_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
for (int i = 0; i < count - 1; i++) {
SkScan::HairLine(devPts[i], devPts[i+1], *rec.fRC, blitter);
}
}
// aa versions
static void aa_line_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
for (int i = 0; i < count; i += 2) {
SkScan::AntiHairLine(devPts[i], devPts[i+1], *rec.fRC, blitter);
}
}
static void aa_poly_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
for (int i = 0; i < count - 1; i++) {
SkScan::AntiHairLine(devPts[i], devPts[i+1], *rec.fRC, blitter);
}
}
// square procs (strokeWidth > 0 but matrix is square-scale (sx == sy)
static void bw_square_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
const SkFixed radius = rec.fRadius;
for (int i = 0; i < count; i++) {
SkFixed x = SkScalarToFixed(devPts[i].fX);
SkFixed y = SkScalarToFixed(devPts[i].fY);
SkXRect r;
r.fLeft = x - radius;
r.fTop = y - radius;
r.fRight = x + radius;
r.fBottom = y + radius;
SkScan::FillXRect(r, *rec.fRC, blitter);
}
}
static void aa_square_proc(const PtProcRec& rec, const SkPoint devPts[],
int count, SkBlitter* blitter) {
const SkFixed radius = rec.fRadius;
for (int i = 0; i < count; i++) {
SkFixed x = SkScalarToFixed(devPts[i].fX);
SkFixed y = SkScalarToFixed(devPts[i].fY);
SkXRect r;
r.fLeft = x - radius;
r.fTop = y - radius;
r.fRight = x + radius;
r.fBottom = y + radius;
SkScan::AntiFillXRect(r, *rec.fRC, blitter);
}
}
// If this guy returns true, then chooseProc() must return a valid proc
bool PtProcRec::init(SkCanvas::PointMode mode, const SkPaint& paint,
const SkMatrix* matrix, const SkRasterClip* rc) {
if (paint.getPathEffect()) {
return false;
}
SkScalar width = paint.getStrokeWidth();
if (0 == width) {
fMode = mode;
fPaint = &paint;
fClip = NULL;
fRC = rc;
fRadius = SK_Fixed1 >> 1;
return true;
}
if (paint.getStrokeCap() != SkPaint::kRound_Cap &&
matrix->rectStaysRect() && SkCanvas::kPoints_PointMode == mode) {
SkScalar sx = matrix->get(SkMatrix::kMScaleX);
SkScalar sy = matrix->get(SkMatrix::kMScaleY);
if (SkScalarNearlyZero(sx - sy)) {
if (sx < 0) {
sx = -sx;
}
fMode = mode;
fPaint = &paint;
fClip = NULL;
fRC = rc;
fRadius = SkScalarToFixed(SkScalarMul(width, sx)) >> 1;
return true;
}
}
return false;
}
PtProcRec::Proc PtProcRec::chooseProc(SkBlitter** blitterPtr) {
Proc proc = NULL;
SkBlitter* blitter = *blitterPtr;
if (fRC->isBW()) {
fClip = &fRC->bwRgn();
} else {
fWrapper.init(*fRC, blitter);
fClip = &fWrapper.getRgn();
blitter = fWrapper.getBlitter();
*blitterPtr = blitter;
}
// for our arrays
SkASSERT(0 == SkCanvas::kPoints_PointMode);
SkASSERT(1 == SkCanvas::kLines_PointMode);
SkASSERT(2 == SkCanvas::kPolygon_PointMode);
SkASSERT((unsigned)fMode <= (unsigned)SkCanvas::kPolygon_PointMode);
// first check for hairlines
if (0 == fPaint->getStrokeWidth()) {
if (fPaint->isAntiAlias()) {
static const Proc gAAProcs[] = {
aa_square_proc, aa_line_hair_proc, aa_poly_hair_proc
};
proc = gAAProcs[fMode];
} else {
if (SkCanvas::kPoints_PointMode == fMode && fClip->isRect()) {
uint32_t value;
const SkBitmap* bm = blitter->justAnOpaqueColor(&value);
if (bm && bm->config() == SkBitmap::kRGB_565_Config) {
proc = bw_pt_rect_16_hair_proc;
} else {
proc = bw_pt_rect_hair_proc;
}
} else {
static Proc gBWProcs[] = {
bw_pt_hair_proc, bw_line_hair_proc, bw_poly_hair_proc
};
proc = gBWProcs[fMode];
}
}
} else if (fPaint->getStrokeCap() != SkPaint::kRound_Cap) {
SkASSERT(SkCanvas::kPoints_PointMode == fMode);
if (fPaint->isAntiAlias()) {
proc = aa_square_proc;
} else {
proc = bw_square_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
void SkDraw::drawPoints(SkCanvas::PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint,
bool forceUseDevice) const {
// if we're in lines mode, force count to be even
if (SkCanvas::kLines_PointMode == mode) {
count &= ~(size_t)1;
}
if ((long)count <= 0) {
return;
}
SkASSERT(pts != NULL);
SkDEBUGCODE(this->validate();)
// nothing to draw
if (fRC->isEmpty()) {
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);
SkPoint devPts[MAX_DEV_PTS];
const SkMatrix* matrix = fMatrix;
SkBlitter* bltr = blitter.get();
PtProcRec::Proc proc = rec.chooseProc(&bltr);
// we have to back up subsequent passes if we're in polygon mode
const size_t backup = (SkCanvas::kPolygon_PointMode == mode);
do {
size_t n = 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);
count -= n;
if (count > 0) {
count += backup;
}
} while (count != 0);
} else {
switch (mode) {
case SkCanvas::kPoints_PointMode: {
// temporarily mark the paint as filling.
SkPaint newPaint(paint);
newPaint.setStyle(SkPaint::kFill_Style);
SkScalar width = newPaint.getStrokeWidth();
SkScalar radius = SkScalarHalf(width);
if (newPaint.getStrokeCap() == SkPaint::kRound_Cap) {
SkPath path;
SkMatrix preMatrix;
path.addCircle(0, 0, radius);
for (size_t i = 0; i < count; i++) {
preMatrix.setTranslate(pts[i].fX, pts[i].fY);
// pass true for the last point, since we can modify
// then path then
if (fDevice) {
fDevice->drawPath(*this, path, newPaint, &preMatrix,
(count-1) == i);
} else {
this->drawPath(path, newPaint, &preMatrix,
(count-1) == i);
}
}
} else {
SkRect r;
for (size_t i = 0; i < count; i++) {
r.fLeft = pts[i].fX - radius;
r.fTop = pts[i].fY - radius;
r.fRight = r.fLeft + width;
r.fBottom = r.fTop + width;
if (fDevice) {
fDevice->drawRect(*this, r, newPaint);
} else {
this->drawRect(r, newPaint);
}
}
}
break;
}
case SkCanvas::kLines_PointMode:
case SkCanvas::kPolygon_PointMode: {
count -= 1;
SkPath path;
SkPaint p(paint);
p.setStyle(SkPaint::kStroke_Style);
size_t inc = (SkCanvas::kLines_PointMode == mode) ? 2 : 1;
for (size_t i = 0; i < count; i += inc) {
path.moveTo(pts[i]);
path.lineTo(pts[i+1]);
if (fDevice) {
fDevice->drawPath(*this, path, p, NULL, true);
} else {
this->drawPath(path, p, NULL, true);
}
path.rewind();
}
break;
}
}
}
}
static inline SkPoint* as_lefttop(SkRect* r) {
return (SkPoint*)(void*)r;
}
static inline SkPoint* as_rightbottom(SkRect* r) {
return ((SkPoint*)(void*)r) + 1;
}
static bool easy_rect_join(const SkPaint& paint, const SkMatrix& matrix,
SkPoint* strokeSize) {
if (SkPaint::kMiter_Join != paint.getStrokeJoin() ||
paint.getStrokeMiter() < SK_ScalarSqrt2) {
return false;
}
SkASSERT(matrix.rectStaysRect());
SkPoint pt = { paint.getStrokeWidth(), paint.getStrokeWidth() };
matrix.mapVectors(strokeSize, &pt, 1);
strokeSize->fX = SkScalarAbs(strokeSize->fX);
strokeSize->fY = SkScalarAbs(strokeSize->fY);
return true;
}
SkDraw::RectType SkDraw::ComputeRectType(const SkPaint& paint,
const SkMatrix& matrix,
SkPoint* strokeSize) {
RectType rtype;
const SkScalar width = paint.getStrokeWidth();
const bool zeroWidth = (0 == width);
SkPaint::Style style = paint.getStyle();
if ((SkPaint::kStrokeAndFill_Style == style) && zeroWidth) {
style = SkPaint::kFill_Style;
}
if (paint.getPathEffect() || paint.getMaskFilter() ||
paint.getRasterizer() || !matrix.rectStaysRect() ||
SkPaint::kStrokeAndFill_Style == style) {
rtype = kPath_RectType;
} else if (SkPaint::kFill_Style == style) {
rtype = kFill_RectType;
} else if (zeroWidth) {
rtype = kHair_RectType;
} else if (easy_rect_join(paint, matrix, strokeSize)) {
rtype = kStroke_RectType;
} else {
rtype = kPath_RectType;
}
return rtype;
}
static SkPoint* rect_points(SkRect& r, int index) {
SkASSERT((unsigned)index < 2);
return &((SkPoint*)(void*)&r)[index];
}
void SkDraw::drawRect(const SkRect& rect, const SkPaint& paint) const {
SkDEBUGCODE(this->validate();)
// nothing to draw
if (fRC->isEmpty()) {
return;
}
SkPoint strokeSize;
RectType rtype = ComputeRectType(paint, *fMatrix, &strokeSize);
#ifdef SK_DISABLE_FAST_AA_STROKE_RECT
if (kStroke_RectType == rtype && paint.isAntiAlias()) {
rtype = kPath_RectType;
}
#endif
if (kPath_RectType == rtype) {
SkPath tmp;
tmp.addRect(rect);
tmp.setFillType(SkPath::kWinding_FillType);
this->drawPath(tmp, paint, NULL, true);
return;
}
const SkMatrix& matrix = *fMatrix;
SkRect devRect;
// transform rect into devRect
{
matrix.mapXY(rect.fLeft, rect.fTop, rect_points(devRect, 0));
matrix.mapXY(rect.fRight, rect.fBottom, rect_points(devRect, 1));
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 (fRC->quickReject(ir))
return;
}
SkAutoBlitterChoose blitterStorage(*fBitmap, matrix, paint);
const SkRasterClip& clip = *fRC;
SkBlitter* blitter = blitterStorage.get();
// we want to "fill" if we are kFill or kStrokeAndFill, since in the latter
// case we are also hairline (if we've gotten to here), which devolves to
// effectively just kFill
switch (rtype) {
case kFill_RectType:
if (paint.isAntiAlias()) {
SkScan::AntiFillRect(devRect, clip, blitter);
} else {
SkScan::FillRect(devRect, clip, blitter);
}
break;
case kStroke_RectType:
if (paint.isAntiAlias()) {
SkScan::AntiFrameRect(devRect, strokeSize, clip, blitter);
} else {
SkScan::FrameRect(devRect, strokeSize, clip, blitter);
}
break;
case kHair_RectType:
if (paint.isAntiAlias()) {
SkScan::AntiHairRect(devRect, clip, blitter);
} else {
SkScan::HairRect(devRect, clip, blitter);
}
break;
default:
SkDEBUGFAIL("bad rtype");
}
}
void SkDraw::drawDevMask(const SkMask& srcM, const SkPaint& paint) const {
if (srcM.fBounds.isEmpty()) {
return;
}
const SkMask* mask = &srcM;
SkMask dstM;
if (paint.getMaskFilter() &&
paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, NULL)) {
mask = &dstM;
} else {
dstM.fImage = NULL;
}
SkAutoMaskFreeImage ami(dstM.fImage);
if (fBounder && !fBounder->doIRect(mask->fBounds)) {
return;
}
SkAutoBlitterChoose blitterChooser(*fBitmap, *fMatrix, paint);
SkBlitter* blitter = blitterChooser.get();
SkAAClipBlitterWrapper wrapper;
const SkRegion* clipRgn;
if (fRC->isBW()) {
clipRgn = &fRC->bwRgn();
} else {
wrapper.init(*fRC, blitter);
clipRgn = &wrapper.getRgn();
blitter = wrapper.getBlitter();
}
blitter->blitMaskRegion(*mask, *clipRgn);
}
static SkScalar fast_len(const SkVector& vec) {
SkScalar x = SkScalarAbs(vec.fX);
SkScalar y = SkScalarAbs(vec.fY);
if (x < y) {
SkTSwap(x, y);
}
return x + SkScalarHalf(y);
}
static bool xfermodeSupportsCoverageAsAlpha(SkXfermode* xfer) {
SkXfermode::Coeff dc;
if (!SkXfermode::AsCoeff(xfer, NULL, &dc)) {
return false;
}
switch (dc) {
case SkXfermode::kOne_Coeff:
case SkXfermode::kISA_Coeff:
case SkXfermode::kISC_Coeff:
return true;
default:
return false;
}
}
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
if (!paint.isAntiAlias()) {
return false;
}
if (matrix.hasPerspective()) {
return false;
}
SkVector src[2], dst[2];
src[0].set(strokeWidth, 0);
src[1].set(0, strokeWidth);
matrix.mapVectors(dst, src, 2);
SkScalar len0 = fast_len(dst[0]);
SkScalar len1 = fast_len(dst[1]);
if (len0 <= SK_Scalar1 && len1 <= SK_Scalar1) {
*coverage = SkScalarAve(len0, len1);
return true;
}
return false;
}
void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint,
const SkMatrix* prePathMatrix, bool pathIsMutable) const {
SkDEBUGCODE(this->validate();)
// nothing to draw
if (fRC->isEmpty()) {
return;
}
SkPath* pathPtr = (SkPath*)&origSrcPath;
bool doFill = true;
SkPath tmpPath;
SkMatrix tmpMatrix;
const SkMatrix* matrix = fMatrix;
if (prePathMatrix) {
if (origPaint.getPathEffect() || origPaint.getStyle() != SkPaint::kFill_Style ||
origPaint.getRasterizer()) {
SkPath* result = pathPtr;
if (!pathIsMutable) {
result = &tmpPath;
pathIsMutable = true;
}
pathPtr->transform(*prePathMatrix, result);
pathPtr = result;
} else {
if (!tmpMatrix.setConcat(*matrix, *prePathMatrix)) {
// overflow
return;
}
matrix = &tmpMatrix;
}
}
// at this point we're done with prePathMatrix
SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
const SkPaint* paint = &origPaint;
SkTLazy<SkPaint> lazyPaint;
{
SkScalar coverage;
if (SkDrawTreatAsHairline(origPaint, *matrix, &coverage)) {
if (SK_Scalar1 == coverage) {
lazyPaint.set(origPaint);
lazyPaint.get()->setStrokeWidth(0);
paint = lazyPaint.get();
} else if (xfermodeSupportsCoverageAsAlpha(origPaint.getXfermode())) {
U8CPU newAlpha;
#if 0
newAlpha = SkToU8(SkScalarRoundToInt(coverage *
origPaint.getAlpha()));
#else
// this is the old technique, which we preserve for now so
// we don't change previous results (testing)
// the new way seems fine, its just (a tiny bit) different
int scale = (int)SkScalarMul(coverage, 256);
newAlpha = origPaint.getAlpha() * scale >> 8;
#endif
lazyPaint.set(origPaint);
lazyPaint.get()->setStrokeWidth(0);
lazyPaint.get()->setAlpha(newAlpha);
paint = lazyPaint.get();
}
}
}
if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style) {
doFill = paint->getFillPath(*pathPtr, &tmpPath);
pathPtr = &tmpPath;
}
if (paint->getRasterizer()) {
SkMask mask;
if (paint->getRasterizer()->rasterize(*pathPtr, *matrix,
&fRC->getBounds(), paint->getMaskFilter(), &mask,
SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
this->drawDevMask(mask, *paint);
SkMask::FreeImage(mask.fImage);
}
return;
}
// avoid possibly allocating a new path in transform if we can
SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;
// transform the path into device space
pathPtr->transform(*matrix, devPathPtr);
SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, *paint);
// how does filterPath() know to fill or hairline the path??? <mrr>
if (paint->getMaskFilter() &&
paint->getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fRC,
fBounder, blitter.get())) {
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::AntiFillPath;
} else {
proc = SkScan::FillPath;
}
} else { // hairline
if (paint->isAntiAlias()) {
proc = SkScan::AntiHairPath;
} else {
proc = SkScan::HairPath;
}
}
proc(*devPathPtr, *fRC, blitter.get());
}
/** For the purposes of drawing bitmaps, if a matrix is "almost" translate
go ahead and treat it as if it were, so that subsequent code can go fast.
*/
static bool just_translate(const SkMatrix& matrix, const SkBitmap& bitmap) {
SkMatrix::TypeMask mask = matrix.getType();
if (mask & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
return false;
}
if (mask & SkMatrix::kScale_Mask) {
SkScalar sx = matrix[SkMatrix::kMScaleX];
SkScalar sy = matrix[SkMatrix::kMScaleY];
int w = bitmap.width();
int h = bitmap.height();
int sw = SkScalarRound(SkScalarMul(sx, SkIntToScalar(w)));
int sh = SkScalarRound(SkScalarMul(sy, SkIntToScalar(h)));
return sw == w && sh == h;
}
// if we got here, we're either kTranslate_Mask or identity
return true;
}
void SkDraw::drawBitmapAsMask(const SkBitmap& bitmap,
const SkPaint& paint) const {
SkASSERT(bitmap.getConfig() == SkBitmap::kA8_Config);
if (just_translate(*fMatrix, bitmap)) {
int ix = SkScalarRound(fMatrix->getTranslateX());
int iy = SkScalarRound(fMatrix->getTranslateY());
SkMask mask;
mask.fBounds.set(ix, iy, ix + bitmap.width(), iy + bitmap.height());
mask.fFormat = SkMask::kA8_Format;
mask.fRowBytes = bitmap.rowBytes();
mask.fImage = bitmap.getAddr8(0, 0);
this->drawDevMask(mask, paint);
} else { // need to xform the bitmap first
SkRect r;
SkMask mask;
r.set(0, 0,
SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
fMatrix->mapRect(&r);
r.round(&mask.fBounds);
// set the mask's bounds to the transformed bitmap-bounds,
// clipped to the actual device
{
SkIRect devBounds;
devBounds.set(0, 0, fBitmap->width(), fBitmap->height());
// need intersect(l, t, r, b) on irect
if (!mask.fBounds.intersect(devBounds)) {
return;
}
}
mask.fFormat = SkMask::kA8_Format;
mask.fRowBytes = SkAlign4(mask.fBounds.width());
size_t size = mask.computeImageSize();
if (0 == size) {
// the mask is too big to allocated, draw nothing
return;
}
// allocate (and clear) our temp buffer to hold the transformed bitmap
SkAutoMalloc storage(size);
mask.fImage = (uint8_t*)storage.get();
memset(mask.fImage, 0, size);
// 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);
SkCanvas c(device);
// need the unclipped top/left for the translate
c.translate(-SkIntToScalar(mask.fBounds.fLeft),
-SkIntToScalar(mask.fBounds.fTop));
c.concat(*fMatrix);
// We can't call drawBitmap, or we'll infinitely recurse. Instead
// we manually build a shader and draw that into our new mask
SkPaint tmpPaint;
tmpPaint.setFlags(paint.getFlags());
SkAutoBitmapShaderInstall install(bitmap, tmpPaint);
SkRect rr;
rr.set(0, 0, SkIntToScalar(bitmap.width()),
SkIntToScalar(bitmap.height()));
c.drawRect(rr, install.paintWithShader());
}
this->drawDevMask(mask, paint);
}
}
static bool clipped_out(const SkMatrix& m, const SkRasterClip& c,
const SkRect& srcR) {
SkRect dstR;
SkIRect devIR;
m.mapRect(&dstR, srcR);
dstR.roundOut(&devIR);
return c.quickReject(devIR);
}
static bool clipped_out(const SkMatrix& matrix, const SkRasterClip& clip,
int width, int height) {
SkRect r;
r.set(0, 0, SkIntToScalar(width), SkIntToScalar(height));
return clipped_out(matrix, clip, r);
}
static bool clipHandlesSprite(const SkRasterClip& clip, int x, int y,
const SkBitmap& bitmap) {
return clip.isBW() ||
clip.quickContains(x, y, x + bitmap.width(), y + bitmap.height());
}
void SkDraw::drawBitmap(const SkBitmap& bitmap, const SkMatrix& prematrix,
const SkPaint& origPaint) const {
SkDEBUGCODE(this->validate();)
// nothing to draw
if (fRC->isEmpty() ||
bitmap.width() == 0 || bitmap.height() == 0 ||
bitmap.getConfig() == SkBitmap::kNo_Config) {
return;
}
#ifndef SK_ALLOW_OVER_32K_BITMAPS
// run away on too-big bitmaps for now (exceed 16.16)
if (bitmap.width() > 32767 || bitmap.height() > 32767) {
return;
}
#endif
SkPaint paint(origPaint);
paint.setStyle(SkPaint::kFill_Style);
SkMatrix matrix;
if (!matrix.setConcat(*fMatrix, prematrix)) {
return;
}
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;
}
}
// only lock the pixels if we passed the clip and bounder tests
SkAutoLockPixels alp(bitmap);
// after the lock, check if we are valid
if (!bitmap.readyToDraw()) {
return;
}
if (bitmap.getConfig() != SkBitmap::kA8_Config &&
just_translate(matrix, bitmap)) {
int ix = SkScalarRound(matrix.getTranslateX());
int iy = SkScalarRound(matrix.getTranslateY());
if (clipHandlesSprite(*fRC, ix, iy, bitmap)) {
uint32_t storage[kBlitterStorageLongCount];
SkBlitter* blitter = SkBlitter::ChooseSprite(*fBitmap, paint, bitmap,
ix, iy, storage, sizeof(storage));
if (blitter) {
SkAutoTPlacementDelete<SkBlitter> ad(blitter, storage);
SkIRect ir;
ir.set(ix, iy, ix + bitmap.width(), iy + bitmap.height());
SkScan::FillIRect(ir, *fRC, blitter);
return;
}
}
}
// now make a temp draw on the stack, and use it
//
SkDraw draw(*this);
draw.fMatrix = &matrix;
if (bitmap.getConfig() == SkBitmap::kA8_Config) {
draw.drawBitmapAsMask(bitmap, paint);
} else {
SkAutoBitmapShaderInstall install(bitmap, paint);
SkRect r;
r.set(0, 0, SkIntToScalar(bitmap.width()),
SkIntToScalar(bitmap.height()));
// is this ok if paint has a rasterizer?
draw.drawRect(r, install.paintWithShader());
}
}
void SkDraw::drawSprite(const SkBitmap& bitmap, int x, int y,
const SkPaint& origPaint) const {
SkDEBUGCODE(this->validate();)
// nothing to draw
if (fRC->isEmpty() ||
bitmap.width() == 0 || bitmap.height() == 0 ||
bitmap.getConfig() == SkBitmap::kNo_Config) {
return;
}
SkIRect bounds;
bounds.set(x, y, x + bitmap.width(), y + bitmap.height());
if (fRC->quickReject(bounds)) {
return; // nothing to draw
}
SkPaint paint(origPaint);
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));
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
matrix.setTranslate(r.fLeft, r.fTop);
shaderPaint.getShader()->setLocalMatrix(matrix);
SkDraw draw(*this);
matrix.reset();
draw.fMatrix = &matrix;
// call ourself with a rect
// is this OK if paint has a rasterizer?
draw.drawRect(r, shaderPaint);
}
///////////////////////////////////////////////////////////////////////////////
#include "SkScalerContext.h"
#include "SkGlyphCache.h"
#include "SkUtils.h"
static void measure_text(SkGlyphCache* cache, SkDrawCacheProc glyphCacheProc,
const char text[], size_t byteLength, SkVector* stopVector) {
SkFixed x = 0, y = 0;
const char* stop = text + byteLength;
SkAutoKern autokern;
while (text < stop) {
// don't need x, y here, since all subpixel variants will have the
// same advance
const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
x += autokern.adjust(glyph) + glyph.fAdvanceX;
y += glyph.fAdvanceY;
}
stopVector->set(SkFixedToScalar(x), SkFixedToScalar(y));
SkASSERT(text == stop);
}
void SkDraw::drawText_asPaths(const char text[], size_t byteLength,
SkScalar x, SkScalar y,
const SkPaint& paint) const {
SkDEBUGCODE(this->validate();)
SkTextToPathIter iter(text, byteLength, paint, true, true);
SkMatrix matrix;
matrix.setScale(iter.getPathScale(), iter.getPathScale());
matrix.postTranslate(x, y);
const SkPath* iterPath;
SkScalar xpos, prevXPos = 0;
while ((iterPath = iter.next(&xpos)) != NULL) {
matrix.postTranslate(xpos - prevXPos, 0);
const SkPaint& pnt = iter.getPaint();
if (fDevice) {
fDevice->drawPath(*this, *iterPath, pnt, &matrix, false);
} else {
this->drawPath(*iterPath, pnt, &matrix, false);
}
prevXPos = xpos;
}
}
// disable warning : local variable used without having been initialized
#if defined _WIN32 && _MSC_VER >= 1300
#pragma warning ( push )
#pragma warning ( disable : 4701 )
#endif
//////////////////////////////////////////////////////////////////////////////
static void D1G_NoBounder_RectClip(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);
SkASSERT(NULL == state.fBounder);
SkASSERT((NULL == state.fClip && state.fAAClip) ||
(state.fClip && NULL == state.fAAClip && state.fClip->isRect()));
left += glyph.fLeft;
top += glyph.fTop;
int right = left + glyph.fWidth;
int bottom = top + glyph.fHeight;
SkMask mask;
SkIRect storage;
SkIRect* bounds = &mask.fBounds;
mask.fBounds.set(left, top, right, bottom);
// this extra test is worth it, assuming that most of the time it succeeds
// since we can avoid writing to storage
if (!state.fClipBounds.containsNoEmptyCheck(left, top, right, bottom)) {
if (!storage.intersectNoEmptyCheck(mask.fBounds, state.fClipBounds))
return;
bounds = &storage;
}
uint8_t* aa = (uint8_t*)glyph.fImage;
if (NULL == aa) {
aa = (uint8_t*)state.fCache->findImage(glyph);
if (NULL == aa) {
return; // can't rasterize glyph
}
}
mask.fRowBytes = glyph.rowBytes();
mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
mask.fImage = aa;
state.fBlitter->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);
SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
SkASSERT(!state.fClip->isRect());
SkASSERT(NULL == state.fBounder);
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;
}
}
mask.fRowBytes = glyph.rowBytes();
mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
mask.fImage = (uint8_t*)aa;
do {
state.fBlitter->blitMask(mask, cr);
clipper.next();
} while (!clipper.done());
}
}
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.fBlitter->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;
}
static bool needsRasterTextBlit(const SkDraw& draw) {
return !hasCustomD1GProc(draw);
}
SkDraw1Glyph::Proc SkDraw1Glyph::init(const SkDraw* draw, SkBlitter* blitter,
SkGlyphCache* cache) {
fDraw = draw;
fBounder = draw->fBounder;
fBlitter = blitter;
fCache = cache;
if (hasCustomD1GProc(*draw)) {
// todo: fix this assumption about clips w/ custom
fClip = draw->fClip;
fClipBounds = fClip->getBounds();
return draw->fProcs->fD1GProc;
}
if (draw->fRC->isBW()) {
fAAClip = NULL;
fClip = &draw->fRC->bwRgn();
fClipBounds = fClip->getBounds();
if (NULL == fBounder) {
if (fClip->isRect()) {
return D1G_NoBounder_RectClip;
} else {
return D1G_NoBounder_RgnClip;
}
} else {
return D1G_Bounder;
}
} else { // aaclip
fAAClip = &draw->fRC->aaRgn();
fClip = NULL;
fClipBounds = fAAClip->getBounds();
if (NULL == fBounder) {
return D1G_NoBounder_RectClip;
} else {
return D1G_Bounder_AAClip;
}
}
}
///////////////////////////////////////////////////////////////////////////////
void SkDraw::drawText(const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkPaint& paint) const {
SkASSERT(byteLength == 0 || text != NULL);
SkDEBUGCODE(this->validate();)
// nothing to draw
if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
return;
}
if (/*paint.isLinearText() ||*/
(fMatrix->hasPerspective())) {
this->drawText_asPaths(text, byteLength, x, y, paint);
return;
}
SkDrawCacheProc glyphCacheProc = paint.getDrawCacheProc();
const SkMatrix* matrix = fMatrix;
if (hasCustomD1GProc(*this)) {
// only support the fMVMatrix (for now) for the GPU case, which also
// sets the fD1GProc
if (fMVMatrix) {
matrix = fMVMatrix;
}
}
SkAutoGlyphCache autoCache(paint, matrix);
SkGlyphCache* cache = autoCache.getCache();
// transform our starting point
{
SkPoint loc;
matrix->mapXY(x, y, &loc);
x = loc.fX;
y = loc.fY;
}
// need to measure first
if (paint.getTextAlign() != SkPaint::kLeft_Align) {
SkVector stop;
measure_text(cache, glyphCacheProc, text, byteLength, &stop);
SkScalar stopX = stop.fX;
SkScalar stopY = stop.fY;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
stopX = SkScalarHalf(stopX);
stopY = SkScalarHalf(stopY);
}
x -= stopX;
y -= stopY;
}
SkFixed fx = SkScalarToFixed(x);
SkFixed fy = SkScalarToFixed(y);
const char* stop = text + byteLength;
SkFixed fxMask = ~0;
SkFixed fyMask = ~0;
if (cache->isSubpixel()) {
SkAxisAlignment baseline = SkComputeAxisAlignmentForHText(*matrix);
if (kX_SkAxisAlignment == baseline) {
fyMask = 0;
} else if (kY_SkAxisAlignment == baseline) {
fxMask = 0;
}
// apply bias here to avoid adding 1/2 the sampling frequency in the loop
fx += SK_FixedHalf >> SkGlyph::kSubBits;
fy += SK_FixedHalf >> SkGlyph::kSubBits;
} else {
fx += SK_FixedHalf;
fy += SK_FixedHalf;
}
SkAAClipBlitter aaBlitter;
SkAutoBlitterChoose blitterChooser;
SkBlitter* blitter = NULL;
if (needsRasterTextBlit(*this)) {
blitterChooser.choose(*fBitmap, *matrix, paint);
blitter = blitterChooser.get();
if (fRC->isAA()) {
aaBlitter.init(blitter, &fRC->aaRgn());
blitter = &aaBlitter;
}
}
SkAutoKern autokern;
SkDraw1Glyph d1g;
SkDraw1Glyph::Proc proc = d1g.init(this, blitter, cache);
while (text < stop) {
const SkGlyph& glyph = glyphCacheProc(cache, &text, fx & fxMask, fy & fyMask);
fx += autokern.adjust(glyph);
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(const char text[], size_t byteLength,
const SkScalar pos[], SkScalar constY,
int scalarsPerPosition, const SkPaint& paint) const {
SkASSERT(byteLength == 0 || text != NULL);
SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
SkDEBUGCODE(this->validate();)
// nothing to draw
if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
return;
}
if (/*paint.isLinearText() ||*/
(fMatrix->hasPerspective())) {
// TODO !!!!
// this->drawText_asPaths(text, byteLength, x, y, paint);
return;
}
const SkMatrix* matrix = fMatrix;
if (hasCustomD1GProc(*this)) {
// only support the fMVMatrix (for now) for the GPU case, which also
// sets the fD1GProc
if (fMVMatrix) {
matrix = fMVMatrix;
}
}
SkDrawCacheProc glyphCacheProc = paint.getDrawCacheProc();
SkAutoGlyphCache autoCache(paint, matrix);
SkGlyphCache* cache = autoCache.getCache();
SkAAClipBlitterWrapper wrapper;
SkAutoBlitterChoose blitterChooser;
SkBlitter* blitter = NULL;
if (needsRasterTextBlit(*this)) {
blitterChooser.choose(*fBitmap, *matrix, paint);
blitter = blitterChooser.get();
if (fRC->isAA()) {
wrapper.init(*fRC, blitter);
blitter = wrapper.getBlitter();
}
}
const char* stop = text + byteLength;
AlignProc alignProc = pick_align_proc(paint.getTextAlign());
SkDraw1Glyph d1g;
SkDraw1Glyph::Proc proc = d1g.init(this, blitter, cache);
TextMapState tms(*matrix, constY);
TextMapState::Proc tmsProc = tms.pickProc(scalarsPerPosition);
if (cache->isSubpixel()) {
// maybe we should skip the rounding if linearText is set
SkAxisAlignment roundBaseline = SkComputeAxisAlignmentForHText(*matrix);
if (SkPaint::kLeft_Align == paint.getTextAlign()) {
while (text < stop) {
tmsProc(tms, pos);
#ifdef SK_DRAW_POS_TEXT_IGNORE_SUBPIXEL_LEFT_ALIGN_FIX
SkFixed fx = SkScalarToFixed(tms.fLoc.fX);
SkFixed fy = SkScalarToFixed(tms.fLoc.fY);
#else
SkFixed fx = SkScalarToFixed(tms.fLoc.fX) + (SK_FixedHalf >> SkGlyph::kSubBits);
SkFixed fy = SkScalarToFixed(tms.fLoc.fY) + (SK_FixedHalf >> SkGlyph::kSubBits);
#endif
SkFixed fxMask = ~0;
SkFixed fyMask = ~0;
if (kX_SkAxisAlignment == roundBaseline) {
fyMask = 0;
} else if (kY_SkAxisAlignment == roundBaseline) {
fxMask = 0;
}
const SkGlyph& glyph = glyphCacheProc(cache, &text,
fx & fxMask, fy & fyMask);
if (glyph.fWidth) {
proc(d1g, fx, fy, glyph);
}
pos += scalarsPerPosition;
}
} else {
while (text < stop) {
const char* currentText = text;
const SkGlyph* glyph = &glyphCacheProc(cache, &text, 0, 0);
if (glyph->fWidth) {
SkDEBUGCODE(SkFixed prevAdvX = glyph->fAdvanceX;)
SkDEBUGCODE(SkFixed prevAdvY = glyph->fAdvanceY;)
SkFixed fx, fy;
SkFixed fxMask = ~0;
SkFixed fyMask = ~0;
tmsProc(tms, pos);
{
SkIPoint fixedLoc;
alignProc(tms.fLoc, *glyph, &fixedLoc);
fx = fixedLoc.fX + (SK_FixedHalf >> SkGlyph::kSubBits);
fy = fixedLoc.fY + (SK_FixedHalf >> SkGlyph::kSubBits);
if (kX_SkAxisAlignment == roundBaseline) {
fyMask = 0;
} else if (kY_SkAxisAlignment == roundBaseline) {
fxMask = 0;
}
}
// have to call again, now that we've been "aligned"
glyph = &glyphCacheProc(cache, ¤tText,
fx & fxMask, fy & fyMask);
// the assumption is that the advance hasn't changed
SkASSERT(prevAdvX == glyph->fAdvanceX);
SkASSERT(prevAdvY == glyph->fAdvanceY);
proc(d1g, fx, fy, *glyph);
}
pos += scalarsPerPosition;
}
}
} else { // not subpixel
while (text < stop) {
// the last 2 parameters are ignored
const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
if (glyph.fWidth) {
tmsProc(tms, pos);
SkIPoint fixedLoc;
alignProc(tms.fLoc, glyph, &fixedLoc);
proc(d1g,
fixedLoc.fX + SK_FixedHalf,
fixedLoc.fY + SK_FixedHalf,
glyph);
}
pos += scalarsPerPosition;
}
}
}
#if defined _WIN32 && _MSC_VER >= 1300
#pragma warning ( pop )
#endif
///////////////////////////////////////////////////////////////////////////////
#include "SkPathMeasure.h"
static void morphpoints(SkPoint dst[], const SkPoint src[], int count,
SkPathMeasure& meas, const SkMatrix& matrix) {
SkMatrix::MapXYProc proc = matrix.getMapXYProc();
for (int i = 0; i < count; i++) {
SkPoint pos;
SkVector tangent;
proc(matrix, src[i].fX, src[i].fY, &pos);
SkScalar sx = pos.fX;
SkScalar sy = pos.fY;
meas.getPosTan(sx, &pos, &tangent);
/* This is the old way (that explains our approach but is way too slow
SkMatrix matrix;
SkPoint pt;
pt.set(sx, sy);
matrix.setSinCos(tangent.fY, tangent.fX);
matrix.preTranslate(-sx, 0);
matrix.postTranslate(pos.fX, pos.fY);
matrix.mapPoints(&dst[i], &pt, 1);
*/
dst[i].set(pos.fX - SkScalarMul(tangent.fY, sy),
pos.fY + SkScalarMul(tangent.fX, sy));
}
}
/* TODO
Need differentially more subdivisions when the follow-path is curvy. Not sure how to
determine that, but we need it. I guess a cheap answer is let the caller tell us,
but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out.
*/
static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas,
const SkMatrix& matrix) {
SkPath::Iter iter(src, false);
SkPoint srcP[4], dstP[3];
SkPath::Verb verb;
while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kMove_Verb:
morphpoints(dstP, srcP, 1, meas, matrix);
dst->moveTo(dstP[0]);
break;
case SkPath::kLine_Verb:
// turn lines into quads to look bendy
srcP[0].fX = SkScalarAve(srcP[0].fX, srcP[1].fX);
srcP[0].fY = SkScalarAve(srcP[0].fY, srcP[1].fY);
morphpoints(dstP, srcP, 2, meas, matrix);
dst->quadTo(dstP[0], dstP[1]);
break;
case SkPath::kQuad_Verb:
morphpoints(dstP, &srcP[1], 2, meas, matrix);
dst->quadTo(dstP[0], dstP[1]);
break;
case SkPath::kCubic_Verb:
morphpoints(dstP, &srcP[1], 3, meas, matrix);
dst->cubicTo(dstP[0], dstP[1], dstP[2]);
break;
case SkPath::kClose_Verb:
dst->close();
break;
default:
SkDEBUGFAIL("unknown verb");
break;
}
}
}
void SkDraw::drawTextOnPath(const char text[], size_t byteLength,
const SkPath& follow, const SkMatrix* matrix,
const SkPaint& paint) const {
SkASSERT(byteLength == 0 || text != NULL);
// nothing to draw
if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
return;
}
SkTextToPathIter iter(text, byteLength, paint, true, true);
SkPathMeasure meas(follow, false);
SkScalar hOffset = 0;
// need to measure first
if (paint.getTextAlign() != SkPaint::kLeft_Align) {
SkScalar pathLen = meas.getLength();
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
pathLen = SkScalarHalf(pathLen);
}
hOffset += pathLen;
}
const SkPath* iterPath;
SkScalar xpos;
SkMatrix scaledMatrix;
SkScalar scale = iter.getPathScale();
scaledMatrix.setScale(scale, scale);
while ((iterPath = iter.next(&xpos)) != NULL) {
SkPath tmp;
SkMatrix m(scaledMatrix);
m.postTranslate(xpos + hOffset, 0);
if (matrix) {
m.postConcat(*matrix);
}
morphpath(&tmp, *iterPath, meas, m);
if (fDevice) {
fDevice->drawPath(*this, tmp, iter.getPaint(), NULL, true);
} else {
this->drawPath(tmp, iter.getPaint(), NULL, true);
}
}
}
#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);
// 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*);
static HairProc ChooseHairProc(bool doAntiAlias) {
return doAntiAlias ? SkScan::AntiHairLine : SkScan::HairLine;
}
static bool texture_to_matrix(const VertState& state, const SkPoint verts[],
const SkPoint texs[], SkMatrix* matrix) {
SkPoint src[3], dst[3];
src[0] = texs[state.f0];
src[1] = texs[state.f1];
src[2] = texs[state.f2];
dst[0] = verts[state.f0];
dst[1] = verts[state.f1];
dst[2] = verts[state.f2];
return matrix->setPolyToPoly(src, dst, 3);
}
class SkTriColorShader : public SkShader {
public:
SkTriColorShader() {}
bool setup(const SkPoint pts[], const SkColor colors[], int, int, int);
virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count);
protected:
SkTriColorShader(SkFlattenableReadBuffer& buffer) : SkShader(buffer) {}
virtual Factory getFactory() { return CreateProc; }
private:
SkMatrix fDstToUnit;
SkPMColor fColors[3];
static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
return SkNEW_ARGS(SkTriColorShader, (buffer));
}
typedef SkShader INHERITED;
};
bool SkTriColorShader::setup(const SkPoint pts[], const SkColor colors[],
int index0, int index1, int index2) {
fColors[0] = SkPreMultiplyColor(colors[index0]);
fColors[1] = SkPreMultiplyColor(colors[index1]);
fColors[2] = SkPreMultiplyColor(colors[index2]);
SkMatrix m, im;
m.reset();
m.set(0, pts[index1].fX - pts[index0].fX);
m.set(1, pts[index2].fX - pts[index0].fX);
m.set(2, pts[index0].fX);
m.set(3, pts[index1].fY - pts[index0].fY);
m.set(4, pts[index2].fY - pts[index0].fY);
m.set(5, pts[index0].fY);
if (!m.invert(&im)) {
return false;
}
return fDstToUnit.setConcat(im, this->getTotalInverse());
}
#include "SkColorPriv.h"
#include "SkComposeShader.h"
static int ScalarTo256(SkScalar v) {
int scale = SkScalarToFixed(v) >> 8;
if (scale < 0) {
scale = 0;
}
if (scale > 255) {
scale = 255;
}
return SkAlpha255To256(scale);
}
void SkTriColorShader::shadeSpan(int x, int y, SkPMColor dstC[], int count) {
SkPoint src;
for (int i = 0; i < count; i++) {
fDstToUnit.mapXY(SkIntToScalar(x), SkIntToScalar(y), &src);
x += 1;
int scale1 = ScalarTo256(src.fX);
int scale2 = ScalarTo256(src.fY);
int scale0 = 256 - scale1 - scale2;
if (scale0 < 0) {
if (scale1 > scale2) {
scale2 = 256 - scale1;
} else {
scale1 = 256 - scale2;
}
scale0 = 0;
}
dstC[i] = SkAlphaMulQ(fColors[0], scale0) +
SkAlphaMulQ(fColors[1], scale1) +
SkAlphaMulQ(fColors[2], scale2);
}
}
void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count,
const SkPoint vertices[], const SkPoint textures[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) const {
SkASSERT(0 == count || NULL != vertices);
// abort early if there is nothing to draw
if (count < 3 || (indices && indexCount < 3) || fRC->isEmpty()) {
return;
}
// transform out vertices into device coordinates
SkAutoSTMalloc<16, SkPoint> storage(count);
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:
- solid color (no shader/texture[], no colors[])
- just colors (no shader/texture[], has colors[])
- just texture (has shader/texture[], no colors[])
- colors * texture (has shader/texture[], has colors[])
Thus for texture drawing, we need both texture[] and a shader.
*/
SkTriColorShader triShader; // must be above declaration of p
SkPaint p(paint);
SkShader* shader = p.getShader();
if (NULL == shader) {
// if we have no shader, we ignore the texture coordinates
textures = NULL;
} else if (NULL == textures) {
// if we don't have texture coordinates, ignore the shader
p.setShader(NULL);
shader = NULL;
}
// setup the custom shader (if needed)
if (NULL != colors) {
if (NULL == textures) {
// just colors (no texture)
p.setShader(&triShader);
} else {
// colors * texture
SkASSERT(shader);
bool releaseMode = false;
if (NULL == xmode) {
xmode = SkXfermode::Create(SkXfermode::kMultiply_Mode);
releaseMode = true;
}
SkShader* compose = SkNEW_ARGS(SkComposeShader,
(&triShader, shader, xmode));
p.setShader(compose)->unref();
if (releaseMode) {
xmode->unref();
}
}
}
SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, p);
// setup our state and function pointer for iterating triangles
VertState state(count, indices, indexCount);
VertState::Proc vertProc = state.chooseProc(vmode);
if (NULL != textures || NULL != colors) {
SkMatrix localM, tempM;
bool hasLocalM = shader && shader->getLocalMatrix(&localM);
if (NULL != colors) {
if (!triShader.setContext(*fBitmap, p, *fMatrix)) {
colors = NULL;
}
}
while (vertProc(&state)) {
if (NULL != textures) {
if (texture_to_matrix(state, vertices, textures, &tempM)) {
if (hasLocalM) {
tempM.postConcat(localM);
}
shader->setLocalMatrix(tempM);
// need to recal setContext since we changed the local matrix
if (!shader->setContext(*fBitmap, p, *fMatrix)) {
continue;
}
}
}
if (NULL != colors) {
if (!triShader.setup(vertices, colors,
state.f0, state.f1, state.f2)) {
continue;
}
}
SkPoint tmp[] = {
devVerts[state.f0], devVerts[state.f1], devVerts[state.f2]
};
SkScan::FillTriangle(tmp, *fRC, blitter.get());
}
// now restore the shader's original local matrix
if (NULL != shader) {
if (hasLocalM) {
shader->setLocalMatrix(localM);
} else {
shader->resetLocalMatrix();
}
}
} else {
// no colors[] and no texture
HairProc hairProc = ChooseHairProc(paint.isAntiAlias());
const SkRasterClip& clip = *fRC;
while (vertProc(&state)) {
hairProc(devVerts[state.f0], devVerts[state.f1], clip, blitter.get());
hairProc(devVerts[state.f1], devVerts[state.f2], clip, blitter.get());
hairProc(devVerts[state.f2], devVerts[state.f0], clip, blitter.get());
}
}
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef SK_DEBUG
void SkDraw::validate() const {
SkASSERT(fBitmap != NULL);
SkASSERT(fMatrix != NULL);
SkASSERT(fClip != NULL);
SkASSERT(fRC != NULL);
const SkIRect& cr = fRC->getBounds();
SkIRect br;
br.set(0, 0, fBitmap->width(), fBitmap->height());
SkASSERT(cr.isEmpty() || br.contains(cr));
// assert that both are null, or both are not-null
SkASSERT(!fMVMatrix == !fExtMatrix);
}
#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"
#include "SkDraw.h"
#include "SkRegion.h"
#include "SkBlitter.h"
static bool compute_bounds(const SkPath& devPath, const SkIRect* clipBounds,
SkMaskFilter* filter, const SkMatrix* filterMatrix,
SkIRect* bounds) {
if (devPath.isEmpty()) {
return false;
}
// init our bounds from the path
{
SkRect pathBounds = devPath.getBounds();
pathBounds.inset(-SK_ScalarHalf, -SK_ScalarHalf);
pathBounds.roundOut(bounds);
}
SkIPoint margin;
if (filter) {
SkASSERT(filterMatrix);
SkMask srcM, dstM;
srcM.fBounds = *bounds;
srcM.fFormat = SkMask::kA8_Format;
srcM.fImage = NULL;
if (!filter->filterMask(&dstM, srcM, *filterMatrix, &margin)) {
return false;
}
}
// (possibly) trim the bounds to reflect the clip
// (plus whatever slop the filter needs)
if (clipBounds) {
SkIRect tmp = *clipBounds;
// Ugh. Guard against gigantic margins from wacky filters. Without this
// check we can request arbitrary amounts of slop beyond our visible
// clip, and bring down the renderer (at least on finite RAM machines
// like handsets, etc.). Need to balance this invented value between
// quality of large filters like blurs, and the corresponding memory
// requests.
static const int MAX_MARGIN = 128;
tmp.inset(-SkMin32(margin.fX, MAX_MARGIN),
-SkMin32(margin.fY, MAX_MARGIN));
if (!bounds->intersect(tmp)) {
return false;
}
}
return true;
}
static void draw_into_mask(const SkMask& mask, const SkPath& devPath) {
SkBitmap bm;
SkDraw draw;
SkRasterClip clip;
SkMatrix matrix;
SkPaint paint;
bm.setConfig(SkBitmap::kA8_Config, mask.fBounds.width(), mask.fBounds.height(), mask.fRowBytes);
bm.setPixels(mask.fImage);
clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height()));
matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
-SkIntToScalar(mask.fBounds.fTop));
draw.fBitmap = &bm;
draw.fRC = &clip;
draw.fClip = &clip.bwRgn();
draw.fMatrix = &matrix;
draw.fBounder = NULL;
paint.setAntiAlias(true);
draw.drawPath(devPath, paint);
}
bool SkDraw::DrawToMask(const SkPath& devPath, const SkIRect* clipBounds,
SkMaskFilter* filter, const SkMatrix* filterMatrix,
SkMask* mask, SkMask::CreateMode mode) {
if (SkMask::kJustRenderImage_CreateMode != mode) {
if (!compute_bounds(devPath, clipBounds, filter, filterMatrix, &mask->fBounds))
return false;
}
if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) {
mask->fFormat = SkMask::kA8_Format;
mask->fRowBytes = mask->fBounds.width();
size_t size = mask->computeImageSize();
if (0 == size) {
// we're too big to allocate the mask, abort
return false;
}
mask->fImage = SkMask::AllocImage(size);
memset(mask->fImage, 0, mask->computeImageSize());
}
if (SkMask::kJustComputeBounds_CreateMode != mode) {
draw_into_mask(*mask, devPath);
}
return true;
}