libs/hwui/BakedOpState.cpp

   1 /*
   2  * Copyright (C) 2015 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  */
  16
  17 #include "BakedOpState.h"
  18
  19 #include "ClipArea.h"
  20
  21 namespace android {
  22 namespace uirenderer {
  23
  24 static int computeClipSideFlags(const Rect& clip, const Rect& bounds) {
  25     int clipSideFlags = 0;
  26     if (clip.left > bounds.left) clipSideFlags |= OpClipSideFlags::Left;
  27     if (clip.top > bounds.top) clipSideFlags |= OpClipSideFlags::Top;
  28     if (clip.right < bounds.right) clipSideFlags |= OpClipSideFlags::Right;
  29     if (clip.bottom < bounds.bottom) clipSideFlags |= OpClipSideFlags::Bottom;
  30     return clipSideFlags;
  31 }
  32
  33 ResolvedRenderState::ResolvedRenderState(LinearAllocator& allocator, Snapshot& snapshot,
  34         const RecordedOp& recordedOp, bool expandForStroke) {
  35     // resolvedMatrix = parentMatrix * localMatrix
  36     transform.loadMultiply(*snapshot.transform, recordedOp.localMatrix);
  37
  38     // resolvedClippedBounds = intersect(resolvedMatrix * opBounds, resolvedClipRect)
  39     clippedBounds = recordedOp.unmappedBounds;
  40     if (CC_UNLIKELY(expandForStroke)) {
  41         // account for non-hairline stroke
  42         clippedBounds.outset(recordedOp.paint->getStrokeWidth() * 0.5f);
  43     }
  44     transform.mapRect(clippedBounds);
  45     if (CC_UNLIKELY(expandForStroke
  46             && (!transform.isPureTranslate() || recordedOp.paint->getStrokeWidth() < 1.0f))) {
  47         // account for hairline stroke when stroke may be < 1 scaled pixel
  48         // Non translate || strokeWidth < 1 is conservative, but will cover all cases
  49         clippedBounds.outset(0.5f);
  50     }
  51
  52     // resolvedClipRect = intersect(parentMatrix * localClip, parentClip)
  53     clipState = snapshot.serializeIntersectedClip(allocator,
  54             recordedOp.localClip, *(snapshot.transform));
  55     LOG_ALWAYS_FATAL_IF(!clipState, "must clip!");
  56
  57     const Rect& clipRect = clipState->rect;
  58     if (CC_UNLIKELY(clipRect.isEmpty() || !clippedBounds.intersects(clipRect))) {
  59         // Rejected based on either empty clip, or bounds not intersecting with clip
  60
  61         // Note: we could rewind the clipState object in situations where the clipRect is empty,
  62         // but *only* if the caching logic within ClipArea was aware of the rewind.
  63         clipState = nullptr;
  64         clippedBounds.setEmpty();
  65     } else {
  66         // Not rejected! compute true clippedBounds, clipSideFlags, and path mask
  67         clipSideFlags = computeClipSideFlags(clipRect, clippedBounds);
  68         clippedBounds.doIntersect(clipRect);
  69
  70         if (CC_UNLIKELY(snapshot.projectionPathMask)) {
  71             // map projection path mask from render target space into op space,
  72             // so intersection with op geometry is possible
  73             Matrix4 inverseTransform;
  74             inverseTransform.loadInverse(transform);
  75             SkMatrix skInverseTransform;
  76             inverseTransform.copyTo(skInverseTransform);
  77
  78             auto localMask = allocator.create<SkPath>();
  79             snapshot.projectionPathMask->transform(skInverseTransform, localMask);
  80             localProjectionPathMask = localMask;
  81         }
  82     }
  83 }
  84
  85 ResolvedRenderState::ResolvedRenderState(LinearAllocator& allocator, Snapshot& snapshot,
  86         const Matrix4& localTransform, const ClipBase* localClip) {
  87     transform.loadMultiply(*snapshot.transform, localTransform);
  88     clipState = snapshot.serializeIntersectedClip(allocator, localClip, *(snapshot.transform));
  89     clippedBounds = clipState->rect;
  90     clipSideFlags = OpClipSideFlags::Full;
  91     localProjectionPathMask = nullptr;
  92 }
  93
  94 ResolvedRenderState::ResolvedRenderState(LinearAllocator& allocator, Snapshot& snapshot)
  95         : transform(*snapshot.transform)
  96         , clipState(snapshot.mutateClipArea().serializeClip(allocator))
  97         , clippedBounds(clipState->rect)
  98         , clipSideFlags(OpClipSideFlags::Full)
  99         , localProjectionPathMask(nullptr) {}
 100
 101 ResolvedRenderState::ResolvedRenderState(const ClipRect* clipRect, const Rect& dstRect)
 102         : transform(Matrix4::identity())
 103         , clipState(clipRect)
 104         , clippedBounds(dstRect)
 105         , clipSideFlags(computeClipSideFlags(clipRect->rect, dstRect))
 106         , localProjectionPathMask(nullptr) {
 107     clippedBounds.doIntersect(clipRect->rect);
 108 }
 109
 110 BakedOpState* BakedOpState::tryConstruct(LinearAllocator& allocator,
 111         Snapshot& snapshot, const RecordedOp& recordedOp) {
 112     if (CC_UNLIKELY(snapshot.getRenderTargetClip().isEmpty())) return nullptr;
 113     BakedOpState* bakedState = allocator.create_trivial<BakedOpState>(
 114             allocator, snapshot, recordedOp, false);
 115     if (bakedState->computedState.clippedBounds.isEmpty()) {
 116         // bounds are empty, so op is rejected
 117         allocator.rewindIfLastAlloc(bakedState);
 118         return nullptr;
 119     }
 120     return bakedState;
 121 }
 122
 123 BakedOpState* BakedOpState::tryConstructUnbounded(LinearAllocator& allocator,
 124         Snapshot& snapshot, const RecordedOp& recordedOp) {
 125     if (CC_UNLIKELY(snapshot.getRenderTargetClip().isEmpty())) return nullptr;
 126     return allocator.create_trivial<BakedOpState>(allocator, snapshot, recordedOp);
 127 }
 128
 129 BakedOpState* BakedOpState::tryStrokeableOpConstruct(LinearAllocator& allocator,
 130         Snapshot& snapshot, const RecordedOp& recordedOp, StrokeBehavior strokeBehavior) {
 131     if (CC_UNLIKELY(snapshot.getRenderTargetClip().isEmpty())) return nullptr;
 132     bool expandForStroke = (strokeBehavior == StrokeBehavior::StyleDefined)
 133             ? (recordedOp.paint && recordedOp.paint->getStyle() != SkPaint::kFill_Style)
 134             : true;
 135
 136     BakedOpState* bakedState = allocator.create_trivial<BakedOpState>(
 137            allocator, snapshot, recordedOp, expandForStroke);
 138     if (bakedState->computedState.clippedBounds.isEmpty()) {
 139         // bounds are empty, so op is rejected
 140         // NOTE: this won't succeed if a clip was allocated
 141         allocator.rewindIfLastAlloc(bakedState);
 142         return nullptr;
 143     }
 144     return bakedState;
 145 }
 146
 147 BakedOpState* BakedOpState::tryShadowOpConstruct(LinearAllocator& allocator,
 148         Snapshot& snapshot, const ShadowOp* shadowOpPtr) {
 149     if (CC_UNLIKELY(snapshot.getRenderTargetClip().isEmpty())) return nullptr;
 150
 151     // clip isn't empty, so construct the op
 152     return allocator.create_trivial<BakedOpState>(allocator, snapshot, shadowOpPtr);
 153 }
 154
 155 BakedOpState* BakedOpState::directConstruct(LinearAllocator& allocator,
 156         const ClipRect* clip, const Rect& dstRect, const RecordedOp& recordedOp) {
 157     return allocator.create_trivial<BakedOpState>(clip, dstRect, recordedOp);
 158 }
 159
 160 void BakedOpState::setupOpacity(const SkPaint* paint) {
 161     computedState.opaqueOverClippedBounds = computedState.transform.isSimple()
 162             && computedState.clipState->mode == ClipMode::Rectangle
 163             && MathUtils::areEqual(alpha, 1.0f)
 164             && !roundRectClipState
 165             && PaintUtils::isOpaquePaint(paint);
 166 }
 167
 168 } // namespace uirenderer
 169 } // namespace android