blob: e1441fca5ee27d8672b3704c6e78dfa03905066b [file] [log] [blame]
Chris Craikb565df12015-10-05 13:00:52 -07001/*
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#ifndef ANDROID_HWUI_BAKED_OP_STATE_H
18#define ANDROID_HWUI_BAKED_OP_STATE_H
19
20#include "Matrix.h"
21#include "RecordedOp.h"
22#include "Rect.h"
23#include "Snapshot.h"
24
25namespace android {
26namespace uirenderer {
27
28namespace OpClipSideFlags {
29 enum {
30 None = 0x0,
31 Left = 0x1,
32 Top = 0x2,
33 Right = 0x4,
34 Bottom = 0x8,
35 Full = 0xF,
36 // ConservativeFull = 0x1F needed?
37 };
38}
39
40/**
Chris Craik15c3f192015-12-03 12:16:56 -080041 * Holds a list of BakedOpStates of ops that can be drawn together
42 */
43struct MergedBakedOpList {
44 const BakedOpState*const* states;
45 size_t count;
46 int clipSideFlags;
47 Rect clip;
48};
49
50/**
Chris Craikb565df12015-10-05 13:00:52 -070051 * Holds the resolved clip, transform, and bounds of a recordedOp, when replayed with a snapshot
52 */
53class ResolvedRenderState {
54public:
Chris Craike4db79d2015-12-22 16:32:23 -080055 ResolvedRenderState(LinearAllocator& allocator, Snapshot& snapshot,
56 const RecordedOp& recordedOp, bool expandForStroke);
Chris Craikb565df12015-10-05 13:00:52 -070057
Chris Craik4c3980b2016-03-15 14:20:18 -070058 // Constructor for unbounded ops *with* transform/clip
59 ResolvedRenderState(LinearAllocator& allocator, Snapshot& snapshot,
60 const Matrix4& localTransform, const ClipBase* localClip);
61
Chris Craike4db79d2015-12-22 16:32:23 -080062 // Constructor for unbounded ops without transform/clip (namely shadows)
63 ResolvedRenderState(LinearAllocator& allocator, Snapshot& snapshot);
Chris Craikd3daa312015-11-06 10:59:56 -080064
Chris Craik7435eb12016-01-07 17:41:40 -080065 // Constructor for primitive ops provided clip, and no transform
66 ResolvedRenderState(const ClipRect* viewportRect, const Rect& dstRect);
Chris Craikb87eadd2016-01-06 09:16:05 -080067
Chris Craikd7448e62015-12-15 10:34:36 -080068 Rect computeLocalSpaceClip() const {
69 Matrix4 inverse;
70 inverse.loadInverse(transform);
71
Chris Craike4db79d2015-12-22 16:32:23 -080072 Rect outClip(clipRect());
Chris Craikd7448e62015-12-15 10:34:36 -080073 inverse.mapRect(outClip);
74 return outClip;
75 }
76
Chris Craike4db79d2015-12-22 16:32:23 -080077 const Rect& clipRect() const {
78 return clipState->rect;
79 }
Chris Craikb87eadd2016-01-06 09:16:05 -080080
Chris Craike4db79d2015-12-22 16:32:23 -080081 bool requiresClip() const {
82 return clipSideFlags != OpClipSideFlags::None
Chris Craik7435eb12016-01-07 17:41:40 -080083 || CC_UNLIKELY(clipState->mode != ClipMode::Rectangle);
Chris Craike4db79d2015-12-22 16:32:23 -080084 }
85
86 // returns the clip if it's needed to draw the operation, otherwise nullptr
87 const ClipBase* getClipIfNeeded() const {
88 return requiresClip() ? clipState : nullptr;
89 }
Chris Craikb87eadd2016-01-06 09:16:05 -080090
91 Matrix4 transform;
Chris Craike4db79d2015-12-22 16:32:23 -080092 const ClipBase* clipState = nullptr;
Chris Craikb565df12015-10-05 13:00:52 -070093 Rect clippedBounds;
Chris Craikb87eadd2016-01-06 09:16:05 -080094 int clipSideFlags = 0;
Chris Craik678ff812016-03-01 13:27:54 -080095 const SkPath* localProjectionPathMask = nullptr;
Chris Craik80d2ade2016-03-28 12:54:07 -070096 bool opaqueOverClippedBounds = false;
Chris Craikb565df12015-10-05 13:00:52 -070097};
98
99/**
100 * Self-contained op wrapper, containing all resolved state required to draw the op.
101 *
102 * Stashed pointers within all point to longer lived objects, with no ownership implied.
103 */
104class BakedOpState {
105public:
106 static BakedOpState* tryConstruct(LinearAllocator& allocator,
Chris Craik80d2ade2016-03-28 12:54:07 -0700107 Snapshot& snapshot, const RecordedOp& recordedOp);
Chris Craik386aa032015-12-07 17:08:25 -0800108
Chris Craik4c3980b2016-03-15 14:20:18 -0700109 static BakedOpState* tryConstructUnbounded(LinearAllocator& allocator,
Chris Craik80d2ade2016-03-28 12:54:07 -0700110 Snapshot& snapshot, const RecordedOp& recordedOp);
Chris Craik4c3980b2016-03-15 14:20:18 -0700111
Chris Craik386aa032015-12-07 17:08:25 -0800112 enum class StrokeBehavior {
Chris Craik4c3980b2016-03-15 14:20:18 -0700113 // stroking is forced, regardless of style on paint (such as for lines)
Chris Craik386aa032015-12-07 17:08:25 -0800114 Forced,
115 // stroking is defined by style on paint
116 StyleDefined,
117 };
118
119 static BakedOpState* tryStrokeableOpConstruct(LinearAllocator& allocator,
Chris Craik80d2ade2016-03-28 12:54:07 -0700120 Snapshot& snapshot, const RecordedOp& recordedOp, StrokeBehavior strokeBehavior);
Chris Craikb565df12015-10-05 13:00:52 -0700121
Chris Craikd3daa312015-11-06 10:59:56 -0800122 static BakedOpState* tryShadowOpConstruct(LinearAllocator& allocator,
Chris Craik80d2ade2016-03-28 12:54:07 -0700123 Snapshot& snapshot, const ShadowOp* shadowOpPtr);
Chris Craikd3daa312015-11-06 10:59:56 -0800124
Chris Craikb87eadd2016-01-06 09:16:05 -0800125 static BakedOpState* directConstruct(LinearAllocator& allocator,
Chris Craik80d2ade2016-03-28 12:54:07 -0700126 const ClipRect* clip, const Rect& dstRect, const RecordedOp& recordedOp);
127
128 // Set opaqueOverClippedBounds. If this method isn't called, the op is assumed translucent.
129 void setupOpacity(const SkPaint* paint);
Chris Craikb565df12015-10-05 13:00:52 -0700130
131 // computed state:
Chris Craikb87eadd2016-01-06 09:16:05 -0800132 ResolvedRenderState computedState;
Chris Craikb565df12015-10-05 13:00:52 -0700133
134 // simple state (straight pointer/value storage):
135 const float alpha;
136 const RoundRectClipState* roundRectClipState;
Chris Craikb565df12015-10-05 13:00:52 -0700137 const RecordedOp* op;
138
139private:
John Reck7df9ff22016-02-10 16:08:08 -0800140 friend class LinearAllocator;
141
Chris Craike4db79d2015-12-22 16:32:23 -0800142 BakedOpState(LinearAllocator& allocator, Snapshot& snapshot,
143 const RecordedOp& recordedOp, bool expandForStroke)
144 : computedState(allocator, snapshot, recordedOp, expandForStroke)
Chris Craikb565df12015-10-05 13:00:52 -0700145 , alpha(snapshot.alpha)
146 , roundRectClipState(snapshot.roundRectClipState)
Chris Craikb565df12015-10-05 13:00:52 -0700147 , op(&recordedOp) {}
Chris Craikd3daa312015-11-06 10:59:56 -0800148
Chris Craik4c3980b2016-03-15 14:20:18 -0700149 // TODO: fix this brittleness
150 BakedOpState(LinearAllocator& allocator, Snapshot& snapshot, const RecordedOp& recordedOp)
151 : computedState(allocator, snapshot, recordedOp.localMatrix, recordedOp.localClip)
152 , alpha(snapshot.alpha)
153 , roundRectClipState(snapshot.roundRectClipState)
154 , op(&recordedOp) {}
155
Chris Craike4db79d2015-12-22 16:32:23 -0800156 BakedOpState(LinearAllocator& allocator, Snapshot& snapshot, const ShadowOp* shadowOpPtr)
157 : computedState(allocator, snapshot)
Chris Craikd3daa312015-11-06 10:59:56 -0800158 , alpha(snapshot.alpha)
159 , roundRectClipState(snapshot.roundRectClipState)
Chris Craikd3daa312015-11-06 10:59:56 -0800160 , op(shadowOpPtr) {}
Chris Craikb87eadd2016-01-06 09:16:05 -0800161
Chris Craik4876de12016-02-25 16:54:08 -0800162 BakedOpState(const ClipRect* clipRect, const Rect& dstRect, const RecordedOp& recordedOp)
163 : computedState(clipRect, dstRect)
Chris Craikb87eadd2016-01-06 09:16:05 -0800164 , alpha(1.0f)
165 , roundRectClipState(nullptr)
Chris Craikb87eadd2016-01-06 09:16:05 -0800166 , op(&recordedOp) {}
Chris Craikb565df12015-10-05 13:00:52 -0700167};
168
169}; // namespace uirenderer
170}; // namespace android
171
172#endif // ANDROID_HWUI_BAKED_OP_STATE_H