1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef GFX_ANIMATIONINFO_H
#define GFX_ANIMATIONINFO_H
#include "nsCSSPropertyIDSet.h"
#include "nsDisplayItemTypes.h"
#include "mozilla/Array.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/FunctionRef.h"
#include "mozilla/layers/AnimationStorageData.h"
#include "mozilla/layers/LayersMessages.h" // for TransformData
struct RawServoAnimationValue;
class nsIContent;
class nsIFrame;
namespace mozilla {
class nsDisplayItem;
class nsDisplayListBuilder;
class EffectSet;
struct AnimationProperty;
namespace dom {
class Animation;
} // namespace dom
namespace gfx {
class Path;
} // namespace gfx
namespace layers {
class Animation;
class CompositorAnimations;
class Layer;
class WebRenderLayerManager;
struct CompositorAnimationData;
struct PropertyAnimationGroup;
class AnimationInfo final {
typedef nsTArray<Animation> AnimationArray;
public:
AnimationInfo();
~AnimationInfo();
// Ensure that this AnimationInfo has a valid (non-zero) animations id. This
// value is unique across layers.
void EnsureAnimationsId();
// Call AddAnimation to add a new animation to this layer from layout code.
// Caller must fill in all the properties of the returned animation.
// A later animation overrides an earlier one.
Animation* AddAnimation();
// These are a parallel to AddAnimation and clearAnimations, except
// they add pending animations that apply only when the next
// transaction is begun. (See also
// SetBaseTransformForNextTransaction.)
Animation* AddAnimationForNextTransaction();
void SetAnimationGeneration(uint64_t aCount) {
mAnimationGeneration = Some(aCount);
}
Maybe<uint64_t> GetAnimationGeneration() const {
return mAnimationGeneration;
}
// ClearAnimations clears animations on this layer.
void ClearAnimations();
void ClearAnimationsForNextTransaction();
uint64_t GetCompositorAnimationsId() { return mCompositorAnimationsId; }
// Note: We don't set mAnimations on the compositor thread, so this will
// always return an empty array on the compositor thread.
AnimationArray& GetAnimations() { return mAnimations; }
nsTArray<PropertyAnimationGroup>& GetPropertyAnimationGroups() {
return mStorageData.mAnimation;
}
const Maybe<TransformData>& GetTransformData() const {
return mStorageData.mTransformData;
}
const LayersId& GetLayersId() const { return mStorageData.mLayersId; }
bool ApplyPendingUpdatesForThisTransaction();
bool HasTransformAnimation() const;
gfx::Path* CachedMotionPath() { return mStorageData.mCachedMotionPath; }
// In case of continuation, |aFrame| must be the first or the last
// continuation frame, otherwise this function might return Nothing().
static Maybe<uint64_t> GetGenerationFromFrame(
nsIFrame* aFrame, DisplayItemType aDisplayItemKey);
using CompositorAnimatableDisplayItemTypes =
Array<DisplayItemType,
nsCSSPropertyIDSet::CompositorAnimatableDisplayItemCount()>;
using AnimationGenerationCallback = FunctionRef<bool(
const Maybe<uint64_t>& aGeneration, DisplayItemType aDisplayItemType)>;
// Enumerates animation generations on |aFrame| for the given display item
// types and calls |aCallback| with the animation generation.
//
// The enumeration stops if |aCallback| returns false.
static void EnumerateGenerationOnFrame(
const nsIFrame* aFrame, const nsIContent* aContent,
const CompositorAnimatableDisplayItemTypes& aDisplayItemTypes,
AnimationGenerationCallback);
void AddAnimationsForDisplayItem(
nsIFrame* aFrame, nsDisplayListBuilder* aBuilder, nsDisplayItem* aItem,
DisplayItemType aType, WebRenderLayerManager* aLayerManager,
const Maybe<LayoutDevicePoint>& aPosition = Nothing());
private:
enum class Send {
NextTransaction,
Immediate,
};
void AddAnimationForProperty(nsIFrame* aFrame,
const AnimationProperty& aProperty,
dom::Animation* aAnimation,
const Maybe<TransformData>& aTransformData,
Send aSendFlag);
bool AddAnimationsForProperty(
nsIFrame* aFrame, const EffectSet* aEffects,
const nsTArray<RefPtr<dom::Animation>>& aCompositorAnimations,
const Maybe<TransformData>& aTransformData, nsCSSPropertyID aProperty,
Send aSendFlag, WebRenderLayerManager* aLayerManager);
void AddNonAnimatingTransformLikePropertiesStyles(
const nsCSSPropertyIDSet& aNonAnimatingProperties, nsIFrame* aFrame,
Send aSendFlag);
void MaybeStartPendingAnimation(Animation&, const TimeStamp& aReadyTime);
// mAnimations (and mPendingAnimations) are only set on the main thread.
//
// Once the animations are received on the compositor thread/process we
// use AnimationHelper::ExtractAnimations to transform the rather compact
// representation of animation data we transfer into something we can more
// readily use for sampling and then store it in mPropertyAnimationGroups
// (below) or CompositorAnimationStorage.mAnimations for WebRender.
AnimationArray mAnimations;
UniquePtr<AnimationArray> mPendingAnimations;
uint64_t mCompositorAnimationsId;
// The extracted data produced by AnimationHelper::ExtractAnimations().
AnimationStorageData mStorageData;
// If this layer is used for OMTA, then this counter is used to ensure we
// stay in sync with the animation manager
Maybe<uint64_t> mAnimationGeneration;
bool mMutated;
};
} // namespace layers
} // namespace mozilla
#endif // GFX_ANIMATIONINFO_H
|
