gfx/layers/AnimationStorageData.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_layers_AnimationStorageData_h
   8 #define mozilla_layers_AnimationStorageData_h
   9
  10 #include "mozilla/dom/Nullable.h"
  11 #include "mozilla/ServoStyleConsts.h"       // for ComputedTimingFunction
  12 #include "mozilla/layers/LayersMessages.h"  // for TransformData, etc
  13 #include "mozilla/layers/LayersTypes.h"     // for LayersId
  14 #include "mozilla/TimeStamp.h"              // for TimeStamp
  15 #include "mozilla/TimingParams.h"
  16 #include "X11UndefineNone.h"
  17
  18 namespace mozilla {
  19
  20 namespace dom {
  21 enum class CompositeOperation : uint8_t;
  22 enum class IterationCompositeOperation : uint8_t;
  23 };  // namespace dom
  24
  25 namespace layers {
  26
  27 struct PropertyAnimation {
  28   struct SegmentData {
  29     RefPtr<StyleAnimationValue> mStartValue;
  30     RefPtr<StyleAnimationValue> mEndValue;
  31     Maybe<mozilla::StyleComputedTimingFunction> mFunction;
  32     float mStartPortion;
  33     float mEndPortion;
  34     dom::CompositeOperation mStartComposite;
  35     dom::CompositeOperation mEndComposite;
  36   };
  37   nsTArray<SegmentData> mSegments;
  38   TimingParams mTiming;
  39
  40   // These two variables correspond to the variables of the same name in
  41   // KeyframeEffectReadOnly and are used for the same purpose: to skip composing
  42   // animations whose progress has not changed.
  43   dom::Nullable<double> mProgressOnLastCompose;
  44   uint64_t mCurrentIterationOnLastCompose = 0;
  45   // These two variables are used for a similar optimization above but are
  46   // applied to the timing function in each keyframe.
  47   uint32_t mSegmentIndexOnLastCompose = 0;
  48   dom::Nullable<double> mPortionInSegmentOnLastCompose;
  49
  50   TimeStamp mOriginTime;
  51   Maybe<TimeDuration> mStartTime;
  52   TimeDuration mHoldTime;
  53   float mPlaybackRate;
  54   dom::IterationCompositeOperation mIterationComposite;
  55   bool mIsNotPlaying;
  56
  57   // The information for scroll-driven animations.
  58   Maybe<ScrollTimelineOptions> mScrollTimelineOptions;
  59
  60   void ResetLastCompositionValues() {
  61     mCurrentIterationOnLastCompose = 0;
  62     mSegmentIndexOnLastCompose = 0;
  63     mProgressOnLastCompose.SetNull();
  64     mPortionInSegmentOnLastCompose.SetNull();
  65   }
  66 };
  67
  68 struct PropertyAnimationGroup {
  69   nsCSSPropertyID mProperty;
  70
  71   nsTArray<PropertyAnimation> mAnimations;
  72   RefPtr<StyleAnimationValue> mBaseStyle;
  73
  74   bool IsEmpty() const { return mAnimations.IsEmpty(); }
  75   void Clear() {
  76     mAnimations.Clear();
  77     mBaseStyle = nullptr;
  78   }
  79   void ResetLastCompositionValues() {
  80     for (PropertyAnimation& animation : mAnimations) {
  81       animation.ResetLastCompositionValues();
  82     }
  83   }
  84 };
  85
  86 struct AnimationStorageData {
  87   // Each entry in the array represents an animation list for one property.  For
  88   // transform-like properties (e.g. transform, rotate etc.), there may be
  89   // multiple entries depending on how many transform-like properties we have.
  90   nsTArray<PropertyAnimationGroup> mAnimation;
  91   Maybe<TransformData> mTransformData;
  92   // For motion path. We cached the gfx path for optimization.
  93   RefPtr<gfx::Path> mCachedMotionPath;
  94   // This is used to communicate with the main-thread. E.g. to tell the fact
  95   // that this animation needs to be pre-rendered again on the main-thread, etc.
  96   LayersId mLayersId;
  97
  98   AnimationStorageData() = default;
  99   AnimationStorageData(AnimationStorageData&& aOther) = default;
 100   AnimationStorageData& operator=(AnimationStorageData&& aOther) = default;
 101
 102   // Avoid any copy because mAnimation could be a large array.
 103   AnimationStorageData(const AnimationStorageData& aOther) = delete;
 104   AnimationStorageData& operator=(const AnimationStorageData& aOther) = delete;
 105
 106   bool IsEmpty() const { return mAnimation.IsEmpty(); }
 107   void Clear() {
 108     mAnimation.Clear();
 109     mTransformData.reset();
 110     mCachedMotionPath = nullptr;
 111   }
 112 };
 113
 114 }  // namespace layers
 115 }  // namespace mozilla
 116
 117 #endif  // mozilla_layers_AnimationStorageData_h