diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index 1369623a62..312ed93e45 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -11,7 +11,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Threading;
 using osu.Game.Audio;
@@ -20,13 +19,14 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Objects.Pooling;
 using osu.Game.Rulesets.UI;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Objects.Drawables
 {
     [Cached(typeof(DrawableHitObject))]
-    public abstract class DrawableHitObject : PoolableDrawable
+    public abstract class DrawableHitObject : DrawableObject<HitObjectLifetimeEntry>
     {
         /// <summary>
         /// Invoked after this <see cref="DrawableHitObject"/>'s applied <see cref="HitObject"/> has had its defaults applied.
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <summary>
         /// The <see cref="HitObject"/> currently represented by this <see cref="DrawableHitObject"/>.
         /// </summary>
-        public HitObject HitObject => lifetimeEntry?.HitObject;
+        public HitObject HitObject => Entry?.HitObject;
 
         /// <summary>
         /// The parenting <see cref="DrawableHitObject"/>, if any.
@@ -110,7 +110,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <summary>
         /// The scoring result of this <see cref="DrawableHitObject"/>.
         /// </summary>
-        public JudgementResult Result => lifetimeEntry?.Result;
+        public JudgementResult Result => Entry?.Result;
 
         /// <summary>
         /// The relative X position of this hit object for sample playback balance adjustment.
@@ -126,8 +126,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
         private readonly Bindable<bool> userPositionalHitSounds = new Bindable<bool>();
         private readonly Bindable<int> comboIndexBindable = new Bindable<int>();
 
-        public override bool RemoveWhenNotAlive => false;
-        public override bool RemoveCompletedTransforms => false;
         protected override bool RequiresChildrenUpdate => true;
 
         public override bool IsPresent => base.IsPresent || (State.Value == ArmedState.Idle && Clock?.CurrentTime >= LifetimeStart);
@@ -142,18 +140,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </remarks>
         public IBindable<ArmedState> State => state;
 
-        /// <summary>
-        /// Whether a <see cref="HitObjectLifetimeEntry"/> is currently applied.
-        /// </summary>
-        private bool hasEntryApplied;
-
-        /// <summary>
-        /// The <see cref="HitObjectLifetimeEntry"/> controlling the lifetime of the currently-attached <see cref="HitObject"/>.
-        /// </summary>
-        /// <remarks>Even if it is not null, it may not be fully applied until loaded (<see cref="hasEntryApplied"/> is false).</remarks>
-        [CanBeNull]
-        private HitObjectLifetimeEntry lifetimeEntry;
-
         [Resolved(CanBeNull = true)]
         private IPooledHitObjectProvider pooledObjectProvider { get; set; }
 
@@ -167,15 +153,13 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </summary>
         /// <param name="initialHitObject">
         /// The <see cref="HitObject"/> to be initially applied to this <see cref="DrawableHitObject"/>.
-        /// If <c>null</c>, a hitobject is expected to be later applied via <see cref="Apply(osu.Game.Rulesets.Objects.HitObjectLifetimeEntry)"/> (or automatically via pooling).
+        /// If <c>null</c>, a hitobject is expected to be later applied via <see cref="DrawableObject{TEntry}.Apply"/> (or automatically via pooling).
         /// </param>
         protected DrawableHitObject([CanBeNull] HitObject initialHitObject = null)
+            : base(initialHitObject != null ? new SyntheticHitObjectEntry(initialHitObject) : null)
         {
-            if (initialHitObject != null)
-            {
-                lifetimeEntry = new SyntheticHitObjectEntry(initialHitObject);
+            if (Entry != null)
                 ensureEntryHasResult();
-            }
         }
 
         [BackgroundDependencyLoader]
@@ -190,14 +174,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
             CurrentSkin.SourceChanged += onSkinSourceChanged;
         }
 
-        protected override void LoadAsyncComplete()
-        {
-            base.LoadAsyncComplete();
-
-            if (lifetimeEntry != null && !hasEntryApplied)
-                Apply(lifetimeEntry);
-        }
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -231,22 +207,15 @@ namespace osu.Game.Rulesets.Objects.Drawables
             Apply(new SyntheticHitObjectEntry(hitObject));
         }
 
