1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you mPrimitiveFields.may not use this file except in compliance with the License.
6  * You mPrimitiveFields.may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "RenderProperties.h"
18 
19 #include <utils/Trace.h>
20 
21 #include <SkColorFilter.h>
22 #include <SkMatrix.h>
23 #include <SkPath.h>
24 #include <SkPathOps.h>
25 
26 #include "Matrix.h"
27 #include "hwui/Canvas.h"
28 #include "utils/MathUtils.h"
29 
30 namespace android {
31 namespace uirenderer {
32 
LayerProperties()33 LayerProperties::LayerProperties() {
34     reset();
35 }
36 
~LayerProperties()37 LayerProperties::~LayerProperties() {
38     setType(LayerType::None);
39 }
40 
reset()41 void LayerProperties::reset() {
42     mOpaque = false;
43     setFromPaint(nullptr);
44 }
45 
setColorFilter(SkColorFilter * filter)46 bool LayerProperties::setColorFilter(SkColorFilter* filter) {
47     if (mColorFilter.get() == filter) return false;
48     mColorFilter = sk_ref_sp(filter);
49     return true;
50 }
51 
setFromPaint(const SkPaint * paint)52 bool LayerProperties::setFromPaint(const SkPaint* paint) {
53     bool changed = false;
54     changed |= setAlpha(static_cast<uint8_t>(PaintUtils::getAlphaDirect(paint)));
55     changed |= setXferMode(PaintUtils::getBlendModeDirect(paint));
56     changed |= setColorFilter(paint ? paint->getColorFilter() : nullptr);
57     return changed;
58 }
59 
operator =(const LayerProperties & other)60 LayerProperties& LayerProperties::operator=(const LayerProperties& other) {
61     setType(other.type());
62     setOpaque(other.opaque());
63     setAlpha(other.alpha());
64     setXferMode(other.xferMode());
65     setColorFilter(other.getColorFilter());
66     return *this;
67 }
68 
ComputedFields()69 RenderProperties::ComputedFields::ComputedFields() : mTransformMatrix(nullptr) {}
70 
~ComputedFields()71 RenderProperties::ComputedFields::~ComputedFields() {
72     delete mTransformMatrix;
73 }
74 
RenderProperties()75 RenderProperties::RenderProperties() : mStaticMatrix(nullptr), mAnimationMatrix(nullptr) {}
76 
~RenderProperties()77 RenderProperties::~RenderProperties() {
78     delete mStaticMatrix;
79     delete mAnimationMatrix;
80 }
81 
operator =(const RenderProperties & other)82 RenderProperties& RenderProperties::operator=(const RenderProperties& other) {
83     if (this != &other) {
84         mPrimitiveFields = other.mPrimitiveFields;
85         setStaticMatrix(other.getStaticMatrix());
86         setAnimationMatrix(other.getAnimationMatrix());
87         setCameraDistance(other.getCameraDistance());
88         mLayerProperties = other.layerProperties();
89 
90         // Force recalculation of the matrix, since other's dirty bit may be clear
91         mPrimitiveFields.mMatrixOrPivotDirty = true;
92         updateMatrix();
93     }
94     return *this;
95 }
96 
dumpMatrix(std::ostream & output,std::string & indent,const char * label,SkMatrix * matrix)97 static void dumpMatrix(std::ostream& output, std::string& indent, const char* label,
98                        SkMatrix* matrix) {
99     if (matrix) {
100         output << indent << "(" << label << " " << matrix << ": ";
101         output << std::fixed << std::setprecision(2);
102         output << "[" << matrix->get(0) << " " << matrix->get(1) << " " << matrix->get(2) << "]";
103         output << " [" << matrix->get(3) << " " << matrix->get(4) << " " << matrix->get(5) << "]";
104         output << " [" << matrix->get(6) << " " << matrix->get(7) << " " << matrix->get(8) << "]";
105         output << ")" << std::endl;
106     }
107 }
108 
debugOutputProperties(std::ostream & output,const int level) const109 void RenderProperties::debugOutputProperties(std::ostream& output, const int level) const {
110     auto indent = std::string(level * 2, ' ');
111     if (mPrimitiveFields.mLeft != 0 || mPrimitiveFields.mTop != 0) {
112         output << indent << "(Translate (left, top) " << mPrimitiveFields.mLeft << ", "
113                << mPrimitiveFields.mTop << ")" << std::endl;
114     }
115     dumpMatrix(output, indent, "ConcatMatrix (static)", mStaticMatrix);
116     dumpMatrix(output, indent, "ConcatMatrix (animation)", mAnimationMatrix);
117 
118     output << std::fixed << std::setprecision(2);
119     if (hasTransformMatrix()) {
120         if (isTransformTranslateOnly()) {
121             output << indent << "(Translate " << getTranslationX() << ", " << getTranslationY()
122                    << ", " << getZ() << ")" << std::endl;
123         } else {
124             dumpMatrix(output, indent, "ConcatMatrix ", mComputedFields.mTransformMatrix);
125         }
126     }
127 
128     const bool isLayer = effectiveLayerType() != LayerType::None;
129     int clipFlags = getClippingFlags();
130     if (mPrimitiveFields.mAlpha < 1 && !MathUtils::isZero(mPrimitiveFields.mAlpha)) {
131         if (isLayer) {
132             clipFlags &= ~CLIP_TO_BOUNDS;  // bounds clipping done by layer
133         }
134 
135         if (CC_LIKELY(isLayer || !getHasOverlappingRendering())) {
136             // simply scale rendering content's alpha
137             output << indent << "(ScaleAlpha " << mPrimitiveFields.mAlpha << ")" << std::endl;
138         } else {
139             // savelayeralpha to create an offscreen buffer to apply alpha
140             Rect layerBounds(0, 0, getWidth(), getHeight());
141             if (clipFlags) {
142                 getClippingRectForFlags(clipFlags, &layerBounds);
143                 clipFlags = 0;  // all clipping done by savelayer
144             }
145             output << indent << "(SaveLayerAlpha " << (int)layerBounds.left << ", "
146                    << (int)layerBounds.top << ", " << (int)layerBounds.right << ", "
147                    << (int)layerBounds.bottom << ", " << (int)(mPrimitiveFields.mAlpha * 255)
148                    << ", 0x" << std::hex << (SaveFlags::HasAlphaLayer | SaveFlags::ClipToLayer)
149                    << ")" << std::dec << std::endl;
150         }
151     }
152 
153     if (clipFlags) {
154         Rect clipRect;
155         getClippingRectForFlags(clipFlags, &clipRect);
156         output << indent << "(ClipRect " << (int)clipRect.left << ", " << (int)clipRect.top << ", "
157                << (int)clipRect.right << ", " << (int)clipRect.bottom << ")" << std::endl;
158     }
159 
160     if (getRevealClip().willClip()) {
161         Rect bounds;
162         getRevealClip().getBounds(&bounds);
163         output << indent << "(Clip to reveal clip with bounds " << bounds.left << ", " << bounds.top
164                << ", " << bounds.right << ", " << bounds.bottom << ")" << std::endl;
165     }
166 
167     auto& outline = mPrimitiveFields.mOutline;
168     if (outline.getShouldClip()) {
169         if (outline.isEmpty()) {
170             output << indent << "(Clip to empty outline)";
171         } else if (outline.willClip()) {
172             const Rect& bounds = outline.getBounds();
173             output << indent << "(Clip to outline with bounds " << bounds.left << ", " << bounds.top
174                    << ", " << bounds.right << ", " << bounds.bottom << ")" << std::endl;
175         }
176     }
177 }
178 
updateMatrix()179 void RenderProperties::updateMatrix() {
180     if (mPrimitiveFields.mMatrixOrPivotDirty) {
181         if (!mComputedFields.mTransformMatrix) {
182             // only allocate a mPrimitiveFields.matrix if we have a complex transform
183             mComputedFields.mTransformMatrix = new SkMatrix();
184         }
185         if (!mPrimitiveFields.mPivotExplicitlySet) {
186             mPrimitiveFields.mPivotX = mPrimitiveFields.mWidth / 2.0f;
187             mPrimitiveFields.mPivotY = mPrimitiveFields.mHeight / 2.0f;
188         }
189         SkMatrix* transform = mComputedFields.mTransformMatrix;
190         transform->reset();
191         if (MathUtils::isZero(getRotationX()) && MathUtils::isZero(getRotationY())) {
192             transform->setTranslate(getTranslationX(), getTranslationY());
193             transform->preRotate(getRotation(), getPivotX(), getPivotY());
194             transform->preScale(getScaleX(), getScaleY(), getPivotX(), getPivotY());
195         } else {
196             SkMatrix transform3D;
197             mComputedFields.mTransformCamera.save();
198             transform->preScale(getScaleX(), getScaleY(), getPivotX(), getPivotY());
199             mComputedFields.mTransformCamera.rotateX(mPrimitiveFields.mRotationX);
200             mComputedFields.mTransformCamera.rotateY(mPrimitiveFields.mRotationY);
201             mComputedFields.mTransformCamera.rotateZ(-mPrimitiveFields.mRotation);
202             mComputedFields.mTransformCamera.getMatrix(&transform3D);
203             transform3D.preTranslate(-getPivotX(), -getPivotY());
204             transform3D.postTranslate(getPivotX() + getTranslationX(),
205                                       getPivotY() + getTranslationY());
206             transform->postConcat(transform3D);
207             mComputedFields.mTransformCamera.restore();
208         }
209         mPrimitiveFields.mMatrixOrPivotDirty = false;
210     }
211 }
212 
213 } /* namespace uirenderer */
214 } /* namespace android */
215