RenderProperties.cpp revision 25fbb3fa1138675379102a44405852555cefccbd 
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#define LOG_TAG "OpenGLRenderer"
18
19#include "RenderProperties.h"
20
21#include <utils/Trace.h>
22
23#include <SkCanvas.h>
24#include <SkColorFilter.h>
25#include <SkMatrix.h>
26#include <SkPath.h>
27#include <SkPathOps.h>
28
29#include "Matrix.h"
30#include "OpenGLRenderer.h"
31#include "utils/MathUtils.h"
32
33namespace android {
34namespace uirenderer {
35
36LayerProperties::LayerProperties()
37        : mType(kLayerTypeNone)
38        , mColorFilter(NULL) {
39    reset();
40}
41
42LayerProperties::~LayerProperties() {
43    setType(kLayerTypeNone);
44}
45
46void LayerProperties::reset() {
47    mOpaque = false;
48    setFromPaint(NULL);
49}
50
51bool LayerProperties::setColorFilter(SkColorFilter* filter) {
52   if (mColorFilter == filter) return false;
53   SkRefCnt_SafeAssign(mColorFilter, filter);
54   return true;
55}
56
57bool LayerProperties::setFromPaint(const SkPaint* paint) {
58    bool changed = false;
59    SkXfermode::Mode mode;
60    int alpha;
61    OpenGLRenderer::getAlphaAndModeDirect(paint, &alpha, &mode);
62    changed |= setAlpha(static_cast<uint8_t>(alpha));
63    changed |= setXferMode(mode);
64    changed |= setColorFilter(paint ? paint->getColorFilter() : NULL);
65    return changed;
66}
67
68LayerProperties& LayerProperties::operator=(const LayerProperties& other) {
69    setType(other.type());
70    setOpaque(other.opaque());
71    setAlpha(other.alpha());
72    setXferMode(other.xferMode());
73    setColorFilter(other.colorFilter());
74    return *this;
75}
76
77RenderProperties::PrimitiveFields::PrimitiveFields()
78        : mClipToBounds(true)
79        , mProjectBackwards(false)
80        , mProjectionReceiver(false)
81        , mAlpha(1)
82        , mHasOverlappingRendering(true)
83        , mElevation(0)
84        , mTranslationX(0), mTranslationY(0), mTranslationZ(0)
85        , mRotation(0), mRotationX(0), mRotationY(0)
86        , mScaleX(1), mScaleY(1)
87        , mPivotX(0), mPivotY(0)
88        , mLeft(0), mTop(0), mRight(0), mBottom(0)
89        , mWidth(0), mHeight(0)
90        , mPivotExplicitlySet(false)
91        , mMatrixOrPivotDirty(false) {
92}
93
94RenderProperties::ComputedFields::ComputedFields()
95        : mTransformMatrix(NULL) {
96}
97
98RenderProperties::ComputedFields::~ComputedFields() {
99    delete mTransformMatrix;
100}
101
102RenderProperties::RenderProperties()
103        : mStaticMatrix(NULL)
104        , mAnimationMatrix(NULL) {
105}
106
107RenderProperties::~RenderProperties() {
108    delete mStaticMatrix;
109    delete mAnimationMatrix;
110}
111
112RenderProperties& RenderProperties::operator=(const RenderProperties& other) {
113    if (this != &other) {
114        mPrimitiveFields = other.mPrimitiveFields;
115        setStaticMatrix(other.getStaticMatrix());
116        setAnimationMatrix(other.getAnimationMatrix());
117        setCameraDistance(other.getCameraDistance());
118        mLayerProperties = other.layerProperties();
119
120        // Force recalculation of the matrix, since other's dirty bit may be clear
121        mPrimitiveFields.mMatrixOrPivotDirty = true;
122        updateMatrix();
123    }
124    return *this;
125}
126
127void RenderProperties::debugOutputProperties(const int level) const {
128    if (mPrimitiveFields.mLeft != 0 || mPrimitiveFields.mTop != 0) {
129        ALOGD("%*sTranslate (left, top) %d, %d", level * 2, "", mPrimitiveFields.mLeft, mPrimitiveFields.mTop);
130    }
131    if (mStaticMatrix) {
132        ALOGD("%*sConcatMatrix (static) %p: " SK_MATRIX_STRING,
133                level * 2, "", mStaticMatrix, SK_MATRIX_ARGS(mStaticMatrix));
134    }
135    if (mAnimationMatrix) {
136        ALOGD("%*sConcatMatrix (animation) %p: " SK_MATRIX_STRING,
137                level * 2, "", mAnimationMatrix, SK_MATRIX_ARGS(mAnimationMatrix));
138    }
139    if (hasTransformMatrix()) {
140        if (isTransformTranslateOnly()) {
141            ALOGD("%*sTranslate %.2f, %.2f, %.2f",
142                    level * 2, "", getTranslationX(), getTranslationY(), getZ());
143        } else {
144            ALOGD("%*sConcatMatrix %p: " SK_MATRIX_STRING,
145                    level * 2, "", mComputedFields.mTransformMatrix, SK_MATRIX_ARGS(mComputedFields.mTransformMatrix));
146        }
147    }
148
149    bool clipToBoundsNeeded = layerProperties().type() != kLayerTypeNone ? false : mPrimitiveFields.mClipToBounds;
150    if (mPrimitiveFields.mAlpha < 1) {
151        if (layerProperties().type() != kLayerTypeNone) {
152            ALOGD("%*sSetOverrideLayerAlpha %.2f", level * 2, "", mPrimitiveFields.mAlpha);
153        } else if (!mPrimitiveFields.mHasOverlappingRendering) {
154            ALOGD("%*sScaleAlpha %.2f", level * 2, "", mPrimitiveFields.mAlpha);
155        } else {
156            int flags = SkCanvas::kHasAlphaLayer_SaveFlag;
157            if (clipToBoundsNeeded) {
158                flags |= SkCanvas::kClipToLayer_SaveFlag;
159                clipToBoundsNeeded = false; // clipping done by save layer
160            }
161            ALOGD("%*sSaveLayerAlpha %d, %d, %d, %d, %d, 0x%x", level * 2, "",
162                    0, 0, getWidth(), getHeight(),
163                    (int)(mPrimitiveFields.mAlpha * 255), flags);
164        }
165    }
166    if (clipToBoundsNeeded) {
167        ALOGD("%*sClipRect %d, %d, %d, %d", level * 2, "",
168                0, 0, getWidth(), getHeight());
169    }
170}
171
172void RenderProperties::updateMatrix() {
173    if (mPrimitiveFields.mMatrixOrPivotDirty) {
174        if (!mComputedFields.mTransformMatrix) {
175            // only allocate a mPrimitiveFields.matrix if we have a complex transform
176            mComputedFields.mTransformMatrix = new SkMatrix();
177        }
178        if (!mPrimitiveFields.mPivotExplicitlySet) {
179            mPrimitiveFields.mPivotX = mPrimitiveFields.mWidth / 2.0f;
180            mPrimitiveFields.mPivotY = mPrimitiveFields.mHeight / 2.0f;
181        }
182        SkMatrix* transform = mComputedFields.mTransformMatrix;
183        transform->reset();
184        if (MathUtils::isZero(getRotationX()) && MathUtils::isZero(getRotationY())) {
185            transform->setTranslate(getTranslationX(), getTranslationY());
186            transform->preRotate(getRotation(), getPivotX(), getPivotY());
187            transform->preScale(getScaleX(), getScaleY(), getPivotX(), getPivotY());
188        } else {
189            SkMatrix transform3D;
190            mComputedFields.mTransformCamera.save();
191            transform->preScale(getScaleX(), getScaleY(), getPivotX(), getPivotY());
192            mComputedFields.mTransformCamera.rotateX(mPrimitiveFields.mRotationX);
193            mComputedFields.mTransformCamera.rotateY(mPrimitiveFields.mRotationY);
194            mComputedFields.mTransformCamera.rotateZ(-mPrimitiveFields.mRotation);
195            mComputedFields.mTransformCamera.getMatrix(&transform3D);
196            transform3D.preTranslate(-getPivotX(), -getPivotY());
197            transform3D.postTranslate(getPivotX() + getTranslationX(),
198                    getPivotY() + getTranslationY());
199            transform->postConcat(transform3D);
200            mComputedFields.mTransformCamera.restore();
201        }
202        mPrimitiveFields.mMatrixOrPivotDirty = false;
203    }
204}
205
206} /* namespace uirenderer */
207} /* namespace android */
208