void GrContext::drawFontCache(const SkRect& rect, GrMaskFormat format, const SkPaint& paint,
GrRenderTarget* target) {
GrBatchFontCache* cache = this->getBatchFontCache();
GrTexture* atlas = cache->getTexture(format);
SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(target));
// TODO: add drawContext method to encapsulate this.
GrPaint grPaint;
SkMatrix mat;
mat.reset();
if (!SkPaintToGrPaint(this, paint, mat, &grPaint)) {
return;
}
SkMatrix textureMat;
textureMat.reset();
// TODO: use setScaleTranslate()
textureMat[SkMatrix::kMScaleX] = 1.0f/rect.width();
textureMat[SkMatrix::kMScaleY] = 1.0f/rect.height();
textureMat[SkMatrix::kMTransX] = -rect.fLeft/rect.width();
textureMat[SkMatrix::kMTransY] = -rect.fTop/rect.height();
grPaint.addColorTextureProcessor(atlas, textureMat);
GrClip clip;
drawContext->drawRect(clip, grPaint, mat, rect);
}
virtual void onDraw(SkCanvas* canvas) {
SkMatrix m;
m.reset();
m.setRotate(33 * SK_Scalar1);
m.postScale(3000 * SK_Scalar1, 3000 * SK_Scalar1);
m.postTranslate(6000 * SK_Scalar1, -5000 * SK_Scalar1);
canvas->concat(m);
SkPaint paint;
paint.setColor(SK_ColorRED);
paint.setAntiAlias(true);
bool success = m.invert(&m);
SkASSERT(success);
(void) success; // silence compiler :(
SkPath path;
SkPoint pt = {10 * SK_Scalar1, 10 * SK_Scalar1};
SkScalar small = 1 / (500 * SK_Scalar1);
m.mapPoints(&pt, 1);
path.addCircle(pt.fX, pt.fY, small);
canvas->drawPath(path, paint);
pt.set(30 * SK_Scalar1, 10 * SK_Scalar1);
m.mapPoints(&pt, 1);
SkRect rect = {pt.fX - small, pt.fY - small,
pt.fX + small, pt.fY + small};
canvas->drawRect(rect, paint);
SkBitmap bmp;
bmp.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
bmp.allocPixels();
bmp.lockPixels();
uint32_t* pixels = reinterpret_cast<uint32_t*>(bmp.getPixels());
pixels[0] = SkPackARGB32(0xFF, 0xFF, 0x00, 0x00);
pixels[1] = SkPackARGB32(0xFF, 0x00, 0xFF, 0x00);
pixels[2] = SkPackARGB32(0x80, 0x00, 0x00, 0x00);
pixels[3] = SkPackARGB32(0xFF, 0x00, 0x00, 0xFF);
bmp.unlockPixels();
pt.set(30 * SK_Scalar1, 30 * SK_Scalar1);
m.mapPoints(&pt, 1);
SkShader* shader = SkShader::CreateBitmapShader(
bmp,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix s;
s.reset();
s.setScale(SK_Scalar1 / 1000, SK_Scalar1 / 1000);
shader->setLocalMatrix(s);
paint.setShader(shader)->unref();
paint.setAntiAlias(false);
paint.setFilterLevel(SkPaint::kLow_FilterLevel);
rect.setLTRB(pt.fX - small, pt.fY - small,
pt.fX + small, pt.fY + small);
canvas->drawRect(rect, paint);
}
void TransparencyWin::compositeTextComposite()
{
if (!m_validLayer)
return;
const SkBitmap& bitmap = m_layerBuffer->context()->layerBitmap(GraphicsContext::ReadWrite);
SkColor textColor = m_textCompositeColor.rgb();
for (int y = 0; y < m_layerSize.height(); y++) {
uint32_t* row = bitmap.getAddr32(0, y);
for (int x = 0; x < m_layerSize.width(); x++) {
// The alpha is the average of the R, G, and B channels.
int alpha = (SkGetPackedR32(row[x]) + SkGetPackedG32(row[x]) + SkGetPackedB32(row[x])) / 3;
// Apply that alpha to the text color and write the result.
row[x] = SkAlphaMulQ(textColor, SkAlpha255To256(255 - alpha));
}
}
// Now the layer has text with the proper color and opacity.
m_destContext->save();
// We want to use Untransformed space (see above)
SkMatrix identity;
identity.reset();
m_destContext->setMatrix(identity);
SkRect destRect = { m_transformedSourceRect.x(), m_transformedSourceRect.y(), m_transformedSourceRect.maxX(), m_transformedSourceRect.maxY() };
// Note that we need to specify the source layer subset, since the bitmap
// may have been cached and it could be larger than what we're using.
SkIRect sourceRect = { 0, 0, m_layerSize.width(), m_layerSize.height() };
m_destContext->drawBitmapRect(bitmap, &sourceRect, destRect, 0);
m_destContext->restore();
}
SkPDFFormXObject::SkPDFFormXObject(SkPDFDevice* device) {
// We don't want to keep around device because we'd have two copies
// of content, so reference or copy everything we need (content and
// resources).
auto resourceDict = device->makeResourceDict();
auto content = device->content();
this->setData(content.get());
sk_sp<SkPDFArray> bboxArray(device->copyMediaBox());
this->init(nullptr, resourceDict.get(), bboxArray.get());
// We invert the initial transform and apply that to the xobject so that
// it doesn't get applied twice. We can't just undo it because it's
// embedded in things like shaders and images.
if (!device->initialTransform().isIdentity()) {
SkMatrix inverse;
if (!device->initialTransform().invert(&inverse)) {
// The initial transform should be invertible.
SkASSERT(false);
inverse.reset();
}
this->insertObject("Matrix", SkPDFUtils::MatrixToArray(inverse));
}
}
static void scaleMatrix(const SkPath& one, const SkPath& two, SkMatrix& scale) {
SkRect larger = one.getBounds();
larger.join(two.getBounds());
SkScalar largerWidth = larger.width();
if (largerWidth < 4) {
largerWidth = 4;
}
SkScalar largerHeight = larger.height();
if (largerHeight < 4) {
largerHeight = 4;
}
SkScalar hScale = (bitWidth - 2) / largerWidth;
SkScalar vScale = (bitHeight - 2) / largerHeight;
scale.reset();
scale.preScale(hScale, vScale);
larger.fLeft *= hScale;
larger.fRight *= hScale;
larger.fTop *= vScale;
larger.fBottom *= vScale;
SkScalar dx = -16000 > larger.fLeft ? -16000 - larger.fLeft
: 16000 < larger.fRight ? 16000 - larger.fRight : 0;
SkScalar dy = -16000 > larger.fTop ? -16000 - larger.fTop
: 16000 < larger.fBottom ? 16000 - larger.fBottom : 0;
scale.postTranslate(dx, dy);
}
static Sink* create_via(const char* tag, Sink* wrapped) {
#define VIA(t, via, ...) if (0 == strcmp(t, tag)) { return new via(__VA_ARGS__); }
VIA("twice", ViaTwice, wrapped);
VIA("pipe", ViaPipe, wrapped);
VIA("serialize", ViaSerialization, wrapped);
VIA("2ndpic", ViaSecondPicture, wrapped);
VIA("sp", ViaSingletonPictures, wrapped);
VIA("tiles", ViaTiles, 256, 256, nullptr, wrapped);
VIA("tiles_rt", ViaTiles, 256, 256, new SkRTreeFactory, wrapped);
if (FLAGS_matrix.count() == 4) {
SkMatrix m;
m.reset();
m.setScaleX((SkScalar)atof(FLAGS_matrix[0]));
m.setSkewX ((SkScalar)atof(FLAGS_matrix[1]));
m.setSkewY ((SkScalar)atof(FLAGS_matrix[2]));
m.setScaleY((SkScalar)atof(FLAGS_matrix[3]));
VIA("matrix", ViaMatrix, m, wrapped);
VIA("upright", ViaUpright, m, wrapped);
}
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
VIA("androidsdk", ViaAndroidSDK, wrapped);
#endif
#undef VIA
return nullptr;
}
bool Surface::paint(SkCanvas* canvas)
{
if (singleLayer()) {
getFirstLayer()->contentDraw(canvas, Layer::UnmergedLayers);
// TODO: double buffer by disabling SurfaceCollection swaps and position
// updates until painting complete
// In single surface mode, draw layer content onto the base layer
if (isBase()
&& getFirstLayer()->countChildren()
&& getFirstLayer()->state()->isSingleSurfaceRenderingMode()) {
for (int i = 0; i < getFirstLayer()->countChildren(); i++)
getFirstLayer()->getChild(i)->drawCanvas(canvas, true, Layer::FlattenedLayers);
}
} else {
SkAutoCanvasRestore acr(canvas, true);
SkMatrix matrix;
GLUtils::toSkMatrix(matrix, m_drawTransform);
SkMatrix inverse;
inverse.reset();
matrix.invert(&inverse);
SkMatrix canvasMatrix = canvas->getTotalMatrix();
inverse.postConcat(canvasMatrix);
canvas->setMatrix(inverse);
for (unsigned int i=0; i<m_layers.size(); i++)
m_layers[i]->drawCanvas(canvas, false, Layer::MergedLayers);
}
return true;
}
virtual SkScalar next(SkPath* dst, SkScalar distance, SkPathMeasure& )
{
fMaker->setExtraPropertyCallBack(fDraw->fType, GetDistance, &distance);
SkDrawPath* drawPath = NULL;
if (fDraw->addPath->isPath()) {
drawPath = (SkDrawPath*) fDraw->addPath;
} else {
SkApply* apply = (SkApply*) fDraw->addPath;
apply->refresh(*fMaker);
apply->activate(*fMaker);
apply->interpolate(*fMaker, SkScalarMulRound(distance, 1000));
drawPath = (SkDrawPath*) apply->getScope();
}
SkMatrix m;
m.reset();
if (fDraw->addMatrix) {
SkDrawMatrix* matrix;
if (fDraw->addMatrix->getType() == SkType_Matrix)
matrix = (SkDrawMatrix*) fDraw->addMatrix;
else {
SkApply* apply = (SkApply*) fDraw->addMatrix;
apply->refresh(*fMaker);
apply->activate(*fMaker);
apply->interpolate(*fMaker, SkScalarMulRound(distance, 1000));
matrix = (SkDrawMatrix*) apply->getScope();
}
}
SkScalar result = 0;
SkAnimatorScript::EvaluateFloat(*fMaker, NULL, fDraw->spacing.c_str(), &result);
if (drawPath)
dst->addPath(drawPath->getPath(), m);
fMaker->clearExtraPropertyCallBack(fDraw->fType);
return result;
}
static void test_transform(skiatest::Reporter* reporter) {
SkPath p, p1;
static const SkPoint pts[] = {
{ 0, 0 },
{ SkIntToScalar(10), SkIntToScalar(10) },
{ SkIntToScalar(20), SkIntToScalar(10) }, { SkIntToScalar(20), 0 },
{ 0, 0 }, { 0, SkIntToScalar(10) }, { SkIntToScalar(1), SkIntToScalar(10) }
};
p.moveTo(pts[0]);
p.lineTo(pts[1]);
p.quadTo(pts[2], pts[3]);
p.cubicTo(pts[4], pts[5], pts[6]);
SkMatrix matrix;
matrix.reset();
p.transform(matrix, &p1);
REPORTER_ASSERT(reporter, p == p1);
matrix.setScale(SK_Scalar1 * 2, SK_Scalar1 * 3);
p.transform(matrix, &p1);
SkPoint pts1[7];
int count = p1.getPoints(pts1, 7);
REPORTER_ASSERT(reporter, 7 == count);
for (int i = 0; i < count; ++i) {
SkPoint newPt = SkPoint::Make(pts[i].fX * 2, pts[i].fY * 3);
REPORTER_ASSERT(reporter, newPt == pts1[i]);
}
}
static SkMatrix TestMatrix() {
SkMatrix matrix;
matrix.reset();
matrix.setScale(SkIntToScalar(2), SkIntToScalar(3));
return matrix;
}
virtual void onDraw(SkCanvas* canvas) {
this->makePath();
// do perspective drawPaint as the background;
SkPaint bkgnrd;
SkPoint center = SkPoint::Make(SkIntToScalar(100),
SkIntToScalar(100));
SkColor colors[] = {SK_ColorBLACK, SK_ColorCYAN,
SK_ColorYELLOW, SK_ColorWHITE};
SkScalar pos[] = {0, SK_ScalarHalf / 2,
3 * SK_ScalarHalf / 2, SK_Scalar1};
SkShader* s = SkGradientShader::CreateRadial(center,
SkIntToScalar(1000),
colors,
pos,
SK_ARRAY_COUNT(colors),
SkShader::kClamp_TileMode);
bkgnrd.setShader(s)->unref();
canvas->save();
canvas->translate(SkIntToScalar(100), SkIntToScalar(100));
SkMatrix mat;
mat.reset();
mat.setPerspY(SkScalarToPersp(SK_Scalar1 / 1000));
canvas->concat(mat);
canvas->drawPaint(bkgnrd);
canvas->restore();
// draw the paths in perspective
SkMatrix persp;
persp.reset();
persp.setPerspX(SkScalarToPersp(-SK_Scalar1 / 1800));
persp.setPerspY(SkScalarToPersp(SK_Scalar1 / 500));
canvas->concat(persp);
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
const SkScalar scale = SkIntToScalar(5)/4;
showFour(canvas, SK_Scalar1, false);
canvas->translate(SkIntToScalar(450), 0);
showFour(canvas, scale, false);
canvas->translate(SkIntToScalar(-450), SkIntToScalar(450));
showFour(canvas, SK_Scalar1, true);
canvas->translate(SkIntToScalar(450), 0);
showFour(canvas, scale, true);
}
void TransparencyWin::compositeOpaqueComposite()
{
if (!m_validLayer)
return;
SkCanvas* destCanvas = canvasForContext(*m_destContext);
destCanvas->save();
SkBitmap* bitmap = const_cast<SkBitmap*>(
&bitmapForContext(*m_layerBuffer->context()));
// This function will be called for WhiteLayer as well, which we don't want
// to change.
if (m_layerMode == OpaqueCompositeLayer) {
// Fix up our bitmap, making it contain only the pixels which changed
// and transparent everywhere else.
SkAutoLockPixels sourceLock(*m_referenceBitmap);
SkAutoLockPixels lock(*bitmap);
for (int y = 0; y < bitmap->height(); y++) {
uint32_t* source = m_referenceBitmap->getAddr32(0, y);
uint32_t* dest = bitmap->getAddr32(0, y);
for (int x = 0; x < bitmap->width(); x++) {
// Clear out any pixels that were untouched.
if (dest[x] == source[x])
dest[x] = 0;
else
dest[x] |= (0xFF << SK_A32_SHIFT);
}
}
} else
makeLayerOpaque();
SkRect destRect;
if (m_transformMode != Untransform) {
// We want to use Untransformed space.
//
// Note that we DON'T call m_layerBuffer->image() here. This actually
// makes a copy of the image, which is unnecessary and slow. Instead, we
// just draw the image from inside the destination context.
SkMatrix identity;
identity.reset();
destCanvas->setMatrix(identity);
destRect.set(m_transformedSourceRect.x(), m_transformedSourceRect.y(), m_transformedSourceRect.maxX(), m_transformedSourceRect.maxY());
} else
destRect.set(m_sourceRect.x(), m_sourceRect.y(), m_sourceRect.maxX(), m_sourceRect.maxY());
SkPaint paint;
paint.setFilterBitmap(true);
paint.setAntiAlias(true);
// Note that we need to specify the source layer subset, since the bitmap
// may have been cached and it could be larger than what we're using.
SkIRect sourceRect = { 0, 0, m_layerSize.width(), m_layerSize.height() };
destCanvas->drawBitmapRect(*bitmap, &sourceRect, destRect, &paint);
destCanvas->restore();
}
void SkPictureRecord::dumpMatrices() {
int count = fMatrices.count();
SkMatrix defaultMatrix;
defaultMatrix.reset();
for (int index = 0; index < count; index++) {
const SkFlatMatrix* flatMatrix = fMatrices[index];
flatMatrix->dump();
}
}
static jlong create(JNIEnv* env, jobject clazz, jlong srcHandle) {
const SkMatrix* src = reinterpret_cast<SkMatrix*>(srcHandle);
SkMatrix* obj = new SkMatrix();
if (src)
*obj = *src;
else
obj->reset();
return reinterpret_cast<jlong>(obj);
}
void SkGpuDevice::drawTextureProducer(GrTextureProducer* producer,
const SkRect* srcRect,
const SkRect* dstRect,
SkCanvas::SrcRectConstraint constraint,
const SkMatrix& viewMatrix,
const GrClip& clip,
const SkPaint& paint) {
// This is the funnel for all non-tiled bitmap/image draw calls. Log a histogram entry.
SK_HISTOGRAM_BOOLEAN("DrawTiled", false);
// Figure out the actual dst and src rect by clipping the src rect to the bounds of the
// adjuster. If the src rect is clipped then the dst rect must be recomputed. Also determine
// the matrix that maps the src rect to the dst rect.
SkRect clippedSrcRect;
SkRect clippedDstRect;
const SkRect srcBounds = SkRect::MakeIWH(producer->width(), producer->height());
SkMatrix srcToDstMatrix;
if (srcRect) {
if (!dstRect) {
dstRect = &srcBounds;
}
if (!srcBounds.contains(*srcRect)) {
clippedSrcRect = *srcRect;
if (!clippedSrcRect.intersect(srcBounds)) {
return;
}
if (!srcToDstMatrix.setRectToRect(*srcRect, *dstRect, SkMatrix::kFill_ScaleToFit)) {
return;
}
srcToDstMatrix.mapRect(&clippedDstRect, clippedSrcRect);
} else {
clippedSrcRect = *srcRect;
clippedDstRect = *dstRect;
if (!srcToDstMatrix.setRectToRect(*srcRect, *dstRect, SkMatrix::kFill_ScaleToFit)) {
return;
}
}
} else {
clippedSrcRect = srcBounds;
if (dstRect) {
clippedDstRect = *dstRect;
if (!srcToDstMatrix.setRectToRect(srcBounds, *dstRect, SkMatrix::kFill_ScaleToFit)) {
return;
}
} else {
clippedDstRect = srcBounds;
srcToDstMatrix.reset();
}
}
// Now that we have both the view and srcToDst matrices, log our scale factor.
LogDrawScaleFactor(SkMatrix::Concat(viewMatrix, srcToDstMatrix), paint.getFilterQuality());
this->drawTextureProducerImpl(producer, clippedSrcRect, clippedDstRect, constraint, viewMatrix,
srcToDstMatrix, clip, paint);
}
void SkGpuDevice::drawTexture(GrTexture* tex, const SkRect& dst, const SkPaint& paint) {
GrPaint grPaint;
SkMatrix mat;
mat.reset();
if (!SkPaintToGrPaint(this->context(), paint, mat,
this->surfaceProps().isGammaCorrect(), &grPaint)) {
return;
}
SkMatrix textureMat;
textureMat.reset();
textureMat[SkMatrix::kMScaleX] = 1.0f/dst.width();
textureMat[SkMatrix::kMScaleY] = 1.0f/dst.height();
textureMat[SkMatrix::kMTransX] = -dst.fLeft/dst.width();
textureMat[SkMatrix::kMTransY] = -dst.fTop/dst.height();
grPaint.addColorTextureProcessor(tex, textureMat);
fDrawContext->drawRect(GrNoClip(), grPaint, mat, dst);
}
void onOnceBeforeDraw() override {
draw_color_bm(&fColorBitmap, squareLength);
draw_alpha8_bm(&fAlpha8Bitmap, squareLength);
SkMatrix s;
s.reset();
fColorBitmapShader = SkShader::MakeBitmapShader(fColorBitmap, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &s);
fAlpha8BitmapShader = SkShader::MakeBitmapShader(fAlpha8Bitmap, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &s);
fLinearGradientShader = make_linear_gradient_shader(squareLength);
}
Int64 Matrix::NativeCreate(
/* [in] */ Int64 nSrc)
{
const SkMatrix* src = reinterpret_cast<SkMatrix*>(nSrc);
SkMatrix* obj = new SkMatrix();
if (src)
*obj = *src;
else
obj->reset();
return reinterpret_cast<Int64>(obj);
}
SkMatrix View::currentTransformMatrix(View* ancestor)
{
SkMatrix m;
m.reset();
View* v = this;
while (v && v != ancestor) {
m.postConcat(v->matrix());
v = v->m_parent;
}
return m;
}
ComposeShaderBitmapGM() {
draw_color_bm(&fColorBitmap, squareLength);
draw_alpha8_bm(&fAlpha8Bitmap, squareLength);
SkMatrix s;
s.reset();
fColorBitmapShader = new SkBitmapProcShader(fColorBitmap, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &s);
fAlpha8BitmapShader = new SkBitmapProcShader(fAlpha8Bitmap, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &s);
fLinearGradientShader = make_linear_gradient_shader(squareLength);
}
static void test_decompScale(skiatest::Reporter* reporter) {
SkMatrix m;
m.reset();
REPORTER_ASSERT(reporter, check_decompScale(m));
m.setScale(2, 3);
REPORTER_ASSERT(reporter, check_decompScale(m));
m.setRotate(35, 0, 0);
REPORTER_ASSERT(reporter, check_decompScale(m));
m.setScale(1, 0);
REPORTER_ASSERT(reporter, !check_decompScale(m));
}
void SkPDFDevice::drawPaint(const SkDraw& d, const SkPaint& paint) {
SkMatrix identityTransform;
identityTransform.reset();
SkMatrix curTransform = setTransform(identityTransform);
SkPaint newPaint = paint;
newPaint.setStyle(SkPaint::kFill_Style);
updateGSFromPaint(newPaint, false);
SkRect all = SkRect::MakeWH(SkIntToScalar(this->width()),
SkIntToScalar(this->height()));
drawRect(d, all, newPaint);
setTransform(curTransform);
}
SkMatrix44::operator SkMatrix() const {
SkMatrix dst;
dst.reset(); // setup our perspective correctly for identity
dst[SkMatrix::kMScaleX] = SkMScalarToFloat(fMat[0][0]);
dst[SkMatrix::kMSkewX] = SkMScalarToFloat(fMat[1][0]);
dst[SkMatrix::kMTransX] = SkMScalarToFloat(fMat[3][0]);
dst[SkMatrix::kMSkewY] = SkMScalarToFloat(fMat[0][1]);
dst[SkMatrix::kMScaleY] = SkMScalarToFloat(fMat[1][1]);
dst[SkMatrix::kMTransY] = SkMScalarToFloat(fMat[3][1]);
return dst;
}
// asserts if halfway case is not handled
static void test_halfway() {
SkPaint paint;
SkPath path;
path.moveTo(16365.5f, 1394);
path.lineTo(16365.5f, 1387.5f);
path.quadTo(16365.5f, 1385.43f, 16367, 1383.96f);
path.quadTo(16368.4f, 1382.5f, 16370.5f, 1382.5f);
path.lineTo(16465.5f, 1382.5f);
path.quadTo(16467.6f, 1382.5f, 16469, 1383.96f);
path.quadTo(16470.5f, 1385.43f, 16470.5f, 1387.5f);
path.lineTo(16470.5f, 1394);
path.quadTo(16470.5f, 1396.07f, 16469, 1397.54f);
path.quadTo(16467.6f, 1399, 16465.5f, 1399);
path.lineTo(16370.5f, 1399);
path.quadTo(16368.4f, 1399, 16367, 1397.54f);
path.quadTo(16365.5f, 1396.07f, 16365.5f, 1394);
path.close();
SkPath p2;
SkMatrix m;
m.reset();
m.postTranslate(0.001f, 0.001f);
path.transform(m, &p2);
auto surface(SkSurface::MakeRasterN32Premul(640, 480));
SkCanvas* canvas = surface->getCanvas();
canvas->translate(-16366, -1383);
canvas->drawPath(p2, paint);
m.reset();
m.postTranslate(-0.001f, -0.001f);
path.transform(m, &p2);
canvas->drawPath(p2, paint);
m.reset();
path.transform(m, &p2);
canvas->drawPath(p2, paint);
}
void Matrix4::copyTo(SkMatrix& v) const {
v.reset();
v.set(SkMatrix::kMScaleX, data[kScaleX]);
v.set(SkMatrix::kMSkewX, data[kSkewX]);
v.set(SkMatrix::kMTransX, data[kTranslateX]);
v.set(SkMatrix::kMSkewY, data[kSkewY]);
v.set(SkMatrix::kMScaleY, data[kScaleY]);
v.set(SkMatrix::kMTransY, data[kTranslateY]);
v.set(SkMatrix::kMPersp0, data[kPerspective0]);
v.set(SkMatrix::kMPersp1, data[kPerspective1]);
v.set(SkMatrix::kMPersp2, data[kPerspective2]);
}
static int scaledDrawTheSame(const SkPath& one, const SkPath& two,
int a, int b, bool drawPaths, SkBitmap& bitmap, SkCanvas* canvas) {
SkMatrix scale;
scale.reset();
float aScale = 1.21f;
float bScale = 1.11f;
scale.preScale(a * aScale, b * bScale);
SkPath scaledOne, scaledTwo;
one.transform(scale, &scaledOne);
two.transform(scale, &scaledTwo);
int errors = pathsDrawTheSame(scaledOne, scaledTwo, bitmap, canvas);
if (errors == 0) {
return 0;
}
while (!drawAsciiPaths(scaledOne, scaledTwo, drawPaths)) {
scale.reset();
aScale *= 0.5f;
bScale *= 0.5f;
scale.preScale(a * aScale, b * bScale);
one.transform(scale, &scaledOne);
two.transform(scale, &scaledTwo);
}
return errors;
}
void onOnceBeforeDraw() override {
fPath.moveTo(69.7030518991886f, 0);
fPath.cubicTo( 69.7030518991886f, 21.831149999999997f,
58.08369508178456f, 43.66448333333333f, 34.8449814469765f, 65.5f);
fPath.cubicTo( 11.608591683531916f, 87.33115f, -0.010765133872116195f, 109.16448333333332f,
-0.013089005235602302f, 131);
fPath.close();
fFlipped = fPath;
SkMatrix matrix;
matrix.reset();
matrix.setScaleX(0);
matrix.setScaleY(0);
matrix.setSkewX(1);
matrix.setSkewY(1);
fFlipped.transform(matrix);
}
static void scaleMatrix(const SkPath& one, const SkPath& two, SkMatrix& scale) {
SkRect larger = one.getBounds();
larger.join(two.getBounds());
SkScalar largerWidth = larger.width();
if (largerWidth < 4) {
largerWidth = 4;
}
SkScalar largerHeight = larger.height();
if (largerHeight < 4) {
largerHeight = 4;
}
SkScalar hScale = (bitWidth - 2) / largerWidth;
SkScalar vScale = (bitHeight - 2) / largerHeight;
scale.reset();
scale.preScale(hScale, vScale);
}
static void DrawRoundRect() {
#ifdef SK_SCALAR_IS_FIXED
bool ret = false;
SkPaint paint;
SkBitmap bitmap;
SkCanvas canvas;
SkMatrix matrix;
matrix.reset();
bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1370, 812);
bitmap.allocPixels();
canvas.setBitmapDevice(bitmap);
// set up clipper
SkRect skclip;
skclip.set(SkIntToFixed(284), SkIntToFixed(40), SkIntToFixed(1370), SkIntToFixed(708));
ret = canvas.clipRect(skclip);
SkASSERT(ret);
matrix.set(SkMatrix::kMTransX, SkFloatToFixed(-1153.28));
matrix.set(SkMatrix::kMTransY, SkFloatToFixed(1180.50));
matrix.set(SkMatrix::kMScaleX, SkFloatToFixed(0.177171));
matrix.set(SkMatrix::kMScaleY, SkFloatToFixed(0.177043));
matrix.set(SkMatrix::kMSkewX, SkFloatToFixed(0.126968));
matrix.set(SkMatrix::kMSkewY, SkFloatToFixed(-0.126876));
matrix.set(SkMatrix::kMPersp0, SkFloatToFixed(0.0));
matrix.set(SkMatrix::kMPersp1, SkFloatToFixed(0.0));
ret = canvas.concat(matrix);
paint.setAntiAlias(true);
paint.setColor(0xb2202020);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SkFloatToFixed(68.13));
SkRect r;
r.set(SkFloatToFixed(-313.714417), SkFloatToFixed(-4.826389), SkFloatToFixed(18014.447266), SkFloatToFixed(1858.154541));
canvas.drawRoundRect(r, SkFloatToFixed(91.756363), SkFloatToFixed(91.756363), paint);
#endif
}
static void DrawRoundRect(SkCanvas& canvas) {
bool ret = false;
SkPaint paint;
SkBitmap bitmap;
SkMatrix matrix;
matrix.reset();
bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1370, 812);
bitmap.allocPixels();
#if 0
SkCanvas canvas;
canvas.setBitmapDevice(bitmap);
#endif
// set up clipper
SkRect skclip;
skclip.set(SkIntToScalar(284), SkIntToScalar(40), SkIntToScalar(1370), SkIntToScalar(708));
// ret = canvas.clipRect(skclip);
// SkASSERT(ret);
matrix.set(SkMatrix::kMTransX, SkFloatToScalar(-1153.28f));
matrix.set(SkMatrix::kMTransY, SkFloatToScalar(1180.50f));
matrix.set(SkMatrix::kMScaleX, SkFloatToScalar(0.177171f));
matrix.set(SkMatrix::kMScaleY, SkFloatToScalar(0.177043f));
matrix.set(SkMatrix::kMSkewX, SkFloatToScalar(0.126968f));
matrix.set(SkMatrix::kMSkewY, SkFloatToScalar(-0.126876f));
matrix.set(SkMatrix::kMPersp0, SkFloatToScalar(0.0f));
matrix.set(SkMatrix::kMPersp1, SkFloatToScalar(0.0f));
ret = canvas.concat(matrix);
paint.setAntiAlias(true);
paint.setColor(0xb2202020);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SkFloatToScalar(68.13f));
SkRect r;
r.set(SkFloatToScalar(-313.714417f), SkFloatToScalar(-4.826389f), SkFloatToScalar(18014.447266f), SkFloatToScalar(1858.154541f));
canvas.drawRoundRect(r, SkFloatToScalar(91.756363f), SkFloatToScalar(91.756363f), paint);
}