-        /// <summary>
-        /// Applies a new <see cref="HitObjectLifetimeEntry"/> to be represented by this <see cref="DrawableHitObject"/>.
-        /// </summary>
-        public void Apply([NotNull] HitObjectLifetimeEntry newEntry)
+        protected sealed override void OnApply(HitObjectLifetimeEntry entry)
         {
-            free();
-
-            lifetimeEntry = newEntry;
-
             // LifetimeStart is already computed using HitObjectLifetimeEntry's InitialLifetimeOffset.
             // We override this with DHO's InitialLifetimeOffset for a non-pooled DHO.
-            if (newEntry is SyntheticHitObjectEntry)
-                lifetimeEntry.LifetimeStart = HitObject.StartTime - InitialLifetimeOffset;
+            if (entry is SyntheticHitObjectEntry)
+                entry.LifetimeStart = HitObject.StartTime - InitialLifetimeOffset;
 
-            LifetimeStart = lifetimeEntry.LifetimeStart;
-            LifetimeEnd = lifetimeEntry.LifetimeEnd;
+            LifetimeStart = entry.LifetimeStart;
+            LifetimeEnd = entry.LifetimeEnd;
 
             ensureEntryHasResult();
 
@@ -297,17 +266,10 @@ namespace osu.Game.Rulesets.Objects.Drawables
                 else
                     updateState(ArmedState.Idle, true);
             }
-
-            hasEntryApplied = true;
         }
 
-        /// <summary>
-        /// Removes the currently applied <see cref="lifetimeEntry"/>
-        /// </summary>
-        private void free()
+        protected sealed override void OnFree(HitObjectLifetimeEntry entry)
         {
-            if (!hasEntryApplied) return;
-
             StartTimeBindable.UnbindFrom(HitObject.StartTimeBindable);
             if (HitObject is IHasComboInformation combo)
                 comboIndexBindable.UnbindFrom(combo.ComboIndexBindable);
@@ -339,22 +301,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
             OnFree();
 
             ParentHitObject = null;
-            lifetimeEntry = null;
 
             clearExistingStateTransforms();
-
-            hasEntryApplied = false;
-        }
-
-        protected sealed override void FreeAfterUse()
-        {
-            base.FreeAfterUse();
-
-            // Freeing while not in a pool would cause the DHO to not be usable elsewhere in the hierarchy without being re-applied.
-            if (!IsInPool)
-                return;
-
-            free();
         }
 
         /// <summary>
@@ -402,8 +350,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         private void onDefaultsApplied(HitObject hitObject)
         {
-            Debug.Assert(lifetimeEntry != null);
-            Apply(lifetimeEntry);
+            Debug.Assert(Entry != null);
+            Apply(Entry);
 
             DefaultsApplied?.Invoke(this);
         }
@@ -486,7 +434,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         /// <summary>
         /// Apply (generally fade-in) transforms leading into the <see cref="HitObject"/> start time.
-        /// The local drawable hierarchy is recursively delayed to <see cref="LifetimeStart"/> for convenience.
+        /// The local drawable hierarchy is recursively delayed to <see cref="HitObjectLifetimeEntry.LifetimeStart"/> for convenience.
         ///
         /// By default this will fade in the object from zero with no duration.
         /// </summary>
@@ -661,30 +609,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </remarks>
         protected internal new ScheduledDelegate Schedule(Action action) => base.Schedule(action);
 
-        public override double LifetimeStart
-        {
-            get => base.LifetimeStart;
-            set => setLifetime(value, LifetimeEnd);
-        }
-
-        public override double LifetimeEnd
-        {
-            get => base.LifetimeEnd;
-            set => setLifetime(LifetimeStart, value);
-        }
-
-        private void setLifetime(double lifetimeStart, double lifetimeEnd)
-        {
-            base.LifetimeStart = lifetimeStart;
-            base.LifetimeEnd = lifetimeEnd;
-
-            if (lifetimeEntry != null)
-            {
-                lifetimeEntry.LifetimeStart = lifetimeStart;
-                lifetimeEntry.LifetimeEnd = lifetimeEnd;
-            }
-        }
-
         /// <summary>
         /// A safe offset prior to the start time of <see cref="HitObject"/> at which this <see cref="DrawableHitObject"/> may begin displaying contents.
         /// By default, <see cref="DrawableHitObject"/>s are assumed to display their contents within 10 seconds prior to the start time of <see cref="HitObject"/>.
@@ -692,7 +616,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <remarks>
         /// This is only used as an optimisation to delay the initial update of this <see cref="DrawableHitObject"/> and may be tuned more aggressively if required.
         /// It is indirectly used to decide the automatic transform offset provided to <see cref="UpdateInitialTransforms"/>.
-        /// A more accurate <see cref="LifetimeStart"/> should be set for further optimisation (in <see cref="LoadComplete"/>, for example).
+        /// A more accurate <see cref="HitObjectLifetimeEntry.LifetimeStart"/> should be set for further optimisation (in <see cref="LoadComplete"/>, for example).
         /// <para>
         /// Only has an effect if this <see cref="DrawableHitObject"/> is not being pooled.
         /// For pooled <see cref="DrawableHitObject"/>s, use <see cref="HitObjectLifetimeEntry.InitialLifetimeOffset"/> instead.
