class GrContext;
#endif
+#define INT_SIZE 64
+#define SCALAR_SIZE SkIntToScalar(INT_SIZE)
-static void make_bitmap(SkBitmap* bitmap, GrContext* ctx) {
- SkCanvas canvas;
-
-#if SK_SUPPORT_GPU
- if (ctx) {
- SkDevice* dev = new SkGpuDevice(ctx, SkBitmap::kARGB_8888_Config, 64, 64);
- canvas.setDevice(dev)->unref();
- *bitmap = dev->accessBitmap(false);
- } else
-#endif
- {
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, 64, 64);
- bitmap->allocPixels();
- canvas.setBitmapDevice(*bitmap);
- }
+static void make_bitmap(SkBitmap* bitmap) {
+ bitmap->setConfig(SkBitmap::kARGB_8888_Config, INT_SIZE, INT_SIZE);
+ bitmap->allocPixels();
+ SkCanvas canvas(*bitmap);
canvas.drawColor(SK_ColorRED);
SkPaint paint;
paint.setAntiAlias(true);
- const SkPoint pts[] = { { 0, 0 }, { 64, 64 } };
+ const SkPoint pts[] = { { 0, 0 }, { SCALAR_SIZE, SCALAR_SIZE } };
const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
paint.setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2,
SkShader::kClamp_TileMode))->unref();
- canvas.drawCircle(32, 32, 32, paint);
+ canvas.drawCircle(SCALAR_SIZE/2, SCALAR_SIZE/2, SCALAR_SIZE/2, paint);
+}
+
+static SkPoint unit_vec(int degrees) {
+ SkScalar rad = SkDegreesToRadians(SkIntToScalar(degrees));
+ SkScalar s, c;
+ s = SkScalarSinCos(rad, &c);
+ return SkPoint::Make(c, s);
+}
+
+static void bounce(SkScalar* value, SkScalar* delta, SkScalar min, SkScalar max) {
+ *value += *delta;
+ if (*value < min) {
+ *value = min;
+ *delta = - *delta;
+ } else if (*value > max) {
+ *value = max;
+ *delta = - *delta;
+ }
+}
+
+static void bounce_pt(SkPoint* pt, SkVector* vec, const SkRect& limit) {
+ bounce(&pt->fX, &vec->fX, limit.fLeft, limit.fRight);
+ bounce(&pt->fY, &vec->fY, limit.fTop, limit.fBottom);
}
class BitmapRectView : public SampleView {
+ SkPoint fSrcPts[2];
+ SkPoint fSrcVec[2];
+ SkRect fSrcLimit;
+ SkRect fDstR[2];
+
+ void bounce() {
+ bounce_pt(&fSrcPts[0], &fSrcVec[0], fSrcLimit);
+ bounce_pt(&fSrcPts[1], &fSrcVec[1], fSrcLimit);
+ }
+
public:
BitmapRectView() {
this->setBGColor(SK_ColorGRAY);
+
+ fSrcPts[0].set(0, 0);
+ fSrcPts[1].set(SCALAR_SIZE, SCALAR_SIZE);
+
+ fSrcVec[0] = unit_vec(30);
+ fSrcVec[1] = unit_vec(107);
+
+ fSrcLimit.set(-SCALAR_SIZE/4, -SCALAR_SIZE/4,
+ SCALAR_SIZE*5/4, SCALAR_SIZE*5/4);
+
+ fDstR[0] = SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(100),
+ SkIntToScalar(250), SkIntToScalar(300));
+ fDstR[1] = fDstR[0];
+ fDstR[1].offset(fDstR[0].width() * 5/4, 0);
+
+ fSrcPts[0].set(32, 32);
+ fSrcPts[1].set(90, 90);
}
protected:
}
virtual void onDrawContent(SkCanvas* canvas) {
- GrContext* ctx = SampleCode::GetGr();
-
- const SkIRect src[] = {
- { 0, 0, 32, 32 },
- { 0, 0, 80, 80 },
- { 32, 32, 96, 96 },
- { -32, -32, 32, 32, }
- };
+ SkRect srcR;
+ srcR.set(fSrcPts[0], fSrcPts[1]);
+ srcR = SkRect::MakeXYWH(fSrcPts[0].fX, fSrcPts[0].fY, 32, 32);
+ srcR.offset(-srcR.width()/2, -srcR.height()/2);
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
- paint.setColor(ctx ? SK_ColorGREEN : SK_ColorYELLOW);
+ paint.setColor(SK_ColorYELLOW);
SkBitmap bitmap;
- make_bitmap(&bitmap, ctx);
+ make_bitmap(&bitmap);
+
+ canvas->translate(20, 20);
+
+ canvas->drawBitmap(bitmap, 0, 0, &paint);
+ canvas->drawRect(srcR, paint);
+
+ for (int i = 0; i < 2; ++i) {
+ paint.setFilterBitmap(1 == i);
+ canvas->drawBitmapRectToRect(bitmap, &srcR, fDstR[i], &paint);
+ canvas->drawRect(fDstR[i], paint);
+ }
+
+ this->bounce();
+ this->inval(NULL);
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static void make_big_bitmap(SkBitmap* bm) {
+ static const char gText[] =
+ "We the people, in order to form a more perfect union, establish justice,"
+ " ensure domestic tranquility, provide for the common defense, promote the"
+ " general welfare and ensure the blessings of liberty to ourselves and our"
+ " posterity, do ordain and establish this constitution for the United"
+ " States of America.";
+
+ const int BIG_H = 120;
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setTextSize(SkIntToScalar(BIG_H));
+
+ const int BIG_W = SkScalarRoundToInt(paint.measureText(gText, strlen(gText)));
+
+ bm->setConfig(SkBitmap::kARGB_8888_Config, BIG_W, BIG_H);
+ bm->allocPixels();
+ bm->eraseColor(SK_ColorWHITE);
+
+ SkCanvas canvas(*bm);
+
+ canvas.drawText(gText, strlen(gText), 0, paint.getTextSize()*4/5, paint);
+}
+
+class BitmapRectView2 : public SampleView {
+ SkBitmap fBitmap;
+
+ SkRect fSrcR;
+ SkRect fLimitR;
+ SkScalar fDX;
+ SkRect fDstR[2];
+
+ void bounceMe() {
+ SkScalar width = fSrcR.width();
+ bounce(&fSrcR.fLeft, &fDX, fLimitR.fLeft, fLimitR.fRight - width);
+ fSrcR.fRight = fSrcR.fLeft + width;
+ }
+
+public:
+ BitmapRectView2() {
+ make_big_bitmap(&fBitmap);
- SkRect dstR = { 0, 200, 128, 380 };
+ this->setBGColor(SK_ColorGRAY);
- canvas->translate(16, 40);
- for (size_t i = 0; i < SK_ARRAY_COUNT(src); i++) {
- SkRect srcR;
- srcR.set(src[i]);
+ fSrcR.fLeft = 0;
+ fSrcR.fTop = 0;
+ fSrcR.fRight = SkIntToScalar(fBitmap.height()) * 3;
+ fSrcR.fBottom = SkIntToScalar(fBitmap.height());
- canvas->drawBitmap(bitmap, 0, 0, &paint);
- canvas->drawBitmapRect(bitmap, &src[i], dstR, &paint);
+ fLimitR.set(0, 0,
+ SkIntToScalar(fBitmap.width()),
+ SkIntToScalar(fBitmap.height()));
- canvas->drawRect(dstR, paint);
- canvas->drawRect(srcR, paint);
+ fDX = SK_Scalar1;
- canvas->translate(160, 0);
+ fDstR[0] = SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
+ SkIntToScalar(600), SkIntToScalar(200));
+ fDstR[1] = fDstR[0];
+ fDstR[1].offset(0, fDstR[0].height() * 5/4);
+ }
+
+protected:
+ // overrides from SkEventSink
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "BigBitmapRect");
+ return true;
}
+ return this->INHERITED::onQuery(evt);
}
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPaint paint;
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setColor(SK_ColorYELLOW);
+ for (int i = 0; i < 2; ++i) {
+ paint.setFilterBitmap(1 == i);
+ canvas->drawBitmapRectToRect(fBitmap, &fSrcR, fDstR[i], &paint);
+ canvas->drawRect(fDstR[i], paint);
+ }
+
+ this->bounceMe();
+ this->inval(NULL);
+ }
+
private:
typedef SkView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
-static SkView* MyFactory() { return new BitmapRectView; }
-static SkViewRegister reg(MyFactory);
+static SkView* F0() { return new BitmapRectView; }
+static SkView* F1() { return new BitmapRectView2; }
+static SkViewRegister gR0(F0);
+static SkViewRegister gR1(F1);
#include "SkMetaData.h"
#include "SkRasterClip.h"
#include "SkRect.h"
+#include "SkShader.h"
SK_DEFINE_INST_COUNT(SkDevice)
draw.drawBitmap(*bitmapPtr, matrix, paint);
}
+void SkDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
+ const SkRect* src, const SkRect& dst,
+ const SkPaint& paint) {
+ SkMatrix matrix;
+ SkRect bitmapBounds, tmpSrc, tmpDst;
+ SkBitmap tmpBitmap;
+
+ bitmapBounds.set(0, 0,
+ SkIntToScalar(bitmap.width()),
+ SkIntToScalar(bitmap.height()));
+
+ // Compute matrix from the two rectangles
+ if (src) {
+ tmpSrc = *src;
+ } else {
+ tmpSrc = bitmapBounds;
+ }
+ matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
+
+ const SkRect* dstPtr = &dst;
+ const SkBitmap* bitmapPtr = &bitmap;
+
+ // clip the tmpSrc to the bounds of the bitmap, and recompute dstRect if
+ // needed (if the src was clipped). No check needed if src==null.
+ if (src) {
+ if (!bitmapBounds.contains(*src)) {
+ if (!tmpSrc.intersect(bitmapBounds)) {
+ return; // nothing to draw
+ }
+ // recompute dst, based on the smaller tmpSrc
+ matrix.mapRect(&tmpDst, tmpSrc);
+ dstPtr = &tmpDst;
+ }
+
+ // since we may need to clamp to the borders of the src rect within
+ // the bitmap, we extract a subset.
+ SkIRect srcIR;
+ tmpSrc.roundOut(&srcIR);
+ if (!bitmap.extractSubset(&tmpBitmap, srcIR)) {
+ return;
+ }
+ bitmapPtr = &tmpBitmap;
+
+ // Since we did an extract, we need to adjust the matrix accordingly
+ SkScalar dx = 0, dy = 0;
+ if (srcIR.fLeft > 0) {
+ dx = SkIntToScalar(srcIR.fLeft);
+ }
+ if (srcIR.fTop > 0) {
+ dy = SkIntToScalar(srcIR.fTop);
+ }
+ if (dx || dy) {
+ matrix.preTranslate(dx, dy);
+ }
+ }
+
+ // construct a shader, so we can call drawRect with the dst
+ SkShader* s = SkShader::CreateBitmapShader(*bitmapPtr,
+ SkShader::kClamp_TileMode,
+ SkShader::kClamp_TileMode);
+ if (NULL == s) {
+ return;
+ }
+ s->setLocalMatrix(matrix);
+
+ SkPaint paintWithShader(paint);
+ paintWithShader.setStyle(SkPaint::kFill_Style);
+ paintWithShader.setShader(s)->unref();
+
+ // Call ourself, in case the subclass wanted to share this setup code
+ // but handle the drawRect code themselves.
+ this->drawRect(draw, *dstPtr, paintWithShader);
+}
+
void SkDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
int x, int y, const SkPaint& paint) {
draw.drawSprite(bitmap, x, y, paint);
GR_Scalar1 * h / texture->height()));
}
+void SkGpuDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
+ const SkRect* src, const SkRect& dst,
+ const SkPaint& paint) {
+ SkMatrix matrix;
+ // Compute matrix from the two rectangles
+ {
+ SkRect tmpSrc;
+ if (src) {
+ tmpSrc = *src;
+ // if the extract process clipped off the top or left of the
+ // original, we adjust for that here to get the position right.
+ if (tmpSrc.fLeft > 0) {
+ tmpSrc.fRight -= tmpSrc.fLeft;
+ tmpSrc.fLeft = 0;
+ }
+ if (tmpSrc.fTop > 0) {
+ tmpSrc.fBottom -= tmpSrc.fTop;
+ tmpSrc.fTop = 0;
+ }
+ } else {
+ tmpSrc.set(0, 0, SkIntToScalar(bitmap.width()),
+ SkIntToScalar(bitmap.height()));
+ }
+ matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
+ }
+
+ // ensure that src is "valid" before we pass it to our internal routines
+ // and to SkDevice. i.e. sure it is contained inside the original bitmap.
+ SkIRect isrcStorage;
+ SkIRect* isrcPtr = NULL;
+ if (src) {
+ src->roundOut(&isrcStorage);
+ if (!isrcStorage.intersect(0, 0, bitmap.width(), bitmap.height())) {
+ return;
+ }
+ isrcPtr = &isrcStorage;
+ }
+
+ this->drawBitmap(draw, bitmap, isrcPtr, matrix, paint);
+}
+
void SkGpuDevice::drawDevice(const SkDraw& draw, SkDevice* device,
int x, int y, const SkPaint& paint) {
// clear of the source device must occur before CHECK_SHOULD_DRAW
projects / platform / upstream / libSkiaSharp.git / commitdiff