AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
ef818a470e
skia2/samplecode/SampleWarp.cpp
rmistry@google.com ae933ce0ea Result of running tools/sanitize_source_files.py (which was added in https://codereview.appspot.com/6465078/) 
This CL is part III of IV (I broke down the 1280 files into 4 CLs).
Review URL: https://codereview.appspot.com/6475053

git-svn-id: http://skia.googlecode.com/svn/trunk@5264 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-08-23 18:19:56 +00:00

475 lines
13 KiB
C++
Raw Blame History

/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SampleCode.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkGradientShader.h"
#include "SkPath.h"
#include "SkRegion.h"
#include "SkShader.h"
#include "SkUtils.h"
#include "SkImageDecoder.h"
#include "SkBlurMaskFilter.h"
#include "SkTableMaskFilter.h"
#define kNearlyZero (SK_Scalar1 / 8092)
static void test_bigblur(SkCanvas* canvas) {
canvas->drawColor(SK_ColorBLACK);
SkBitmap orig, mask;
SkImageDecoder::DecodeFile("/skimages/app_icon.png", &orig);
SkMaskFilter* mf = SkBlurMaskFilter::Create(8, SkBlurMaskFilter::kNormal_BlurStyle);
SkPaint paint;
paint.setMaskFilter(mf)->unref();
SkIPoint offset;
orig.extractAlpha(&mask, &paint, &offset);
paint.setColor(0xFFBB8800);
paint.setColor(SK_ColorWHITE);
int i;
canvas->save();
float gamma = 0.8;
for (i = 0; i < 5; i++) {
paint.setMaskFilter(SkTableMaskFilter::CreateGamma(gamma))->unref();
canvas->drawBitmap(mask, 0, 0, &paint);
paint.setMaskFilter(NULL);
canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
gamma -= 0.1;
canvas->translate(120, 0);
}
canvas->restore();
canvas->translate(0, 160);
for (i = 0; i < 5; i++) {
paint.setMaskFilter(SkTableMaskFilter::CreateClip(i*30, 255 - 20))->unref();
canvas->drawBitmap(mask, 0, 0, &paint);
paint.setMaskFilter(NULL);
canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
canvas->translate(120, 0);
}
#if 0
paint.setColor(0xFFFFFFFF);
canvas->drawBitmap(mask, 0, 0, &paint);
paint.setMaskFilter(NULL);
canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
canvas->translate(120, 0);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
canvas->translate(120, 0);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
canvas->translate(120, 0);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
canvas->translate(120, 0);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(mask, 0, 0, &paint);
canvas->drawBitmap(orig, -offset.fX, -offset.fY, &paint);
#endif
}
#include "SkMeshUtils.h"
static SkPoint SkMakePoint(SkScalar x, SkScalar y) {
SkPoint pt;
pt.set(x, y);
return pt;
}
static SkPoint SkPointInterp(const SkPoint& a, const SkPoint& b, SkScalar t) {
return SkMakePoint(SkScalarInterp(a.fX, b.fX, t),
SkScalarInterp(a.fY, b.fY, t));
}
#include "SkBoundaryPatch.h"
static void set_cubic(SkPoint pts[4], SkScalar x0, SkScalar y0,
SkScalar x3, SkScalar y3, SkScalar scale = 1) {
SkPoint tmp, tmp2;
pts[0].set(x0, y0);
pts[3].set(x3, y3);
tmp = SkPointInterp(pts[0], pts[3], SK_Scalar1/3);
tmp2 = pts[0] - tmp;
tmp2.rotateCW();
tmp2.scale(scale);
pts[1] = tmp + tmp2;
tmp = SkPointInterp(pts[0], pts[3], 2*SK_Scalar1/3);
tmp2 = pts[3] - tmp;
tmp2.rotateCW();
tmp2.scale(scale);
pts[2] = tmp + tmp2;
}
static void test_patch(SkCanvas* canvas, const SkBitmap& bm, SkScalar scale) {
SkCubicBoundary cubic;
set_cubic(cubic.fPts + 0, 0, 0, 100, 0, scale);
set_cubic(cubic.fPts + 3, 100, 0, 100, 100, scale);
set_cubic(cubic.fPts + 6, 100, 100, 0, 100, -scale);
set_cubic(cubic.fPts + 9, 0, 100, 0, 0, 0);
SkBoundaryPatch patch;
patch.setBoundary(&cubic);
const int Rows = 16;
const int Cols = 16;
SkPoint pts[Rows * Cols];
patch.evalPatch(pts, Rows, Cols);
SkPaint paint;
paint.setAntiAlias(true);
paint.setFilterBitmap(true);
paint.setStrokeWidth(1);
paint.setStrokeCap(SkPaint::kRound_Cap);
canvas->translate(50, 50);
canvas->scale(3, 3);
SkMeshUtils::Draw(canvas, bm, Rows, Cols, pts, NULL, paint);
}
static void test_drag(SkCanvas* canvas, const SkBitmap& bm,
const SkPoint& p0, const SkPoint& p1) {
SkCubicBoundary cubic;
set_cubic(cubic.fPts + 0, 0, 0, 100, 0, 0);
set_cubic(cubic.fPts + 3, 100, 0, 100, 100, 0);
set_cubic(cubic.fPts + 6, 100, 100, 0, 100, 0);
set_cubic(cubic.fPts + 9, 0, 100, 0, 0, 0);
#if 0
cubic.fPts[1] += p1 - p0;
cubic.fPts[2] += p1 - p0;
#else
SkScalar dx = p1.fX - p0.fX;
if (dx > 0) dx = 0;
SkScalar dy = p1.fY - p0.fY;
if (dy > 0) dy = 0;
cubic.fPts[1].fY += dy;
cubic.fPts[2].fY += dy;
cubic.fPts[10].fX += dx;
cubic.fPts[11].fX += dx;
#endif
SkBoundaryPatch patch;
patch.setBoundary(&cubic);
const int Rows = 16;
const int Cols = 16;
SkPoint pts[Rows * Cols];
patch.evalPatch(pts, Rows, Cols);
SkPaint paint;
paint.setAntiAlias(true);
paint.setFilterBitmap(true);
paint.setStrokeWidth(1);
paint.setStrokeCap(SkPaint::kRound_Cap);
canvas->translate(50, 50);
canvas->scale(3, 3);
SkAutoCanvasRestore acr(canvas, true);
SkRect r = { 0, 0, 100, 100 };
canvas->clipRect(r);
SkMeshUtils::Draw(canvas, bm, Rows, Cols, pts, NULL, paint);
}
///////////////////////////////////////////////////////////////////////////////
class Mesh {
public:
Mesh();
~Mesh();
Mesh& operator=(const Mesh& src);
void init(const SkRect& bounds, int rows, int cols,
const SkRect& texture);
const SkRect& bounds() const { return fBounds; }
int rows() const { return fRows; }
int cols() const { return fCols; }
SkPoint& pt(int row, int col) {
return fPts[row * (fRows + 1) + col];
}
void draw(SkCanvas*, const SkPaint&);
void drawWireframe(SkCanvas* canvas, const SkPaint& paint);
private:
SkRect fBounds;
int fRows, fCols;
SkPoint* fPts;
SkPoint* fTex; // just points into fPts, not separately allocated
int fCount;
uint16_t* fIndices;
int fIndexCount;
};
Mesh::Mesh() : fPts(NULL), fCount(0), fIndices(NULL), fIndexCount(0) {}
Mesh::~Mesh() {
delete[] fPts;
delete[] fIndices;
}
Mesh& Mesh::operator=(const Mesh& src) {
delete[] fPts;
delete[] fIndices;
fBounds = src.fBounds;
fRows = src.fRows;
fCols = src.fCols;
fCount = src.fCount;
fPts = new SkPoint[fCount * 2];
fTex = fPts + fCount;
memcpy(fPts, src.fPts, fCount * 2 * sizeof(SkPoint));
delete[] fIndices;
fIndexCount = src.fIndexCount;
fIndices = new uint16_t[fIndexCount];
memcpy(fIndices, src.fIndices, fIndexCount * sizeof(uint16_t));
return *this;
}
void Mesh::init(const SkRect& bounds, int rows, int cols,
const SkRect& texture) {
SkASSERT(rows > 0 && cols > 0);
fBounds = bounds;
fRows = rows;
fCols = cols;
delete[] fPts;
fCount = (rows + 1) * (cols + 1);
fPts = new SkPoint[fCount * 2];
fTex = fPts + fCount;
delete[] fIndices;
fIndexCount = rows * cols * 6;
fIndices = new uint16_t[fIndexCount];
SkPoint* pts = fPts;
const SkScalar dx = bounds.width() / rows;
const SkScalar dy = bounds.height() / cols;
SkPoint* tex = fTex;
const SkScalar dtx = texture.width() / rows;
const SkScalar dty = texture.height() / cols;
uint16_t* idx = fIndices;
int index = 0;
for (int y = 0; y <= cols; y++) {
for (int x = 0; x <= rows; x++) {
pts->set(bounds.fLeft + x*dx, bounds.fTop + y*dy);
pts += 1;
tex->set(texture.fLeft + x*dtx, texture.fTop + y*dty);
tex += 1;
if (y < cols && x < rows) {
*idx++ = index;
*idx++ = index + rows + 1;
*idx++ = index + 1;
*idx++ = index + 1;
*idx++ = index + rows + 1;
*idx++ = index + rows + 2;
index += 1;
}
}
index += 1;
}
}
void Mesh::draw(SkCanvas* canvas, const SkPaint& paint) {
canvas->drawVertices(SkCanvas::kTriangles_VertexMode, fCount,
fPts, fTex, NULL, NULL, fIndices, fIndexCount,
paint);
}
void Mesh::drawWireframe(SkCanvas* canvas, const SkPaint& paint) {
canvas->drawVertices(SkCanvas::kTriangles_VertexMode, fCount,
fPts, NULL, NULL, NULL, fIndices, fIndexCount,
paint);
}
///////////////////////////////////////////////////////////////////////////////
class WarpView : public SkView {
Mesh fMesh, fOrig;
SkBitmap fBitmap;
SkMatrix fMatrix, fInverse;
public:
WarpView() {
SkBitmap bm;
// SkImageDecoder::DecodeFile("/skimages/marker.png", &bm);
SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm);
// SkImageDecoder::DecodeFile("/beach_shot.JPG", &bm);
fBitmap = bm;
SkRect bounds, texture;
texture.set(0, 0, SkIntToScalar(fBitmap.width()),
SkIntToScalar(fBitmap.height()));
bounds = texture;
// fMesh.init(bounds, fBitmap.width() / 40, fBitmap.height() / 40, texture);
fMesh.init(bounds, fBitmap.width()/16, fBitmap.height()/16, texture);
fOrig = fMesh;
fP0.set(0, 0);
fP1 = fP0;
fMatrix.setScale(2, 2);
fMatrix.invert(&fInverse);
}
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Warp");
return true;
}
return this->INHERITED::onQuery(evt);
}
static SkPoint apply_warp(const SkVector& drag, SkScalar dragLength,
const SkPoint& dragStart, const SkPoint& dragCurr,
const SkPoint& orig) {
SkVector delta = orig - dragCurr;
SkScalar length = SkPoint::Normalize(&delta);
if (length <= kNearlyZero) {
return orig;
}
const SkScalar period = 20;
const SkScalar mag = dragLength / 3;
SkScalar d = length / (period);
d = mag * SkScalarSin(d) / d;
SkScalar dx = delta.fX * d;
SkScalar dy = delta.fY * d;
SkScalar px = orig.fX + dx;
SkScalar py = orig.fY + dy;
return SkPoint::Make(px, py);
}
static SkPoint apply_warp2(const SkVector& drag, SkScalar dragLength,
const SkPoint& dragStart, const SkPoint& dragCurr,
const SkPoint& orig) {
SkVector delta = orig - dragCurr;
SkScalar length = SkPoint::Normalize(&delta);
if (length <= kNearlyZero) {
return orig;
}
const SkScalar period = 10 + dragLength/4;
const SkScalar mag = dragLength / 3;
SkScalar d = length / (period);
if (d > SK_ScalarPI) {
d = SK_ScalarPI;
}
d = -mag * SkScalarSin(d);
SkScalar dx = delta.fX * d;
SkScalar dy = delta.fY * d;
SkScalar px = orig.fX + dx;
SkScalar py = orig.fY + dy;
return SkPoint::Make(px, py);
}
typedef SkPoint (*WarpProc)(const SkVector& drag, SkScalar dragLength,
const SkPoint& dragStart, const SkPoint& dragCurr,
const SkPoint& orig);
void warp(const SkPoint& p0, const SkPoint& p1) {
WarpProc proc = apply_warp2;
SkPoint delta = p1 - p0;
SkScalar length = SkPoint::Normalize(&delta);
for (int y = 0; y < fMesh.rows(); y++) {
for (int x = 0; x < fMesh.cols(); x++) {
fMesh.pt(x, y) = proc(delta, length, p0, p1, fOrig.pt(x, y));
}
}
fP0 = p0;
fP1 = p1;
}
virtual void onDraw(SkCanvas* canvas) {
canvas->drawColor(SK_ColorLTGRAY);
// test_bigblur(canvas); return;
canvas->concat(fMatrix);
SkPaint paint;
paint.setFilterBitmap(true);
paint.setShader(SkShader::CreateBitmapShader(fBitmap,
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode))->unref();
fMesh.draw(canvas, paint); //return;
paint.setShader(NULL);
paint.setColor(SK_ColorRED);
fMesh.draw(canvas, paint);
// test_drag(canvas, fBitmap, fP0, fP1);
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
return new Click(this);
}
virtual bool onClick(Click* click) {
SkPoint pts[2] = { click->fOrig, click->fCurr };
fInverse.mapPoints(pts, 2);
this->warp(pts[0], pts[1]);
this->inval(NULL);
return true;
}
private:
SkIRect fBase, fRect;
SkPoint fP0, fP1;
typedef SkView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
static SkView* MyFactory() { return new WarpView; }
static SkViewRegister reg(MyFactory);
Reference in New Issue View Git Blame Copy Permalink