| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "VectorDrawable.h" |
| |
| #include "PathParser.h" |
| #include "SkImageInfo.h" |
| #include <utils/Log.h> |
| #include "utils/Macros.h" |
| #include "utils/VectorDrawableUtils.h" |
| |
| #include <math.h> |
| #include <string.h> |
| |
| namespace android { |
| namespace uirenderer { |
| namespace VectorDrawable { |
| |
| const int Tree::MAX_CACHED_BITMAP_SIZE = 2048; |
| |
| void Path::draw(SkCanvas* outCanvas, const SkMatrix& groupStackedMatrix, float scaleX, float scaleY) { |
| float matrixScale = getMatrixScale(groupStackedMatrix); |
| if (matrixScale == 0) { |
| // When either x or y is scaled to 0, we don't need to draw anything. |
| return; |
| } |
| |
| const SkPath updatedPath = getUpdatedPath(); |
| SkMatrix pathMatrix(groupStackedMatrix); |
| pathMatrix.postScale(scaleX, scaleY); |
| |
| //TODO: try apply the path matrix to the canvas instead of creating a new path. |
| SkPath renderPath; |
| renderPath.reset(); |
| renderPath.addPath(updatedPath, pathMatrix); |
| |
| float minScale = fmin(scaleX, scaleY); |
| float strokeScale = minScale * matrixScale; |
| drawPath(outCanvas, renderPath, strokeScale); |
| } |
| |
| void Path::setPathData(const Data& data) { |
| if (mData == data) { |
| return; |
| } |
| // Updates the path data. Note that we don't generate a new Skia path right away |
| // because there are cases where the animation is changing the path data, but the view |
| // that hosts the VD has gone off screen, in which case we won't even draw. So we |
| // postpone the Skia path generation to the draw time. |
| mData = data; |
| mSkPathDirty = true; |
| } |
| |
| void Path::dump() { |
| ALOGD("Path: %s has %zu points", mName.c_str(), mData.points.size()); |
| } |
| |
| float Path::getMatrixScale(const SkMatrix& groupStackedMatrix) { |
| // Given unit vectors A = (0, 1) and B = (1, 0). |
| // After matrix mapping, we got A' and B'. Let theta = the angel b/t A' and B'. |
| // Therefore, the final scale we want is min(|A'| * sin(theta), |B'| * sin(theta)), |
| // which is (|A'| * |B'| * sin(theta)) / max (|A'|, |B'|); |
| // If max (|A'|, |B'|) = 0, that means either x or y has a scale of 0. |
| // |
| // For non-skew case, which is most of the cases, matrix scale is computing exactly the |
| // scale on x and y axis, and take the minimal of these two. |
| // For skew case, an unit square will mapped to a parallelogram. And this function will |
| // return the minimal height of the 2 bases. |
| SkVector skVectors[2]; |
| skVectors[0].set(0, 1); |
| skVectors[1].set(1, 0); |
| groupStackedMatrix.mapVectors(skVectors, 2); |
| float scaleX = hypotf(skVectors[0].fX, skVectors[0].fY); |
| float scaleY = hypotf(skVectors[1].fX, skVectors[1].fY); |
| float crossProduct = skVectors[0].cross(skVectors[1]); |
| float maxScale = fmax(scaleX, scaleY); |
| |
| float matrixScale = 0; |
| if (maxScale > 0) { |
| matrixScale = fabs(crossProduct) / maxScale; |
| } |
| return matrixScale; |
| } |
| Path::Path(const char* pathStr, size_t strLength) { |
| PathParser::ParseResult result; |
| PathParser::getPathDataFromString(&mData, &result, pathStr, strLength); |
| if (!result.failureOccurred) { |
| VectorDrawableUtils::verbsToPath(&mSkPath, mData); |
| } |
| } |
| |
| Path::Path(const Data& data) { |
| mData = data; |
| // Now we need to construct a path |
| VectorDrawableUtils::verbsToPath(&mSkPath, data); |
| } |
| |
| Path::Path(const Path& path) : Node(path) { |
| mData = path.mData; |
| VectorDrawableUtils::verbsToPath(&mSkPath, mData); |
| } |
| |
| bool Path::canMorph(const Data& morphTo) { |
| return VectorDrawableUtils::canMorph(mData, morphTo); |
| } |
| |
| bool Path::canMorph(const Path& path) { |
| return canMorph(path.mData); |
| } |
| |
| const SkPath& Path::getUpdatedPath() { |
| if (mSkPathDirty) { |
| mSkPath.reset(); |
| VectorDrawableUtils::verbsToPath(&mSkPath, mData); |
| mSkPathDirty = false; |
| } |
| return mSkPath; |
| } |
| |
| void Path::setPath(const char* pathStr, size_t strLength) { |
| PathParser::ParseResult result; |
| mSkPathDirty = true; |
| PathParser::getPathDataFromString(&mData, &result, pathStr, strLength); |
| } |
| |
| FullPath::FullPath(const FullPath& path) : Path(path) { |
| mStrokeWidth = path.mStrokeWidth; |
| mStrokeColor = path.mStrokeColor; |
| mStrokeAlpha = path.mStrokeAlpha; |
| mFillColor = path.mFillColor; |
| mFillAlpha = path.mFillAlpha; |
| mTrimPathStart = path.mTrimPathStart; |
| mTrimPathEnd = path.mTrimPathEnd; |
| mTrimPathOffset = path.mTrimPathOffset; |
| mStrokeMiterLimit = path.mStrokeMiterLimit; |
| mStrokeLineCap = path.mStrokeLineCap; |
| mStrokeLineJoin = path.mStrokeLineJoin; |
| } |
| |
| const SkPath& FullPath::getUpdatedPath() { |
| if (!mSkPathDirty && !mTrimDirty) { |
| return mTrimmedSkPath; |
| } |
| Path::getUpdatedPath(); |
| if (mTrimPathStart != 0.0f || mTrimPathEnd != 1.0f) { |
| applyTrim(); |
| return mTrimmedSkPath; |
| } else { |
| return mSkPath; |
| } |
| } |
| |
| void FullPath::updateProperties(float strokeWidth, SkColor strokeColor, float strokeAlpha, |
| SkColor fillColor, float fillAlpha, float trimPathStart, float trimPathEnd, |
| float trimPathOffset, float strokeMiterLimit, int strokeLineCap, int strokeLineJoin) { |
| mStrokeWidth = strokeWidth; |
| mStrokeColor = strokeColor; |
| mStrokeAlpha = strokeAlpha; |
| mFillColor = fillColor; |
| mFillAlpha = fillAlpha; |
| mStrokeMiterLimit = strokeMiterLimit; |
| mStrokeLineCap = SkPaint::Cap(strokeLineCap); |
| mStrokeLineJoin = SkPaint::Join(strokeLineJoin); |
| |
| // If any trim property changes, mark trim dirty and update the trim path |
| setTrimPathStart(trimPathStart); |
| setTrimPathEnd(trimPathEnd); |
| setTrimPathOffset(trimPathOffset); |
| } |
| |
| inline SkColor applyAlpha(SkColor color, float alpha) { |
| int alphaBytes = SkColorGetA(color); |
| return SkColorSetA(color, alphaBytes * alpha); |
| } |
| |
| void FullPath::drawPath(SkCanvas* outCanvas, const SkPath& renderPath, float strokeScale){ |
| // Draw path's fill, if fill color isn't transparent. |
| if (mFillColor != SK_ColorTRANSPARENT) { |
| mPaint.setStyle(SkPaint::Style::kFill_Style); |
| mPaint.setAntiAlias(true); |
| mPaint.setColor(applyAlpha(mFillColor, mFillAlpha)); |
| outCanvas->drawPath(renderPath, mPaint); |
| } |
| // Draw path's stroke, if stroke color isn't transparent |
| if (mStrokeColor != SK_ColorTRANSPARENT) { |
| mPaint.setStyle(SkPaint::Style::kStroke_Style); |
| mPaint.setAntiAlias(true); |
| mPaint.setStrokeJoin(mStrokeLineJoin); |
| mPaint.setStrokeCap(mStrokeLineCap); |
| mPaint.setStrokeMiter(mStrokeMiterLimit); |
| mPaint.setColor(applyAlpha(mStrokeColor, mStrokeAlpha)); |
| mPaint.setStrokeWidth(mStrokeWidth * strokeScale); |
| outCanvas->drawPath(renderPath, mPaint); |
| } |
| } |
| |
| /** |
| * Applies trimming to the specified path. |
| */ |
| void FullPath::applyTrim() { |
| if (mTrimPathStart == 0.0f && mTrimPathEnd == 1.0f) { |
| // No trimming necessary. |
| return; |
| } |
| SkPathMeasure measure(mSkPath, false); |
| float len = SkScalarToFloat(measure.getLength()); |
| float start = len * fmod((mTrimPathStart + mTrimPathOffset), 1.0f); |
| float end = len * fmod((mTrimPathEnd + mTrimPathOffset), 1.0f); |
| |
| mTrimmedSkPath.reset(); |
| if (start > end) { |
| measure.getSegment(start, len, &mTrimmedSkPath, true); |
| measure.getSegment(0, end, &mTrimmedSkPath, true); |
| } else { |
| measure.getSegment(start, end, &mTrimmedSkPath, true); |
| } |
| mTrimDirty = false; |
| } |
| |
| inline int putData(int8_t* outBytes, int startIndex, float value) { |
| int size = sizeof(float); |
| memcpy(&outBytes[startIndex], &value, size); |
| return size; |
| } |
| |
| inline int putData(int8_t* outBytes, int startIndex, int value) { |
| int size = sizeof(int); |
| memcpy(&outBytes[startIndex], &value, size); |
| return size; |
| } |
| |
| struct FullPathProperties { |
| // TODO: Consider storing full path properties in this struct instead of the fields. |
| float strokeWidth; |
| SkColor strokeColor; |
| float strokeAlpha; |
| SkColor fillColor; |
| float fillAlpha; |
| float trimPathStart; |
| float trimPathEnd; |
| float trimPathOffset; |
| int32_t strokeLineCap; |
| int32_t strokeLineJoin; |
| float strokeMiterLimit; |
| }; |
| |
| REQUIRE_COMPATIBLE_LAYOUT(FullPathProperties); |
| |
| static_assert(sizeof(float) == sizeof(int32_t), "float is not the same size as int32_t"); |
| static_assert(sizeof(SkColor) == sizeof(int32_t), "SkColor is not the same size as int32_t"); |
| |
| bool FullPath::getProperties(int8_t* outProperties, int length) { |
| int propertyDataSize = sizeof(FullPathProperties); |
| if (length != propertyDataSize) { |
| LOG_ALWAYS_FATAL("Properties needs exactly %d bytes, a byte array of size %d is provided", |
| propertyDataSize, length); |
| return false; |
| } |
| // TODO: consider replacing the property fields with a FullPathProperties struct. |
| FullPathProperties properties; |
| properties.strokeWidth = mStrokeWidth; |
| properties.strokeColor = mStrokeColor; |
| properties.strokeAlpha = mStrokeAlpha; |
| properties.fillColor = mFillColor; |
| properties.fillAlpha = mFillAlpha; |
| properties.trimPathStart = mTrimPathStart; |
| properties.trimPathEnd = mTrimPathEnd; |
| properties.trimPathOffset = mTrimPathOffset; |
| properties.strokeLineCap = mStrokeLineCap; |
| properties.strokeLineJoin = mStrokeLineJoin; |
| properties.strokeMiterLimit = mStrokeMiterLimit; |
| |
| memcpy(outProperties, &properties, length); |
| return true; |
| } |
| |
| void ClipPath::drawPath(SkCanvas* outCanvas, const SkPath& renderPath, |
| float strokeScale){ |
| outCanvas->clipPath(renderPath, SkRegion::kIntersect_Op); |
| } |
| |
| Group::Group(const Group& group) : Node(group) { |
| mRotate = group.mRotate; |
| mPivotX = group.mPivotX; |
| mPivotY = group.mPivotY; |
| mScaleX = group.mScaleX; |
| mScaleY = group.mScaleY; |
| mTranslateX = group.mTranslateX; |
| mTranslateY = group.mTranslateY; |
| } |
| |
| void Group::draw(SkCanvas* outCanvas, const SkMatrix& currentMatrix, float scaleX, |
| float scaleY) { |
| // TODO: Try apply the matrix to the canvas instead of passing it down the tree |
| |
| // Calculate current group's matrix by preConcat the parent's and |
| // and the current one on the top of the stack. |
| // Basically the Mfinal = Mviewport * M0 * M1 * M2; |
| // Mi the local matrix at level i of the group tree. |
| SkMatrix stackedMatrix; |
| getLocalMatrix(&stackedMatrix); |
| stackedMatrix.postConcat(currentMatrix); |
| |
| // Save the current clip information, which is local to this group. |
| outCanvas->save(); |
| // Draw the group tree in the same order as the XML file. |
| for (Node* child : mChildren) { |
| child->draw(outCanvas, stackedMatrix, scaleX, scaleY); |
| } |
| // Restore the previous clip information. |
| outCanvas->restore(); |
| } |
| |
| void Group::dump() { |
| ALOGD("Group %s has %zu children: ", mName.c_str(), mChildren.size()); |
| for (size_t i = 0; i < mChildren.size(); i++) { |
| mChildren[i]->dump(); |
| } |
| } |
| |
| void Group::updateLocalMatrix(float rotate, float pivotX, float pivotY, |
| float scaleX, float scaleY, float translateX, float translateY) { |
| setRotation(rotate); |
| setPivotX(pivotX); |
| setPivotY(pivotY); |
| setScaleX(scaleX); |
| setScaleY(scaleY); |
| setTranslateX(translateX); |
| setTranslateY(translateY); |
| } |
| |
| void Group::getLocalMatrix(SkMatrix* outMatrix) { |
| outMatrix->reset(); |
| // TODO: use rotate(mRotate, mPivotX, mPivotY) and scale with pivot point, instead of |
| // translating to pivot for rotating and scaling, then translating back. |
| outMatrix->postTranslate(-mPivotX, -mPivotY); |
| outMatrix->postScale(mScaleX, mScaleY); |
| outMatrix->postRotate(mRotate, 0, 0); |
| outMatrix->postTranslate(mTranslateX + mPivotX, mTranslateY + mPivotY); |
| } |
| |
| void Group::addChild(Node* child) { |
| mChildren.push_back(child); |
| } |
| |
| bool Group::getProperties(float* outProperties, int length) { |
| int propertyCount = static_cast<int>(Property::Count); |
| if (length != propertyCount) { |
| LOG_ALWAYS_FATAL("Properties needs exactly %d bytes, a byte array of size %d is provided", |
| propertyCount, length); |
| return false; |
| } |
| for (int i = 0; i < propertyCount; i++) { |
| Property currentProperty = static_cast<Property>(i); |
| switch (currentProperty) { |
| case Property::Rotate_Property: |
| outProperties[i] = mRotate; |
| break; |
| case Property::PivotX_Property: |
| outProperties[i] = mPivotX; |
| break; |
| case Property::PivotY_Property: |
| outProperties[i] = mPivotY; |
| break; |
| case Property::ScaleX_Property: |
| outProperties[i] = mScaleX; |
| break; |
| case Property::ScaleY_Property: |
| outProperties[i] = mScaleY; |
| break; |
| case Property::TranslateX_Property: |
| outProperties[i] = mTranslateX; |
| break; |
| case Property::TranslateY_Property: |
| outProperties[i] = mTranslateY; |
| break; |
| default: |
| LOG_ALWAYS_FATAL("Invalid input index: %d", i); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void Tree::draw(Canvas* outCanvas, SkColorFilter* colorFilter, |
| const SkRect& bounds, bool needsMirroring, bool canReuseCache) { |
| // The imageView can scale the canvas in different ways, in order to |
| // avoid blurry scaling, we have to draw into a bitmap with exact pixel |
| // size first. This bitmap size is determined by the bounds and the |
| // canvas scale. |
| outCanvas->getMatrix(&mCanvasMatrix); |
| mBounds = bounds; |
| float canvasScaleX = 1.0f; |
| float canvasScaleY = 1.0f; |
| if (mCanvasMatrix.getSkewX() == 0 && mCanvasMatrix.getSkewY() == 0) { |
| // Only use the scale value when there's no skew or rotation in the canvas matrix. |
| // TODO: Add a cts test for drawing VD on a canvas with negative scaling factors. |
| canvasScaleX = fabs(mCanvasMatrix.getScaleX()); |
| canvasScaleY = fabs(mCanvasMatrix.getScaleY()); |
| } |
| int scaledWidth = (int) (mBounds.width() * canvasScaleX); |
| int scaledHeight = (int) (mBounds.height() * canvasScaleY); |
| scaledWidth = std::min(Tree::MAX_CACHED_BITMAP_SIZE, scaledWidth); |
| scaledHeight = std::min(Tree::MAX_CACHED_BITMAP_SIZE, scaledHeight); |
| |
| if (scaledWidth <= 0 || scaledHeight <= 0) { |
| return; |
| } |
| |
| int saveCount = outCanvas->save(SaveFlags::MatrixClip); |
| outCanvas->translate(mBounds.fLeft, mBounds.fTop); |
| |
| // Handle RTL mirroring. |
| if (needsMirroring) { |
| outCanvas->translate(mBounds.width(), 0); |
| outCanvas->scale(-1.0f, 1.0f); |
| } |
| |
| // At this point, canvas has been translated to the right position. |
| // And we use this bound for the destination rect for the drawBitmap, so |
| // we offset to (0, 0); |
| mBounds.offsetTo(0, 0); |
| |
| createCachedBitmapIfNeeded(scaledWidth, scaledHeight); |
| if (!mAllowCaching) { |
| updateCachedBitmap(scaledWidth, scaledHeight); |
| } else { |
| if (!canReuseCache || mCacheDirty) { |
| updateCachedBitmap(scaledWidth, scaledHeight); |
| } |
| } |
| drawCachedBitmapWithRootAlpha(outCanvas, colorFilter, mBounds); |
| |
| outCanvas->restoreToCount(saveCount); |
| } |
| |
| void Tree::drawCachedBitmapWithRootAlpha(Canvas* outCanvas, SkColorFilter* filter, |
| const SkRect& originalBounds) { |
| SkPaint* paint; |
| if (mRootAlpha == 1.0f && filter == NULL) { |
| paint = NULL; |
| } else { |
| mPaint.setFilterQuality(kLow_SkFilterQuality); |
| mPaint.setAlpha(mRootAlpha * 255); |
| mPaint.setColorFilter(filter); |
| paint = &mPaint; |
| } |
| outCanvas->drawBitmap(mCachedBitmap, 0, 0, mCachedBitmap.width(), mCachedBitmap.height(), |
| originalBounds.fLeft, originalBounds.fTop, originalBounds.fRight, |
| originalBounds.fBottom, paint); |
| } |
| |
| void Tree::updateCachedBitmap(int width, int height) { |
| mCachedBitmap.eraseColor(SK_ColorTRANSPARENT); |
| SkCanvas outCanvas(mCachedBitmap); |
| float scaleX = width / mViewportWidth; |
| float scaleY = height / mViewportHeight; |
| mRootNode->draw(&outCanvas, SkMatrix::I(), scaleX, scaleY); |
| mCacheDirty = false; |
| } |
| |
| void Tree::createCachedBitmapIfNeeded(int width, int height) { |
| if (!canReuseBitmap(width, height)) { |
| SkImageInfo info = SkImageInfo::Make(width, height, |
| kN32_SkColorType, kPremul_SkAlphaType); |
| mCachedBitmap.setInfo(info); |
| // TODO: Count the bitmap cache against app's java heap |
| mCachedBitmap.allocPixels(info); |
| mCacheDirty = true; |
| } |
| } |
| |
| bool Tree::canReuseBitmap(int width, int height) { |
| return width == mCachedBitmap.width() && height == mCachedBitmap.height(); |
| } |
| |
| }; // namespace VectorDrawable |
| |
| }; // namespace uirenderer |
| }; // namespace android |