@@ -808,9 +732,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         private void ensureEntryHasResult()
         {
-            Debug.Assert(lifetimeEntry != null);
-            lifetimeEntry.Result ??= CreateResult(HitObject.CreateJudgement())
-                                     ?? throw new InvalidOperationException($"{GetType().ReadableName()} must provide a {nameof(JudgementResult)} through {nameof(CreateResult)}.");
+            Debug.Assert(Entry != null);
+            Entry.Result ??= CreateResult(HitObject.CreateJudgement())
+                             ?? throw new InvalidOperationException($"{GetType().ReadableName()} must provide a {nameof(JudgementResult)} through {nameof(CreateResult)}.");
         }
 
         protected override void Dispose(bool isDisposing)
diff --git a/osu.Game/Rulesets/Objects/Pooling/DrawableObject.cs b/osu.Game/Rulesets/Objects/Pooling/DrawableObject.cs
new file mode 100644
index 0000000000..b29e6a6c3c
--- /dev/null
+++ b/osu.Game/Rulesets/Objects/Pooling/DrawableObject.cs
@@ -0,0 +1,121 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System.Diagnostics;
+using osu.Framework.Graphics.Performance;
+using osu.Framework.Graphics.Pooling;
+
+namespace osu.Game.Rulesets.Objects.Pooling
+{
+    /// <summary>
+    /// A <see cref="PoolableDrawable"/> that is controlled by <see cref="Entry"/> to implement drawable pooling and replay rewinding.
+    /// </summary>
+    /// <typeparam name="TEntry">The <see cref="LifetimeEntry"/> type storing state and controlling this drawable.</typeparam>
+    public abstract class DrawableObject<TEntry> : PoolableDrawable where TEntry : LifetimeEntry
+    {
+        /// <summary>
+        /// The entry holding essential state of this <see cref="DrawableObject{TEntry}"/>.
+        /// </summary>
+        protected TEntry? Entry { get; private set; }
+
+        /// <summary>
+        /// Whether <see cref="Entry"/> is applied to this <see cref="DrawableObject{TEntry}"/>.
+        /// When an initial entry is specified in the constructor, <see cref="Entry"/> is set but not applied until loading is completed.
+        /// </summary>
+        protected bool HasEntryApplied { get; private set; }
+
+        public override double LifetimeStart
+        {
+            get => base.LifetimeStart;
+            set => setLifetime(value, LifetimeEnd);
+        }
+
+        public override double LifetimeEnd
+        {
+            get => base.LifetimeEnd;
+            set => setLifetime(LifetimeStart, value);
+        }
+
+        public override bool RemoveWhenNotAlive => false;
+        public override bool RemoveCompletedTransforms => false;
+
+        protected DrawableObject(TEntry? initialEntry = null)
+        {
+            Entry = initialEntry;
+        }
+
+        protected override void LoadAsyncComplete()
+        {
+            base.LoadAsyncComplete();
+
+            if (Entry != null && !HasEntryApplied)
+                Apply(Entry);
+        }
+
+        /// <summary>
+        /// Applies a new entry to be represented by this drawable.
+        /// If there is an existing entry applied, the entry will be replaced.
+        /// </summary>
+        public void Apply(TEntry entry)
+        {
+            freeIfInUse();
+
+            setLifetime(entry.LifetimeStart, entry.LifetimeEnd);
+            Entry = entry;
+
+            OnApply(entry);
+
+            HasEntryApplied = true;
+        }
+
+        protected sealed override void FreeAfterUse()
+        {
+            base.FreeAfterUse();
+
+            if (IsInPool)
+                freeIfInUse();
+        }
+
+        /// <summary>
+        /// Invoked to apply a new entry to this drawable.
+        /// </summary>
+        protected virtual void OnApply(TEntry entry)
+        {
+        }
+
+        /// <summary>
+        /// Invoked to revert application of the entry to this drawable.
+        /// </summary>
+        protected virtual void OnFree(TEntry entry)
+        {
+        }
+
+        private void setLifetime(double start, double end)
+        {
+            base.LifetimeStart = start;
+            base.LifetimeEnd = end;
+
+            if (Entry != null)
+            {
+                Entry.LifetimeStart = start;
+                Entry.LifetimeEnd = end;
+            }
+        }
+
+        private void freeIfInUse()
+        {
+            if (!HasEntryApplied) return;
+
+            Debug.Assert(Entry != null);
+
+            OnFree(Entry);
+
+            Entry = null;
+            setLifetime(double.MaxValue, double.MaxValue);
+
+            HasEntryApplied = false;
+        }
+    }
+}