John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You 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 | */ |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 16 | |
| 17 | #pragma once |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 18 | |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 19 | #include "DeviceInfo.h" |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 20 | #include "Outline.h" |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 21 | #include "Rect.h" |
| 22 | #include "RevealClip.h" |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 23 | #include "utils/MathUtils.h" |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 24 | #include "utils/PaintUtils.h" |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 25 | |
Mike Reed | 260ab72 | 2016-10-07 15:59:20 -0400 | [diff] [blame] | 26 | #include <SkBlendMode.h> |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 27 | #include <SkCamera.h> |
John Reck | 3c0369b | 2017-11-13 16:47:35 -0800 | [diff] [blame] | 28 | #include <SkColor.h> |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 29 | #include <SkMatrix.h> |
Chris Craik | 8c271ca | 2014-03-25 10:33:01 -0700 | [diff] [blame] | 30 | #include <SkRegion.h> |
Chris Craik | b49f446 | 2014-03-20 12:44:20 -0700 | [diff] [blame] | 31 | |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 32 | #include <androidfw/ResourceTypes.h> |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 33 | #include <cutils/compiler.h> |
| 34 | #include <stddef.h> |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 35 | #include <utils/Log.h> |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 36 | #include <algorithm> |
sergeyv | c3849aa | 2016-08-08 13:22:06 -0700 | [diff] [blame] | 37 | #include <ostream> |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 38 | #include <vector> |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 39 | |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 40 | class SkBitmap; |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 41 | class SkColorFilter; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 42 | class SkPaint; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 43 | |
| 44 | namespace android { |
| 45 | namespace uirenderer { |
| 46 | |
| 47 | class Matrix4; |
| 48 | class RenderNode; |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 49 | class RenderProperties; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 50 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 51 | // The __VA_ARGS__ will be executed if a & b are not equal |
Chih-Hung Hsieh | cef190d | 2016-05-19 15:25:50 -0700 | [diff] [blame] | 52 | #define RP_SET(a, b, ...) ((a) != (b) ? ((a) = (b), ##__VA_ARGS__, true) : false) |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 53 | #define RP_SET_AND_DIRTY(a, b) RP_SET(a, b, mPrimitiveFields.mMatrixOrPivotDirty = true) |
| 54 | |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 55 | // Keep in sync with View.java:LAYER_TYPE_* |
Chris Craik | 182952f | 2015-03-09 14:17:29 -0700 | [diff] [blame] | 56 | enum class LayerType { |
| 57 | None = 0, |
Derek Sollenberger | 52230bc | 2018-02-16 12:24:13 -0500 | [diff] [blame] | 58 | // We cannot build the software layer directly (must be done at record time) and all management |
| 59 | // of software layers is handled in Java. |
Chris Craik | 182952f | 2015-03-09 14:17:29 -0700 | [diff] [blame] | 60 | Software = 1, |
| 61 | RenderLayer = 2, |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 62 | }; |
| 63 | |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 64 | enum ClippingFlags { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 65 | CLIP_TO_BOUNDS = 0x1 << 0, |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 66 | CLIP_TO_CLIP_BOUNDS = 0x1 << 1, |
| 67 | }; |
| 68 | |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 69 | class ANDROID_API LayerProperties { |
| 70 | public: |
| 71 | bool setType(LayerType type) { |
| 72 | if (RP_SET(mType, type)) { |
| 73 | reset(); |
| 74 | return true; |
| 75 | } |
| 76 | return false; |
| 77 | } |
| 78 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 79 | bool setOpaque(bool opaque) { return RP_SET(mOpaque, opaque); } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 80 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 81 | bool opaque() const { return mOpaque; } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 82 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 83 | bool setAlpha(uint8_t alpha) { return RP_SET(mAlpha, alpha); } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 84 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 85 | uint8_t alpha() const { return mAlpha; } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 86 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 87 | bool setXferMode(SkBlendMode mode) { return RP_SET(mMode, mode); } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 88 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 89 | SkBlendMode xferMode() const { return mMode; } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 90 | |
Ben Wagner | c1a8a46 | 2018-07-12 12:41:28 -0400 | [diff] [blame] | 91 | SkColorFilter* getColorFilter() const { return mColorFilter.get(); } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 92 | |
| 93 | // Sets alpha, xfermode, and colorfilter from an SkPaint |
| 94 | // paint may be NULL, in which case defaults will be set |
| 95 | bool setFromPaint(const SkPaint* paint); |
| 96 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 97 | bool needsBlending() const { return !opaque() || alpha() < 255; } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 98 | |
| 99 | LayerProperties& operator=(const LayerProperties& other); |
| 100 | |
John Reck | 470a919 | 2018-12-17 10:55:54 -0800 | [diff] [blame] | 101 | // Strongly recommend using effectiveLayerType instead |
| 102 | LayerType type() const { return mType; } |
| 103 | |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 104 | private: |
| 105 | LayerProperties(); |
| 106 | ~LayerProperties(); |
| 107 | void reset(); |
Ben Wagner | c1a8a46 | 2018-07-12 12:41:28 -0400 | [diff] [blame] | 108 | bool setColorFilter(SkColorFilter* filter); |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 109 | |
| 110 | friend class RenderProperties; |
| 111 | |
Chris Craik | 182952f | 2015-03-09 14:17:29 -0700 | [diff] [blame] | 112 | LayerType mType = LayerType::None; |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 113 | // Whether or not that Layer's content is opaque, doesn't include alpha |
| 114 | bool mOpaque; |
| 115 | uint8_t mAlpha; |
Mike Reed | 260ab72 | 2016-10-07 15:59:20 -0400 | [diff] [blame] | 116 | SkBlendMode mMode; |
Ben Wagner | c1a8a46 | 2018-07-12 12:41:28 -0400 | [diff] [blame] | 117 | sk_sp<SkColorFilter> mColorFilter; |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 118 | }; |
| 119 | |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 120 | /* |
| 121 | * Data structure that holds the properties for a RenderNode |
| 122 | */ |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 123 | class ANDROID_API RenderProperties { |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 124 | public: |
| 125 | RenderProperties(); |
| 126 | virtual ~RenderProperties(); |
| 127 | |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 128 | static bool setFlag(int flag, bool newValue, int* outFlags) { |
| 129 | if (newValue) { |
| 130 | if (!(flag & *outFlags)) { |
| 131 | *outFlags |= flag; |
| 132 | return true; |
| 133 | } |
| 134 | return false; |
| 135 | } else { |
| 136 | if (flag & *outFlags) { |
| 137 | *outFlags &= ~flag; |
| 138 | return true; |
| 139 | } |
| 140 | return false; |
| 141 | } |
| 142 | } |
| 143 | |
Chris Craik | a766cb2 | 2015-06-08 16:49:43 -0700 | [diff] [blame] | 144 | /** |
| 145 | * Set internal layer state based on whether this layer |
| 146 | * |
| 147 | * Additionally, returns true if child RenderNodes with functors will need to use a layer |
| 148 | * to support clipping. |
| 149 | */ |
| 150 | bool prepareForFunctorPresence(bool willHaveFunctor, bool ancestorDictatesFunctorsNeedLayer) { |
| 151 | // parent may have already dictated that a descendant layer is needed |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 152 | bool functorsNeedLayer = |
| 153 | ancestorDictatesFunctorsNeedLayer |
Stan Iliev | f09ee58 | 2018-11-06 17:35:50 -0500 | [diff] [blame] | 154 | || CC_UNLIKELY(isClipMayBeComplex()) |
Chris Craik | a766cb2 | 2015-06-08 16:49:43 -0700 | [diff] [blame] | 155 | |
| 156 | // Round rect clipping forces layer for functors |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 157 | || CC_UNLIKELY(getOutline().willRoundRectClip()) || |
| 158 | CC_UNLIKELY(getRevealClip().willClip()) |
Chris Craik | a766cb2 | 2015-06-08 16:49:43 -0700 | [diff] [blame] | 159 | |
| 160 | // Complex matrices forces layer, due to stencil clipping |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 161 | || CC_UNLIKELY(getTransformMatrix() && !getTransformMatrix()->isScaleTranslate()) || |
| 162 | CC_UNLIKELY(getAnimationMatrix() && !getAnimationMatrix()->isScaleTranslate()) || |
| 163 | CC_UNLIKELY(getStaticMatrix() && !getStaticMatrix()->isScaleTranslate()); |
Chris Craik | a766cb2 | 2015-06-08 16:49:43 -0700 | [diff] [blame] | 164 | |
| 165 | mComputedFields.mNeedLayerForFunctors = (willHaveFunctor && functorsNeedLayer); |
| 166 | |
| 167 | // If on a layer, will have consumed the need for isolating functors from stencil. |
| 168 | // Thus, it's safe to reset the flag until some descendent sets it. |
| 169 | return CC_LIKELY(effectiveLayerType() == LayerType::None) && functorsNeedLayer; |
| 170 | } |
| 171 | |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 172 | RenderProperties& operator=(const RenderProperties& other); |
| 173 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 174 | bool setClipToBounds(bool clipToBounds) { |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 175 | return setFlag(CLIP_TO_BOUNDS, clipToBounds, &mPrimitiveFields.mClippingFlags); |
| 176 | } |
| 177 | |
| 178 | bool setClipBounds(const Rect& clipBounds) { |
| 179 | bool ret = setFlag(CLIP_TO_CLIP_BOUNDS, true, &mPrimitiveFields.mClippingFlags); |
| 180 | return RP_SET(mPrimitiveFields.mClipBounds, clipBounds) || ret; |
| 181 | } |
| 182 | |
| 183 | bool setClipBoundsEmpty() { |
| 184 | return setFlag(CLIP_TO_CLIP_BOUNDS, false, &mPrimitiveFields.mClippingFlags); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 185 | } |
| 186 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 187 | bool setProjectBackwards(bool shouldProject) { |
| 188 | return RP_SET(mPrimitiveFields.mProjectBackwards, shouldProject); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 189 | } |
| 190 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 191 | bool setProjectionReceiver(bool shouldReceive) { |
| 192 | return RP_SET(mPrimitiveFields.mProjectionReceiver, shouldReceive); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 193 | } |
| 194 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 195 | bool isProjectionReceiver() const { return mPrimitiveFields.mProjectionReceiver; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 196 | |
Stan Iliev | f09ee58 | 2018-11-06 17:35:50 -0500 | [diff] [blame] | 197 | bool setClipMayBeComplex(bool isClipMayBeComplex) { |
| 198 | return RP_SET(mPrimitiveFields.mClipMayBeComplex, isClipMayBeComplex); |
| 199 | } |
| 200 | |
| 201 | bool isClipMayBeComplex() const { return mPrimitiveFields.mClipMayBeComplex; } |
| 202 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 203 | bool setStaticMatrix(const SkMatrix* matrix) { |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 204 | delete mStaticMatrix; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 205 | if (matrix) { |
| 206 | mStaticMatrix = new SkMatrix(*matrix); |
| 207 | } else { |
Chris Craik | e84a208 | 2014-12-22 14:28:49 -0800 | [diff] [blame] | 208 | mStaticMatrix = nullptr; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 209 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 210 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | // Can return NULL |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 214 | const SkMatrix* getStaticMatrix() const { return mStaticMatrix; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 215 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 216 | bool setAnimationMatrix(const SkMatrix* matrix) { |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 217 | delete mAnimationMatrix; |
| 218 | if (matrix) { |
| 219 | mAnimationMatrix = new SkMatrix(*matrix); |
| 220 | } else { |
Chris Craik | e84a208 | 2014-12-22 14:28:49 -0800 | [diff] [blame] | 221 | mAnimationMatrix = nullptr; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 222 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 223 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 224 | } |
| 225 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 226 | bool setAlpha(float alpha) { |
John Reck | 3b52c03 | 2014-08-06 10:19:32 -0700 | [diff] [blame] | 227 | alpha = MathUtils::clampAlpha(alpha); |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 228 | return RP_SET(mPrimitiveFields.mAlpha, alpha); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 229 | } |
| 230 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 231 | float getAlpha() const { return mPrimitiveFields.mAlpha; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 232 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 233 | bool setHasOverlappingRendering(bool hasOverlappingRendering) { |
| 234 | return RP_SET(mPrimitiveFields.mHasOverlappingRendering, hasOverlappingRendering); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 235 | } |
| 236 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 237 | bool hasOverlappingRendering() const { return mPrimitiveFields.mHasOverlappingRendering; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 238 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 239 | bool setElevation(float elevation) { |
| 240 | return RP_SET(mPrimitiveFields.mElevation, elevation); |
| 241 | // Don't dirty matrix/pivot, since they don't respect Z |
Chris Craik | cc39e16 | 2014-04-25 18:34:11 -0700 | [diff] [blame] | 242 | } |
| 243 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 244 | float getElevation() const { return mPrimitiveFields.mElevation; } |
Chris Craik | cc39e16 | 2014-04-25 18:34:11 -0700 | [diff] [blame] | 245 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 246 | bool setTranslationX(float translationX) { |
| 247 | return RP_SET_AND_DIRTY(mPrimitiveFields.mTranslationX, translationX); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 248 | } |
| 249 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 250 | float getTranslationX() const { return mPrimitiveFields.mTranslationX; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 251 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 252 | bool setTranslationY(float translationY) { |
| 253 | return RP_SET_AND_DIRTY(mPrimitiveFields.mTranslationY, translationY); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 254 | } |
| 255 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 256 | float getTranslationY() const { return mPrimitiveFields.mTranslationY; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 257 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 258 | bool setTranslationZ(float translationZ) { |
| 259 | return RP_SET(mPrimitiveFields.mTranslationZ, translationZ); |
| 260 | // mMatrixOrPivotDirty not set, since matrix doesn't respect Z |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 261 | } |
| 262 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 263 | float getTranslationZ() const { return mPrimitiveFields.mTranslationZ; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 264 | |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 265 | // Animation helper |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 266 | bool setX(float value) { return setTranslationX(value - getLeft()); } |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 267 | |
| 268 | // Animation helper |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 269 | float getX() const { return getLeft() + getTranslationX(); } |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 270 | |
| 271 | // Animation helper |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 272 | bool setY(float value) { return setTranslationY(value - getTop()); } |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 273 | |
| 274 | // Animation helper |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 275 | float getY() const { return getTop() + getTranslationY(); } |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 276 | |
| 277 | // Animation helper |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 278 | bool setZ(float value) { return setTranslationZ(value - getElevation()); } |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 279 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 280 | float getZ() const { return getElevation() + getTranslationZ(); } |
Chris Craik | cc39e16 | 2014-04-25 18:34:11 -0700 | [diff] [blame] | 281 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 282 | bool setRotation(float rotation) { |
| 283 | return RP_SET_AND_DIRTY(mPrimitiveFields.mRotation, rotation); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 284 | } |
| 285 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 286 | float getRotation() const { return mPrimitiveFields.mRotation; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 287 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 288 | bool setRotationX(float rotationX) { |
| 289 | return RP_SET_AND_DIRTY(mPrimitiveFields.mRotationX, rotationX); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 290 | } |
| 291 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 292 | float getRotationX() const { return mPrimitiveFields.mRotationX; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 293 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 294 | bool setRotationY(float rotationY) { |
| 295 | return RP_SET_AND_DIRTY(mPrimitiveFields.mRotationY, rotationY); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 296 | } |
| 297 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 298 | float getRotationY() const { return mPrimitiveFields.mRotationY; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 299 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 300 | bool setScaleX(float scaleX) { return RP_SET_AND_DIRTY(mPrimitiveFields.mScaleX, scaleX); } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 301 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 302 | float getScaleX() const { return mPrimitiveFields.mScaleX; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 303 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 304 | bool setScaleY(float scaleY) { return RP_SET_AND_DIRTY(mPrimitiveFields.mScaleY, scaleY); } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 305 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 306 | float getScaleY() const { return mPrimitiveFields.mScaleY; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 307 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 308 | bool setPivotX(float pivotX) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 309 | if (RP_SET(mPrimitiveFields.mPivotX, pivotX) || !mPrimitiveFields.mPivotExplicitlySet) { |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 310 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
| 311 | mPrimitiveFields.mPivotExplicitlySet = true; |
| 312 | return true; |
| 313 | } |
| 314 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 315 | } |
| 316 | |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 317 | /* Note that getPivotX and getPivotY are adjusted by updateMatrix(), |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 318 | * so the value returned may be stale if the RenderProperties has been |
| 319 | * modified since the last call to updateMatrix() |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 320 | */ |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 321 | float getPivotX() const { return mPrimitiveFields.mPivotX; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 322 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 323 | bool setPivotY(float pivotY) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 324 | if (RP_SET(mPrimitiveFields.mPivotY, pivotY) || !mPrimitiveFields.mPivotExplicitlySet) { |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 325 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
| 326 | mPrimitiveFields.mPivotExplicitlySet = true; |
| 327 | return true; |
| 328 | } |
| 329 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 330 | } |
| 331 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 332 | float getPivotY() const { return mPrimitiveFields.mPivotY; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 333 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 334 | bool isPivotExplicitlySet() const { return mPrimitiveFields.mPivotExplicitlySet; } |
Chris Craik | 49e6c73 | 2014-03-31 12:34:11 -0700 | [diff] [blame] | 335 | |
John Reck | e170fb6 | 2018-05-07 08:12:07 -0700 | [diff] [blame] | 336 | bool resetPivot() { return RP_SET_AND_DIRTY(mPrimitiveFields.mPivotExplicitlySet, false); } |
John Reck | 8686e1f | 2018-03-21 16:31:21 -0700 | [diff] [blame] | 337 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 338 | bool setCameraDistance(float distance) { |
Chris Craik | 49e6c73 | 2014-03-31 12:34:11 -0700 | [diff] [blame] | 339 | if (distance != getCameraDistance()) { |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 340 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
Chris Craik | 49e6c73 | 2014-03-31 12:34:11 -0700 | [diff] [blame] | 341 | mComputedFields.mTransformCamera.setCameraLocation(0, 0, distance); |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 342 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 343 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 344 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 345 | } |
| 346 | |
| 347 | float getCameraDistance() const { |
Chris Craik | 49e6c73 | 2014-03-31 12:34:11 -0700 | [diff] [blame] | 348 | // TODO: update getCameraLocationZ() to be const |
| 349 | return const_cast<Sk3DView*>(&mComputedFields.mTransformCamera)->getCameraLocationZ(); |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 350 | } |
| 351 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 352 | bool setLeft(int left) { |
| 353 | if (RP_SET(mPrimitiveFields.mLeft, left)) { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 354 | mPrimitiveFields.mWidth = mPrimitiveFields.mRight - mPrimitiveFields.mLeft; |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 355 | if (!mPrimitiveFields.mPivotExplicitlySet) { |
| 356 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 357 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 358 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 359 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 360 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 361 | } |
| 362 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 363 | int getLeft() const { return mPrimitiveFields.mLeft; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 364 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 365 | bool setTop(int top) { |
| 366 | if (RP_SET(mPrimitiveFields.mTop, top)) { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 367 | mPrimitiveFields.mHeight = mPrimitiveFields.mBottom - mPrimitiveFields.mTop; |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 368 | if (!mPrimitiveFields.mPivotExplicitlySet) { |
| 369 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 370 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 371 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 372 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 373 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 374 | } |
| 375 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 376 | int getTop() const { return mPrimitiveFields.mTop; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 377 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 378 | bool setRight(int right) { |
| 379 | if (RP_SET(mPrimitiveFields.mRight, right)) { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 380 | mPrimitiveFields.mWidth = mPrimitiveFields.mRight - mPrimitiveFields.mLeft; |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 381 | if (!mPrimitiveFields.mPivotExplicitlySet) { |
| 382 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 383 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 384 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 385 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 386 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 387 | } |
| 388 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 389 | int getRight() const { return mPrimitiveFields.mRight; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 390 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 391 | bool setBottom(int bottom) { |
| 392 | if (RP_SET(mPrimitiveFields.mBottom, bottom)) { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 393 | mPrimitiveFields.mHeight = mPrimitiveFields.mBottom - mPrimitiveFields.mTop; |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 394 | if (!mPrimitiveFields.mPivotExplicitlySet) { |
| 395 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 396 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 397 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 398 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 399 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 400 | } |
| 401 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 402 | int getBottom() const { return mPrimitiveFields.mBottom; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 403 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 404 | bool setLeftTop(int left, int top) { |
| 405 | bool leftResult = setLeft(left); |
| 406 | bool topResult = setTop(top); |
| 407 | return leftResult || topResult; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 408 | } |
| 409 | |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 410 | bool setLeftTopRightBottom(int left, int top, int right, int bottom) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 411 | if (left != mPrimitiveFields.mLeft || top != mPrimitiveFields.mTop || |
| 412 | right != mPrimitiveFields.mRight || bottom != mPrimitiveFields.mBottom) { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 413 | mPrimitiveFields.mLeft = left; |
| 414 | mPrimitiveFields.mTop = top; |
| 415 | mPrimitiveFields.mRight = right; |
| 416 | mPrimitiveFields.mBottom = bottom; |
| 417 | mPrimitiveFields.mWidth = mPrimitiveFields.mRight - mPrimitiveFields.mLeft; |
| 418 | mPrimitiveFields.mHeight = mPrimitiveFields.mBottom - mPrimitiveFields.mTop; |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 419 | if (!mPrimitiveFields.mPivotExplicitlySet) { |
| 420 | mPrimitiveFields.mMatrixOrPivotDirty = true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 421 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 422 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 423 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 424 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 425 | } |
| 426 | |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 427 | bool offsetLeftRight(int offset) { |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 428 | if (offset != 0) { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 429 | mPrimitiveFields.mLeft += offset; |
| 430 | mPrimitiveFields.mRight += offset; |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 431 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 432 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 433 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 434 | } |
| 435 | |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 436 | bool offsetTopBottom(int offset) { |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 437 | if (offset != 0) { |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 438 | mPrimitiveFields.mTop += offset; |
| 439 | mPrimitiveFields.mBottom += offset; |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 440 | return true; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 441 | } |
John Reck | 79c7de7 | 2014-05-23 10:33:31 -0700 | [diff] [blame] | 442 | return false; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 443 | } |
| 444 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 445 | int getWidth() const { return mPrimitiveFields.mWidth; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 446 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 447 | int getHeight() const { return mPrimitiveFields.mHeight; } |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 448 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 449 | const SkMatrix* getAnimationMatrix() const { return mAnimationMatrix; } |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 450 | |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 451 | bool hasTransformMatrix() const { |
| 452 | return getTransformMatrix() && !getTransformMatrix()->isIdentity(); |
| 453 | } |
| 454 | |
| 455 | // May only call this if hasTransformMatrix() is true |
| 456 | bool isTransformTranslateOnly() const { |
| 457 | return getTransformMatrix()->getType() == SkMatrix::kTranslate_Mask; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 458 | } |
| 459 | |
Chris Craik | 49e6c73 | 2014-03-31 12:34:11 -0700 | [diff] [blame] | 460 | const SkMatrix* getTransformMatrix() const { |
John Reck | f7483e3 | 2014-04-11 08:54:47 -0700 | [diff] [blame] | 461 | LOG_ALWAYS_FATAL_IF(mPrimitiveFields.mMatrixOrPivotDirty, "Cannot get a dirty matrix!"); |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 462 | return mComputedFields.mTransformMatrix; |
| 463 | } |
| 464 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 465 | int getClippingFlags() const { return mPrimitiveFields.mClippingFlags; } |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 466 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 467 | bool getClipToBounds() const { return mPrimitiveFields.mClippingFlags & CLIP_TO_BOUNDS; } |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 468 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 469 | const Rect& getClipBounds() const { return mPrimitiveFields.mClipBounds; } |
John Reck | e248bd1 | 2015-08-05 13:53:53 -0700 | [diff] [blame] | 470 | |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 471 | void getClippingRectForFlags(uint32_t flags, Rect* outRect) const { |
| 472 | if (flags & CLIP_TO_BOUNDS) { |
| 473 | outRect->set(0, 0, getWidth(), getHeight()); |
| 474 | if (flags & CLIP_TO_CLIP_BOUNDS) { |
Chris Craik | ac02eb9 | 2015-10-05 12:23:46 -0700 | [diff] [blame] | 475 | outRect->doIntersect(mPrimitiveFields.mClipBounds); |
Chris Craik | a753f4c | 2014-07-24 12:39:17 -0700 | [diff] [blame] | 476 | } |
| 477 | } else { |
| 478 | outRect->set(mPrimitiveFields.mClipBounds); |
| 479 | } |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 480 | } |
| 481 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 482 | bool getHasOverlappingRendering() const { return mPrimitiveFields.mHasOverlappingRendering; } |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 483 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 484 | const Outline& getOutline() const { return mPrimitiveFields.mOutline; } |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 485 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 486 | const RevealClip& getRevealClip() const { return mPrimitiveFields.mRevealClip; } |
Chris Craik | 8c271ca | 2014-03-25 10:33:01 -0700 | [diff] [blame] | 487 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 488 | bool getProjectBackwards() const { return mPrimitiveFields.mProjectBackwards; } |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 489 | |
sergeyv | c3849aa | 2016-08-08 13:22:06 -0700 | [diff] [blame] | 490 | void debugOutputProperties(std::ostream& output, const int level) const; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 491 | |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 492 | void updateMatrix(); |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 493 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 494 | Outline& mutableOutline() { return mPrimitiveFields.mOutline; } |
Chris Craik | b49f446 | 2014-03-20 12:44:20 -0700 | [diff] [blame] | 495 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 496 | RevealClip& mutableRevealClip() { return mPrimitiveFields.mRevealClip; } |
Chris Craik | 8c271ca | 2014-03-25 10:33:01 -0700 | [diff] [blame] | 497 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 498 | const LayerProperties& layerProperties() const { return mLayerProperties; } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 499 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 500 | LayerProperties& mutateLayerProperties() { return mLayerProperties; } |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 501 | |
John Reck | 293e868 | 2014-06-17 10:34:02 -0700 | [diff] [blame] | 502 | // Returns true if damage calculations should be clipped to bounds |
| 503 | // TODO: Figure out something better for getZ(), as children should still be |
| 504 | // clipped to this RP's bounds. But as we will damage -INT_MAX to INT_MAX |
| 505 | // for this RP's getZ() anyway, this can be optimized when we have a |
| 506 | // Z damage estimate instead of INT_MAX |
| 507 | bool getClipDamageToBounds() const { |
| 508 | return getClipToBounds() && (getZ() <= 0 || getOutline().isEmpty()); |
| 509 | } |
| 510 | |
Chris Craik | 5c75c52 | 2014-09-05 14:08:08 -0700 | [diff] [blame] | 511 | bool hasShadow() const { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 512 | return getZ() > 0.0f && getOutline().getPath() != nullptr && |
| 513 | getOutline().getAlpha() != 0.0f; |
Chris Craik | 5c75c52 | 2014-09-05 14:08:08 -0700 | [diff] [blame] | 514 | } |
| 515 | |
John Reck | e170fb6 | 2018-05-07 08:12:07 -0700 | [diff] [blame] | 516 | SkColor getSpotShadowColor() const { return mPrimitiveFields.mSpotShadowColor; } |
John Reck | 3c0369b | 2017-11-13 16:47:35 -0800 | [diff] [blame] | 517 | |
John Reck | d8be4a0 | 2017-11-17 15:06:24 -0800 | [diff] [blame] | 518 | bool setSpotShadowColor(SkColor shadowColor) { |
| 519 | return RP_SET(mPrimitiveFields.mSpotShadowColor, shadowColor); |
| 520 | } |
| 521 | |
John Reck | e170fb6 | 2018-05-07 08:12:07 -0700 | [diff] [blame] | 522 | SkColor getAmbientShadowColor() const { return mPrimitiveFields.mAmbientShadowColor; } |
John Reck | d8be4a0 | 2017-11-17 15:06:24 -0800 | [diff] [blame] | 523 | |
| 524 | bool setAmbientShadowColor(SkColor shadowColor) { |
| 525 | return RP_SET(mPrimitiveFields.mAmbientShadowColor, shadowColor); |
John Reck | 3c0369b | 2017-11-13 16:47:35 -0800 | [diff] [blame] | 526 | } |
| 527 | |
Chris Craik | 9fded23 | 2015-11-11 16:42:34 -0800 | [diff] [blame] | 528 | bool fitsOnLayer() const { |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 529 | const DeviceInfo* deviceInfo = DeviceInfo::get(); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 530 | return mPrimitiveFields.mWidth <= deviceInfo->maxTextureSize() && |
| 531 | mPrimitiveFields.mHeight <= deviceInfo->maxTextureSize(); |
Chris Craik | 9fded23 | 2015-11-11 16:42:34 -0800 | [diff] [blame] | 532 | } |
| 533 | |
| 534 | bool promotedToLayer() const { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 535 | return mLayerProperties.mType == LayerType::None && fitsOnLayer() && |
| 536 | (mComputedFields.mNeedLayerForFunctors || |
| 537 | (!MathUtils::isZero(mPrimitiveFields.mAlpha) && mPrimitiveFields.mAlpha < 1 && |
| 538 | mPrimitiveFields.mHasOverlappingRendering)); |
Chris Craik | 1a0808e | 2015-05-13 16:33:04 -0700 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | LayerType effectiveLayerType() const { |
Chris Craik | a766cb2 | 2015-06-08 16:49:43 -0700 | [diff] [blame] | 542 | return CC_UNLIKELY(promotedToLayer()) ? LayerType::RenderLayer : mLayerProperties.mType; |
Chris Craik | 856f0cc | 2015-04-21 15:13:29 -0700 | [diff] [blame] | 543 | } |
| 544 | |
John Reck | 1423e13 | 2018-09-21 14:30:19 -0700 | [diff] [blame] | 545 | bool setAllowForceDark(bool allow) { |
| 546 | return RP_SET(mPrimitiveFields.mAllowForceDark, allow); |
| 547 | } |
| 548 | |
| 549 | bool getAllowForceDark() const { |
| 550 | return mPrimitiveFields.mAllowForceDark; |
| 551 | } |
| 552 | |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 553 | private: |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 554 | // Rendering properties |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 555 | struct PrimitiveFields { |
John Reck | e248bd1 | 2015-08-05 13:53:53 -0700 | [diff] [blame] | 556 | int mLeft = 0, mTop = 0, mRight = 0, mBottom = 0; |
| 557 | int mWidth = 0, mHeight = 0; |
| 558 | int mClippingFlags = CLIP_TO_BOUNDS; |
John Reck | d8be4a0 | 2017-11-17 15:06:24 -0800 | [diff] [blame] | 559 | SkColor mSpotShadowColor = SK_ColorBLACK; |
| 560 | SkColor mAmbientShadowColor = SK_ColorBLACK; |
John Reck | e248bd1 | 2015-08-05 13:53:53 -0700 | [diff] [blame] | 561 | float mAlpha = 1; |
| 562 | float mTranslationX = 0, mTranslationY = 0, mTranslationZ = 0; |
| 563 | float mElevation = 0; |
| 564 | float mRotation = 0, mRotationX = 0, mRotationY = 0; |
| 565 | float mScaleX = 1, mScaleY = 1; |
| 566 | float mPivotX = 0, mPivotY = 0; |
| 567 | bool mHasOverlappingRendering = false; |
| 568 | bool mPivotExplicitlySet = false; |
| 569 | bool mMatrixOrPivotDirty = false; |
| 570 | bool mProjectBackwards = false; |
| 571 | bool mProjectionReceiver = false; |
John Reck | 1423e13 | 2018-09-21 14:30:19 -0700 | [diff] [blame] | 572 | bool mAllowForceDark = true; |
Stan Iliev | f09ee58 | 2018-11-06 17:35:50 -0500 | [diff] [blame] | 573 | bool mClipMayBeComplex = false; |
John Reck | e248bd1 | 2015-08-05 13:53:53 -0700 | [diff] [blame] | 574 | Rect mClipBounds; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 575 | Outline mOutline; |
Chris Craik | 8c271ca | 2014-03-25 10:33:01 -0700 | [diff] [blame] | 576 | RevealClip mRevealClip; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 577 | } mPrimitiveFields; |
| 578 | |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 579 | SkMatrix* mStaticMatrix; |
| 580 | SkMatrix* mAnimationMatrix; |
John Reck | 25fbb3f | 2014-06-12 13:46:45 -0700 | [diff] [blame] | 581 | LayerProperties mLayerProperties; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 582 | |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 583 | /** |
| 584 | * These fields are all generated from other properties and are not set directly. |
| 585 | */ |
| 586 | struct ComputedFields { |
| 587 | ComputedFields(); |
| 588 | ~ComputedFields(); |
| 589 | |
| 590 | /** |
| 591 | * Stores the total transformation of the DisplayList based upon its scalar |
| 592 | * translate/rotate/scale properties. |
| 593 | * |
Chris Craik | 49e6c73 | 2014-03-31 12:34:11 -0700 | [diff] [blame] | 594 | * In the common translation-only case, the matrix isn't necessarily allocated, |
| 595 | * and the mTranslation properties are used directly. |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 596 | */ |
Chris Craik | 49e6c73 | 2014-03-31 12:34:11 -0700 | [diff] [blame] | 597 | SkMatrix* mTransformMatrix; |
| 598 | |
| 599 | Sk3DView mTransformCamera; |
Chris Craik | a766cb2 | 2015-06-08 16:49:43 -0700 | [diff] [blame] | 600 | |
| 601 | // Force layer on for functors to enable render features they don't yet support (clipping) |
| 602 | bool mNeedLayerForFunctors = false; |
John Reck | d0a0b2a | 2014-03-20 16:28:56 -0700 | [diff] [blame] | 603 | } mComputedFields; |
John Reck | acb6f07 | 2014-03-12 16:11:23 -0700 | [diff] [blame] | 604 | }; |
| 605 | |
| 606 | } /* namespace uirenderer */ |
| 607 | } /* namespace android */ |