Home | History | Annotate | Download | only in hwui 
      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 
     33 namespace android {
     34 namespace uirenderer {
     35 
     36 LayerProperties::LayerProperties()
     37         : mType(kLayerTypeNone)
     38         , mColorFilter(NULL) {
     39     reset();
     40 }
     41 
     42 LayerProperties::~LayerProperties() {
     43     setType(kLayerTypeNone);
     44 }
     45 
     46 void LayerProperties::reset() {
     47     mOpaque = false;
     48     setFromPaint(NULL);
     49 }
     50 
     51 bool LayerProperties::setColorFilter(SkColorFilter* filter) {
     52    if (mColorFilter == filter) return false;
     53    SkRefCnt_SafeAssign(mColorFilter, filter);
     54    return true;
     55 }
     56 
     57 bool 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 
     68 LayerProperties& 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 
     77 RenderProperties::PrimitiveFields::PrimitiveFields()
     78         : mClippingFlags(CLIP_TO_BOUNDS)
     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 
     94 RenderProperties::ComputedFields::ComputedFields()
     95         : mTransformMatrix(NULL) {
     96 }
     97 
     98 RenderProperties::ComputedFields::~ComputedFields() {
     99     delete mTransformMatrix;
    100 }
    101 
    102 RenderProperties::RenderProperties()
    103         : mStaticMatrix(NULL)
    104         , mAnimationMatrix(NULL) {
    105 }
    106 
    107 RenderProperties::~RenderProperties() {
    108     delete mStaticMatrix;
    109     delete mAnimationMatrix;
    110 }
    111 
    112 RenderProperties& 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 
    127 void 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     const bool isLayer = layerProperties().type() != kLayerTypeNone;
    150     int clipFlags = getClippingFlags();
    151     if (mPrimitiveFields.mAlpha < 1) {
    152         if (isLayer) {
    153             clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer
    154 
    155             ALOGD("%*sSetOverrideLayerAlpha %.2f", level * 2, "", mPrimitiveFields.mAlpha);
    156         } else if (!mPrimitiveFields.mHasOverlappingRendering) {
    157             ALOGD("%*sScaleAlpha %.2f", level * 2, "", mPrimitiveFields.mAlpha);
    158         } else {
    159             Rect layerBounds(0, 0, getWidth(), getHeight());
    160             int saveFlags = SkCanvas::kHasAlphaLayer_SaveFlag;
    161             if (clipFlags) {
    162                 saveFlags |= SkCanvas::kClipToLayer_SaveFlag;
    163                 getClippingRectForFlags(clipFlags, &layerBounds);
    164                 clipFlags = 0; // all clipping done by saveLayer
    165             }
    166 
    167             ALOGD("%*sSaveLayerAlpha %d, %d, %d, %d, %d, 0x%x", level * 2, "",
    168                     (int)layerBounds.left, (int)layerBounds.top, (int)layerBounds.right, (int)layerBounds.bottom,
    169                     (int)(mPrimitiveFields.mAlpha * 255), saveFlags);
    170         }
    171     }
    172     if (clipFlags) {
    173         Rect clipRect;
    174         getClippingRectForFlags(clipFlags, &clipRect);
    175         ALOGD("%*sClipRect %d, %d, %d, %d", level * 2, "",
    176                 (int)clipRect.left, (int)clipRect.top, (int)clipRect.right, (int)clipRect.bottom);
    177     }
    178 }
    179 
    180 void RenderProperties::updateMatrix() {
    181     if (mPrimitiveFields.mMatrixOrPivotDirty) {
    182         if (!mComputedFields.mTransformMatrix) {
    183             // only allocate a mPrimitiveFields.matrix if we have a complex transform
    184             mComputedFields.mTransformMatrix = new SkMatrix();
    185         }
    186         if (!mPrimitiveFields.mPivotExplicitlySet) {
    187             mPrimitiveFields.mPivotX = mPrimitiveFields.mWidth / 2.0f;
    188             mPrimitiveFields.mPivotY = mPrimitiveFields.mHeight / 2.0f;
    189         }
    190         SkMatrix* transform = mComputedFields.mTransformMatrix;
    191         transform->reset();
    192         if (MathUtils::isZero(getRotationX()) && MathUtils::isZero(getRotationY())) {
    193             transform->setTranslate(getTranslationX(), getTranslationY());
    194             transform->preRotate(getRotation(), getPivotX(), getPivotY());
    195             transform->preScale(getScaleX(), getScaleY(), getPivotX(), getPivotY());
    196         } else {
    197             SkMatrix transform3D;
    198             mComputedFields.mTransformCamera.save();
    199             transform->preScale(getScaleX(), getScaleY(), getPivotX(), getPivotY());
    200             mComputedFields.mTransformCamera.rotateX(mPrimitiveFields.mRotationX);
    201             mComputedFields.mTransformCamera.rotateY(mPrimitiveFields.mRotationY);
    202             mComputedFields.mTransformCamera.rotateZ(-mPrimitiveFields.mRotation);
    203             mComputedFields.mTransformCamera.getMatrix(&transform3D);
    204             transform3D.preTranslate(-getPivotX(), -getPivotY());
    205             transform3D.postTranslate(getPivotX() + getTranslationX(),
    206                     getPivotY() + getTranslationY());
    207             transform->postConcat(transform3D);
    208             mComputedFields.mTransformCamera.restore();
    209         }
    210         mPrimitiveFields.mMatrixOrPivotDirty = false;
    211     }
    212 }
    213 
    214 } /* namespace uirenderer */
    215 } /* namespace android */
    216