Remove AtomicCounter to reduce draw node object allocations slightly

osu.Framework/Graphics/DrawNode.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics.OpenGL;
 using System;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.OpenGL;
 using osu.Framework.Graphics.OpenGL.Buffers;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.OpenGL.Vertices;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osuTK;
 
···
         /// </summary>
         protected IDrawable Source { get; private set; }
 
-        private readonly AtomicCounter referenceCount = new AtomicCounter();
+        private long referenceCount;
 
         /// <summary>
         /// The depth at which drawing should take place.
···
         /// <remarks>
         /// All <see cref="DrawNode"/>s start with a reference count of 1.
         /// </remarks>
-        internal void Reference() => referenceCount.Increment();
+        internal void Reference() => Interlocked.Increment(ref referenceCount);
 
         protected internal bool IsDisposed { get; private set; }
 
         public void Dispose()
         {
-            if (referenceCount.Decrement() != 0)
+            if (Interlocked.Decrement(ref referenceCount) != 0)
                 return;
 
             GLWrapper.ScheduleDisposal(() => Dispose(true));

osu.Framework/Threading/AtomicCounter.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Threading;
-
-namespace osu.Framework.Threading
-{
-    public class AtomicCounter
-    {
-        private long count;
-
-        public long Increment() => Interlocked.Increment(ref count);
-
-        public long Decrement() => Interlocked.Decrement(ref count);
-
-        public long Add(long value) => Interlocked.Add(ref count, value);
-
-        public long Reset() => Interlocked.Exchange(ref count, 0);
-
-        public long Value
-        {
-            set => Interlocked.Exchange(ref count, value);
-            get => Interlocked.Read(ref count);
-        }
-    }
-}