Block pooling and finish editor redesign

Assets/Resources/Prefabs/GameView/GameTex.renderTexture

@@ -14,8 +14,8 @@ RenderTexture:
   m_DownscaleFallback: 0
   m_IsAlphaChannelOptional: 0
   serializedVersion: 5
-  m_Width: 1189
+  m_Width: 1150
-  m_Height: 668
+  m_Height: 646
   m_AntiAliasing: 2
   m_MipCount: -1
   m_DepthStencilFormat: 92

Assets/Resources/Prefabs/GameView/OverlayTex.renderTexture

@@ -14,8 +14,8 @@ RenderTexture:
   m_DownscaleFallback: 0
   m_IsAlphaChannelOptional: 0
   serializedVersion: 5
-  m_Width: 1783
+  m_Width: 1725
-  m_Height: 1002
+  m_Height: 969
   m_AntiAliasing: 1
   m_MipCount: -1
   m_DepthStencilFormat: 92

Assets/Resources/Sprites/Editor/UI/rounded-bg-6px.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 521af96912848ef4887f49a524efb143
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Resources/Sprites/Editor/UI/rounded-bg-6px/rounded-bg-6px.png.meta

@@ -0,0 +1,345 @@
+fileFormatVersion: 2
+guid: bd48ded17f064414eb670529c2375358
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: right
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: 5695434ae09b7894888b9766c0fafe5c
+      internalID: -1106677661
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: top
+      rect:
+        serializedVersion: 2
+        x: 64
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: 1350a8d457f4c424f98c69ce6e6df1be
+      internalID: 1099965293
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: topleft
+      rect:
+        serializedVersion: 2
+        x: 128
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: 3f2592c6e00f5894ab312ff3ce6f5dc1
+      internalID: -997670817
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: topright
+      rect:
+        serializedVersion: 2
+        x: 192
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: 782584f2863184b458a12717d9678b79
+      internalID: -1853719049
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: all
+      rect:
+        serializedVersion: 2
+        x: 256
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: 0f3cd91703739b04b86d55ba7d1b25e9
+      internalID: 1401309272
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: bottom
+      rect:
+        serializedVersion: 2
+        x: 320
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: e3d49d09c750a384aac9b16bb51b26a2
+      internalID: 1782490243
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: bottomleft
+      rect:
+        serializedVersion: 2
+        x: 384
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: ed9f01dd79b2205449a42f45cb342289
+      internalID: 1973936073
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: bottomright
+      rect:
+        serializedVersion: 2
+        x: 448
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: 03b889313964dcb47baff7696505e9c8
+      internalID: -520399450
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    - serializedVersion: 2
+      name: left
+      rect:
+        serializedVersion: 2
+        x: 512
+        y: 0
+        width: 64
+        height: 64
+      alignment: 0
+      pivot: {x: 0.5, y: 0.5}
+      border: {x: 6, y: 6, z: 6, w: 6}
+      outline: []
+      physicsShape: []
+      tessellationDetail: 0
+      bones: []
+      spriteID: c40d45e6189a98a4c873384925aab9f1
+      internalID: 1937931747
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable:
+      all: 1401309272
+      bottom: 1782490243
+      bottomleft: 1973936073
+      bottomright: -520399450
+      left: 1937931747
+      right: -1106677661
+      top: 1099965293
+      topleft: -997670817
+      topright: -1853719049
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Resources/Sprites/Editor/eventObjs/blockResize.png.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 84fb27b49ee4cc148abc3d78cf2e9448
+guid: a0b769f6af690934f97fb73c271e1830
 TextureImporter:
   internalIDToNameTable: []
   externalObjects: {}
@@ -48,7 +48,7 @@ TextureImporter:
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
   spritePixelsToUnits: 100
-  spriteBorder: {x: 8, y: 8, z: 8, w: 8}
+  spriteBorder: {x: 35, y: 0, z: 35, w: 0}
   spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 1
@@ -67,7 +67,7 @@ TextureImporter:
   platformSettings:
   - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 64
+    maxTextureSize: 128
     resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 2

Assets/Scripts/LevelEditor/BeatGrid.cs

@@ -50,7 +50,7 @@ namespace HeavenStudio.Editor.Track
         {
             if (Editor.instance.fullscreen) return;
 
-            var x = Mathf.FloorToInt(contentPosX);
+            var x = Mathp.Round2Nearest(contentPosX, Timeline.instance.PixelsPerBeat);
             var pos = new Vector3(x, transform.localPosition.y, transform.localPosition.z);
             transform.localPosition = pos;
             GetComponent<RectTransform>().anchoredPosition = new Vector3(rectTransform.anchoredPosition.x, rectTransform.anchoredPosition.y, 0);
@@ -65,25 +65,23 @@ namespace HeavenStudio.Editor.Track
             var changeScale = (scrollRect.viewport.rect.size.x != lastTimelineSize || scrollRect.content.localScale.x != lastContentScale);
             if (changeScale)
             {
-                var rightSide = (scrollRect.viewport.GetComponent<RectTransform>().rect.width / scrollRect.content.localScale.x) + contentPosX;
-
                 for (int i = 0; i < Lines.Count; i++)
                     Destroy(Lines[i].gameObject);
                 Lines.Clear();
 
-                count = Mathf.RoundToInt(rightSide - contentPosX) + 2;
+                count = Mathf.RoundToInt(scrollRect.viewport.GetComponent<RectTransform>().rect.width / Timeline.instance.PixelsPerBeat) + 2;
 
                 for (int i = 0; i < count; i++)
                 {
-                    var line = Instantiate(transform.GetChild(0).gameObject, transform);
+                    var line = Instantiate(transform.GetChild(0).gameObject.GetComponent<RectTransform>(), transform);
-                    line.transform.localPosition = new Vector3(i, line.transform.localPosition.y, line.transform.localPosition.z);
+                    line.anchoredPosition = new Vector3(i * Timeline.instance.PixelsPerBeat, line.transform.localPosition.y, line.transform.localPosition.z);
 
                     var halfBeatRect = line.transform.GetChild(2).GetComponent<RectTransform>();
-                    halfBeatRect.anchoredPosition = new Vector3(scrollRect.content.localScale.x * 0.5f, halfBeatRect.anchoredPosition.y);
+                    halfBeatRect.anchoredPosition = new Vector3(Timeline.instance.PixelsPerBeat * 0.5f, halfBeatRect.anchoredPosition.y);
                     
-                    line.SetActive(true);
+                    line.gameObject.SetActive(true);
 
-                    Lines.Add(line);
+                    Lines.Add(line.gameObject);
                 }
                 UpdateGridNum();
 
@@ -106,7 +104,7 @@ namespace HeavenStudio.Editor.Track
                 var line = Lines[i];
                 if (line.transform.childCount == 0) continue;
 
-                var newNum = Mathf.RoundToInt(rectTransform.anchoredPosition.x + ((i) / snap));
+                var newNum = Mathf.RoundToInt((rectTransform.anchoredPosition.x / Timeline.instance.PixelsPerBeat) + ((i) / snap));
                 line.transform.GetChild(0).GetComponent<TMP_Text>().text = newNum.ToString(CultureInfo.CurrentCulture);
             }
         }

Assets/Scripts/LevelEditor/Commands/Block.cs

@@ -100,7 +100,7 @@ namespace HeavenStudio.Editor.Commands
         {
             if (pos[id].eventObj == null)
             {
-                pos[id].eventObj = Timeline.instance.eventObjs.Find(c => c.eventObjID == pos[id].eventObj.eventObjID);
+                // pos[id].eventObj = Timeline.instance.eventObjs.Find(c => c.eventObjID == pos[id].eventObj.eventObjID);
             }
         }
     }

Assets/Scripts/LevelEditor/Selections.cs

@@ -38,6 +38,7 @@ namespace HeavenStudio.Editor
         {
             DeselectAll();
             eventsSelected.Add(eventToAdd);
+            eventToAdd.selected = true;
 
             // CommandManager.instance.Execute(new Commands.Selection(new List<TimelineEventObj>() { eventToAdd } ));
         }
@@ -46,10 +47,12 @@ namespace HeavenStudio.Editor
         {
             if (!eventsSelected.Contains(eventToAdd))
             {
+                eventToAdd.selected = true;
                 eventsSelected.Add(eventToAdd);
             }
             else
             {
+                eventToAdd.selected = false;
                 eventsSelected.Remove(eventToAdd);
             }
         }
@@ -58,6 +61,7 @@ namespace HeavenStudio.Editor
         {
             if (!eventsSelected.Contains(eventToAdd))
             {
+                eventToAdd.selected = true;
                 eventsSelected.Add(eventToAdd);
             }
         }
@@ -67,11 +71,18 @@ namespace HeavenStudio.Editor
             DeselectAll();
             var eventObjs = Timeline.instance.eventObjs;
             for (int i = 0; i < eventObjs.Count; i++)
+            {
+                eventObjs[i].selected = true;
                 eventsSelected.Add(eventObjs[i]);
+            }
         }
 
         public void DeselectAll()
         {
+            foreach (var @event in eventsSelected)
+            {
+                @event.selected = false;
+            }
             eventsSelected.Clear();
         }
 
@@ -79,6 +90,7 @@ namespace HeavenStudio.Editor
         {
             if (eventsSelected.Contains(eventToDeselect))
             {
+                eventToDeselect.selected = false;
                 eventsSelected.Remove(eventToDeselect);
             }
         }

Assets/Scripts/LevelEditor/Timeline/KeepSizeRelativeToContent.cs

@@ -1,32 +0,0 @@
-using UnityEngine;
-using UnityEngine.UI;
-
-namespace HeavenStudio.Editor.Track
-{
-    public class KeepSizeRelativeToContent : MonoBehaviour
-    {
-        private RectTransform rectTransform;
-
-        public float sizeDeltaXInternal;
-
-        public float sizeDeltaX = 1.0f;
-        public float multiply;
-
-        private void Start()
-        {
-            rectTransform = GetComponent<RectTransform>();
-            SetScale(Timeline.instance.TimelineContent.localScale.x);
-        }
-
-        private void LateUpdate()
-        {
-            SetScale(Timeline.instance.TimelineContent.localScale.x);
-        }
-
-        private void SetScale(float scale)
-        {
-            rectTransform.localScale = new Vector3((1.0f / scale) * multiply, transform.localScale.y, 1);
-            LayoutRebuilder.ForceRebuildLayoutImmediate(rectTransform);
-        }
-    }
-}

Assets/Scripts/LevelEditor/Timeline/Timeline.cs

@@ -9,6 +9,9 @@ using TMPro;
 using Starpelly;
 using Jukebox;
 using Jukebox.Legacy;
+using UnityEditor;
+using static HeavenStudio.Minigames;
+using static HeavenStudio.Util.BeatAction;
 
 namespace HeavenStudio.Editor.Track
 {
@@ -20,8 +23,6 @@ namespace HeavenStudio.Editor.Track
         [SerializeField] private TMP_Text CurrentTempo;
 
         [Header("Timeline Properties")]
-        private float lastBeatPos = 0;
-        private Vector2 lastMousePos;
         public List<TimelineEventObj> eventObjs = new List<TimelineEventObj>();
         private bool lastFrameDrag;
         public int LayerCount = 5;
@@ -35,6 +36,16 @@ namespace HeavenStudio.Editor.Track
         [SerializeField] private RawImage waveform;
         public Texture2D resizeCursor;
 
+        public float WidthPerBeat { get; private set; } = 100.0f;
+        public float PixelsPerBeat => WidthPerBeat * Zoom;
+        public float Zoom { get; private set; } = 1.0f;
+        public float MousePos2Beat { get; private set; }
+        public float MousePos2BeatSnap => Mathp.Round2Nearest(MousePos2Beat + (SnapInterval() * 0.5f), SnapInterval());
+
+        private Vector2 relativeMousePos;
+        public Vector2 RelativeMousePos => relativeMousePos;
+        public float PlaybackBeat = 0.0f;
+
         public static float SnapInterval() { return instance.snapInterval; }
 
         public void SetSnap(float snap) { snapInterval = snap; }
@@ -133,6 +144,7 @@ namespace HeavenStudio.Editor.Track
         [SerializeField] private ZoomComponent zoomComponent;
         [SerializeField] private RectTransform TimelineSongPosLineRef;
         [SerializeField] private RectTransform TimelineEventObjRef;
+        public RectTransform TimelineEventsHolder;
         [SerializeField] private RectTransform LayersRect;
 
         [Header("Timeline Inputs")]
@@ -162,8 +174,8 @@ namespace HeavenStudio.Editor.Track
 
         public Vector3[] LayerCorners = new Vector3[4];
 
-        public float leftSide => (TimelineContent.localPosition.x / TimelineContent.localScale.x) * -1;
+        public float leftSide => (TimelineContent.localPosition.x / PixelsPerBeat) * -1;
-        public float rightSide => (TimelineScroll.viewport.rect.width / TimelineContent.localScale.x) + leftSide;
+        public float rightSide => (TimelineScroll.viewport.rect.width / PixelsPerBeat) + leftSide;
         
         public static Timeline instance { get; private set; }
 
@@ -187,12 +199,16 @@ namespace HeavenStudio.Editor.Track
             }
             eventObjs.Clear();
 
+            /*
             for (int i = 0; i < GameManager.instance.Beatmap.Entities.Count; i++)
             {
                 var e = GameManager.instance.Beatmap.Entities[i];
 
                 AddEventObject(e.datamodel, false, new Vector3((float)e.beat, -e["track"] * LayerHeight()), e, false);
             }
+            */
+
+            TimelineBlockManager.Instance.Load();
 
             SpecialInfo.Setup();
             UpdateOffsetText();
@@ -318,8 +334,8 @@ namespace HeavenStudio.Editor.Track
             float songBeats = Conductor.instance.SongLengthInBeats();
             if (songBeats == 0) songBeats = 320;
             else songBeats += 10;
-            TimelineContent.sizeDelta = new Vector2(songBeats, currentSizeDelta.y);
+            TimelineContent.sizeDelta = new Vector2(songBeats * PixelsPerBeat, currentSizeDelta.y);
-            TimelineEventGrid.sizeDelta = new Vector2(songBeats, currentSizeDelta.y);
+            TimelineEventGrid.sizeDelta = new Vector2(songBeats * PixelsPerBeat, currentSizeDelta.y);
         }
 
         public void CreateWaveform()
@@ -349,7 +365,6 @@ namespace HeavenStudio.Editor.Track
             }
         }
 
-
         public void MetronomeToggle()
         {
             if (!Conductor.instance.metronome)
@@ -373,6 +388,10 @@ namespace HeavenStudio.Editor.Track
 
         private void Update()
         {
+            RectTransformUtility.ScreenPointToLocalPointInRectangle(TimelineContent, Input.mousePosition, Editor.instance.EditorCamera, out relativeMousePos);
+
+            MousePos2Beat = relativeMousePos.x / PixelsPerBeat;
+
             Conductor cond = Conductor.instance;
             // waveform.rectTransform.anchoredPosition = new Vector2(
             //     -(GameManager.instance.Beatmap.data.offset / (60.0f / GameManager.instance.Beatmap.bpm)), 
@@ -382,8 +401,8 @@ namespace HeavenStudio.Editor.Track
 
             if (!cond.isPlaying && !cond.isPaused)
             {
-                SongBeat.text = $"Beat {string.Format("{0:0.000}", TimelineSlider.localPosition.x)}";
+                SongBeat.text = $"Beat {string.Format("{0:0.000}", PlaybackBeat)}";
-                SongPos.text = FormatTime(cond.GetSongPosFromBeat(TimelineSlider.localPosition.x));
+                SongPos.text = FormatTime(cond.GetSongPosFromBeat(PlaybackBeat));
             }
             else
             {
@@ -465,13 +484,11 @@ namespace HeavenStudio.Editor.Track
             }
             if (movingPlayback)
             {
-                RectTransformUtility.ScreenPointToLocalPointInRectangle(TimelineContent, Input.mousePosition, Editor.instance.EditorCamera, out lastMousePos);
+                var playbackBeat = Mathf.Max(MousePos2BeatSnap, 0);
-                TimelineSlider.localPosition = new Vector3(Mathf.Max(Mathp.Round2Nearest(lastMousePos.x + 0.12f, Timeline.SnapInterval()), 0), TimelineSlider.transform.localPosition.y);
+                TimelineSlider.localPosition = new Vector3(playbackBeat * PixelsPerBeat, TimelineSlider.transform.localPosition.y);
 
-                if (TimelineSlider.localPosition.x != lastBeatPos)
+                cond.SetBeat(playbackBeat);
-                    cond.SetBeat(TimelineSlider.transform.localPosition.x);
+                this.PlaybackBeat = playbackBeat;
-
-                lastBeatPos = TimelineSlider.localPosition.x;
             }
 
             if (cond.isPlaying)
@@ -482,6 +499,8 @@ namespace HeavenStudio.Editor.Track
             CurrentTempo.text = $"    = {cond.songBpm}";
 
             LayersRect.GetWorldCorners(LayerCorners);
+
+            TimelineBlockManager.Instance.UpdateMarkers();
         }
 
         public static float GetScaleModifier()
@@ -498,12 +517,11 @@ namespace HeavenStudio.Editor.Track
 
         private void SliderControl()
         {
-            TimelinePlaybackBeat.text = $"Beat {string.Format("{0:0.000}", TimelineSlider.localPosition.x)}";
+            TimelinePlaybackBeat.text = $"Beat {string.Format("{0:0.000}", PlaybackBeat)}";
 
             if (TimelineSongPosLine != null)
             {
-                TimelineSongPosLine.transform.localPosition = new Vector3(Conductor.instance.songPositionInBeats, TimelineSongPosLine.transform.localPosition.y);
+                TimelineSongPosLine.transform.localPosition = new Vector3(Conductor.instance.songPositionInBeats * PixelsPerBeat, TimelineSongPosLine.transform.localPosition.y);
-                TimelineSongPosLine.transform.localScale = new Vector3(1f / TimelineContent.transform.localScale.x, TimelineSongPosLine.transform.localScale.y, 1);
             }
         }
 
@@ -514,11 +532,11 @@ namespace HeavenStudio.Editor.Track
             {
                 if (!Conductor.instance.isPlaying && !Conductor.instance.isPaused)
                 {
-                    Play(false, TimelineSlider.transform.localPosition.x);
+                    Play(false, PlaybackBeat);
                 }
                 else
                 {
-                    Stop(TimelineSlider.transform.localPosition.x);
+                    Stop(PlaybackBeat);
                 }
                     
             }
@@ -528,11 +546,11 @@ namespace HeavenStudio.Editor.Track
                 {
                     if (TimelineSongPosLine == null)
                     {
-                        Play(false, TimelineSlider.transform.localPosition.x);
+                        Play(false, PlaybackBeat);
                     }
                     else
                     {
-                        Play(false, TimelineSongPosLine.transform.localPosition.x);
+                        Play(false, Conductor.instance.songPositionInBeats);
                     }
                 }
                 else if (!Conductor.instance.isPaused)
@@ -637,7 +655,7 @@ namespace HeavenStudio.Editor.Track
         {
             var lerpSpd = (lerp) ? 12f : 10000000; // im lazy
 
-            var newPos = new Vector3((-Conductor.instance.songPositionInBeats * TimelineContent.localScale.x) + 200, TimelineContent.transform.localPosition.y);
+            var newPos = new Vector3((-Conductor.instance.songPositionInBeats * PixelsPerBeat) + 200, TimelineContent.transform.localPosition.y);
             TimelineContent.transform.localPosition =
                 Vector3.Lerp(TimelineContent.transform.localPosition, newPos, Time.deltaTime * lerpSpd);
         }
@@ -740,6 +758,87 @@ namespace HeavenStudio.Editor.Track
             return tex2D;
         }
 
+        public TimelineEventObj AddEventObject(string eventName, bool dragNDrop = false, Vector3 pos = new Vector3(), RiqEntity entity = null, bool addEvent = false)
+        {
+            var game = EventCaller.instance.GetMinigame(eventName.Split(0));
+            var action = EventCaller.instance.GetGameAction(game, eventName.Split(1));
+
+            var gameAction = EventCaller.instance.GetGameAction(EventCaller.instance.GetMinigame(eventName.Split(0)), eventName.Split(1));
+
+            if (addEvent)
+            {
+                RiqEntity tempEntity = entity;
+
+                if (entity == null)
+                {
+                    RiqEntity en = GameManager.instance.Beatmap.AddNewEntity(eventName, 0, gameAction.defaultLength);
+
+                    tempEntity = en;
+
+                    // default param values
+                    var ep = action.parameters;
+
+                    if (ep != null)
+                    {
+                        for (int i = 0; i < ep.Count; i++)
+                        {
+                            object returnVal = ep[i].parameter;
+
+                            var propertyType = returnVal.GetType();
+                            if (propertyType == typeof(EntityTypes.Integer))
+                            {
+                                returnVal = ((EntityTypes.Integer)ep[i].parameter).val;
+                            }
+                            else if (propertyType == typeof(EntityTypes.Float))
+                            {
+                                returnVal = ((EntityTypes.Float)ep[i].parameter).val;
+                            }
+                            else if (propertyType.IsEnum)
+                            {
+                                returnVal = (int)ep[i].parameter;
+                            }
+
+                            //tempEntity[ep[i].propertyName] = returnVal;
+                            tempEntity.CreateProperty(ep[i].propertyName, returnVal);
+                        }
+                    }
+                }
+                else
+                {
+                    GameManager.instance.Beatmap.Entities.Add(tempEntity);
+                }
+
+                GameManager.instance.SortEventsList();
+                TimelineBlockManager.Instance.SetEntityToSet(tempEntity);
+            }
+            else
+            {
+                TimelineBlockManager.Instance.SetEntityToSet(entity);
+            }
+
+            var marker = TimelineBlockManager.Instance.Pool.Get();
+
+            
+
+
+            marker.SetMarkerInfo();
+
+            if (dragNDrop)
+            {
+                Selections.instance.ClickSelect(marker);
+                marker.moving = true;
+            }
+            else
+            {
+                entity["track"] = marker.GetTrack();
+            }
+
+            eventObjs.Add(marker);
+
+            return marker;
+        }
+
+        /*
         public TimelineEventObj AddEventObject(string eventName, bool dragNDrop = false, Vector3 pos = new Vector3(), RiqEntity entity = null, bool addEvent = false)
         {
             var game = EventCaller.instance.GetMinigame(eventName.Split(0));
@@ -761,7 +860,7 @@ namespace HeavenStudio.Editor.Track
             {
                 if (gameAction.resizable == false)
                 {
-                    g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength, LayerHeight());
+                    g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength * Timeline.instance.PixelsPerBeat, LayerHeight());
                     float length = gameAction.defaultLength;
                     eventObj.length = length;
                 }
@@ -770,11 +869,11 @@ namespace HeavenStudio.Editor.Track
                     eventObj.resizable = true;
                     if (entity != null && gameAction.defaultLength != entity.length && dragNDrop == false)
                     {
-                        g.GetComponent<RectTransform>().sizeDelta = new Vector2(entity.length, LayerHeight());
+                        g.GetComponent<RectTransform>().sizeDelta = new Vector2(entity.length * Timeline.instance.PixelsPerBeat, LayerHeight());
                     }
                     else
                     {
-                        g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength, LayerHeight());
+                        g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength * Timeline.instance.PixelsPerBeat, LayerHeight());
                     }
                 }
             }
@@ -850,6 +949,7 @@ namespace HeavenStudio.Editor.Track
 
             return eventObj;
         }
+        */
 
         private List<TimelineEventObj> duplicatedEventObjs = new List<TimelineEventObj>();
         public TimelineEventObj CopyEventObject(TimelineEventObj e)

Assets/Scripts/LevelEditor/Timeline/TimelineBlockManager.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Pool;
+
+using Jukebox;
+using static System.Windows.Forms.VisualStyles.VisualStyleElement.Header;
+
+namespace HeavenStudio.Editor.Track
+{
+    public class TimelineBlockManager : MonoBehaviour
+    {
+        public static TimelineBlockManager Instance { get; private set; }
+
+        public TimelineEventObj EntityTemplate;
+        public Dictionary<int, TimelineEventObj> EntityMarkers = new();
+        public ObjectPool<TimelineEventObj> Pool { get; private set; }
+
+        private int firstMarkerToCareAbout = 0;
+        private int lastMarkerToCareAbout = 0;
+        private Timeline timeline;
+
+        private RiqEntity entityToSet;
+
+        public void SetEntityToSet(RiqEntity entity)
+        {
+            entityToSet = entity;
+        }
+
+        private void Awake()
+        {
+            Instance = this;
+
+            timeline = GetComponent<Timeline>();
+
+            Pool = new ObjectPool<TimelineEventObj>(CreateMarker, OnTakeMarkerFromPool, OnReturnMarkerToPool, OnDestroyMarker, true, 125, 1500);
+        }
+
+        public void Load()
+        {
+            var timeLeft = timeline.leftSide;
+            var timeRight = timeline.rightSide;
+
+            foreach (var marker in EntityMarkers)
+            {
+                Destroy(marker.Value.gameObject);
+            }
+
+            EntityMarkers.Clear();
+            Pool.Clear();
+
+            foreach (var entity in GameManager.instance.Beatmap.Entities)
+            {
+                var vLeft = entity.beat + entity.length >= timeLeft;
+                var vRight = entity.beat < timeRight;
+                var active = vLeft && vRight;
+
+                if (!active) continue;
+
+                entityToSet = entity;
+                Pool.Get();
+            }
+        }
+
+        public void UpdateMarkers()
+        {
+            var timeLeft = timeline.leftSide;
+            var timeRight = timeline.rightSide;
+
+            for (var i = 0; i < GameManager.instance.Beatmap.Entities.Count; i++)
+            {
+                var entity = GameManager.instance.Beatmap.Entities[i];
+
+                var vLeft = entity.beat + entity.length >= timeLeft;
+                var vRight = entity.beat < timeRight;
+                var active = vLeft && vRight;
+
+                var containsMarker = EntityMarkers.ContainsKey(entity.uid);
+
+                if (containsMarker)
+                {
+                    var marker = EntityMarkers[entity.uid];
+                    if (marker.selected || marker.moving) active = true;
+                }
+
+                if (active)
+                {
+                    if (!containsMarker)
+                    {
+                        entityToSet = entity;
+                        Pool.Get();
+                    }
+                    EntityMarkers[entity.uid].UpdateMarker();
+                }
+                else
+                {
+                    if (EntityMarkers.ContainsKey(entity.uid))
+                        Pool.Release(EntityMarkers[entity.uid]);
+                }
+            }
+        }
+
+        private TimelineEventObj CreateMarker()
+        {
+            TimelineEventObj marker = Instantiate(EntityTemplate.gameObject, Timeline.instance.TimelineEventsHolder).GetComponent<TimelineEventObj>();
+            return marker;
+        }
+
+        private void OnTakeMarkerFromPool(TimelineEventObj marker)
+        {
+            marker.SetEntity(entityToSet);
+            marker.SetMarkerInfo();
+
+            marker.gameObject.SetActive(true);
+            EntityMarkers.Add(entityToSet.uid, marker);
+        }
+
+        private void OnReturnMarkerToPool(TimelineEventObj marker)
+        {
+            EntityMarkers.Remove(marker.entity.uid);
+            marker.gameObject.SetActive(false);
+        }
+
+        private void OnDestroyMarker(TimelineEventObj marker)
+        {
+            Destroy(marker.gameObject);
+        }
+    }
+}

Assets/Scripts/LevelEditor/Timeline/TimelineBlockManager.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 0ebb4f22da63ed144917cdff47f9c93c
+guid: e14b50f4d0b2ac54aaaf3aedaeefd04d
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/Scripts/LevelEditor/Timeline/TimelineEventObj.cs

@@ -23,19 +23,12 @@ namespace HeavenStudio.Editor.Track
         [SerializeField] private Image selectedImage;
         [SerializeField] public TMP_Text eventLabel;
 
-        [SerializeField] private RectTransform resizeGraphicHolder;
+        [SerializeField] private Image resizeGraphic;
-        [SerializeField] private RectTransform resizeGraphicLeft;
-        [SerializeField] private RectTransform resizeGraphicRight;
-        [SerializeField] private RectTransform resizeGraphicLine;
 
         [SerializeField] private RectTransform leftDrag;
         [SerializeField] private RectTransform rightDrag;
 
-        [SerializeField] private RectTransform outline;
+        [SerializeField] private Image outline;
-        [SerializeField] private RectTransform outline1;
-        [SerializeField] private RectTransform outline2;
-        [SerializeField] private RectTransform outline3;
-        [SerializeField] private RectTransform outline4;
 
         // private GameObject moveTemp;
 
@@ -54,109 +47,66 @@ namespace HeavenStudio.Editor.Track
         private bool resizingRight;
         private bool inResizeRegion;
         public bool isCreating;
-        public int eventObjID;
 
-        Timeline tl;
         float leftSide, rightSide;
 
         [Header("Colors")]
         public Color NormalCol;
 
-        private void Start()
+        public void SetMarkerInfo()
         {
             moveStartPos = transform.localPosition;
-
             rectTransform = GetComponent<RectTransform>();
 
-            if (!resizable)
+            var eventName = entity.datamodel;
+
+            var game = EventCaller.instance.GetMinigame(eventName.Split(0));
+            var action = EventCaller.instance.GetGameAction(game, eventName.Split(1));
+            var gameAction = EventCaller.instance.GetGameAction(EventCaller.instance.GetMinigame(eventName.Split(0)), eventName.Split(1));
+
+            if (eventName.Split(1) == "switchGame")
+                Icon.sprite = Editor.GameIcon(eventName.Split(2));
+            else
+                Icon.sprite = Editor.GameIcon(eventName.Split(0));
+
+            if (gameAction != null)
             {
-                Destroy(resizeGraphicHolder.gameObject);
+                if (gameAction.resizable == false)
+                {
+                    rectTransform.sizeDelta = new Vector2(gameAction.defaultLength * Timeline.instance.PixelsPerBeat, Timeline.instance.LayerHeight());
+                    this.length = gameAction.defaultLength;
+                }
+                else
+                {
+                    this.resizable = true;
+                    if (entity != null && gameAction.defaultLength != entity.length)
+                    {
+                        rectTransform.sizeDelta = new Vector2(entity.length * Timeline.instance.PixelsPerBeat, Timeline.instance.LayerHeight());
+                    }
+                    else
+                    {
+                        rectTransform.sizeDelta = new Vector2(gameAction.defaultLength * Timeline.instance.PixelsPerBeat, Timeline.instance.LayerHeight());
+                    }
+                }
             }
 
-            // what the fuck???? -- I wonder if I wrote this?
+            rectTransform.anchoredPosition = new Vector2((float)entity.beat * Timeline.instance.PixelsPerBeat, -entity["track"] * Timeline.instance.LayerHeight());
-            // moveTemp = new GameObject();
+            resizeGraphic.gameObject.SetActive(resizable);
-            // moveTemp.transform.SetParent(this.transform.parent);
+            eventLabel.text = action.displayName;
 
-            bool visible = rectTransform.IsVisibleFrom(Editor.instance.EditorCamera);
+            SetColor((int)entity["track"]);
-            for (int i = 0; i < this.transform.childCount; i++)
-            {
-                if (i != 4)
-                    this.transform.GetChild(i).gameObject.SetActive(visible);
-            }
-
-            tl = Timeline.instance;
         }
 
-        private void Update()
+        public void SetEntity(RiqEntity entity)
         {
-            if (tl == null)
+            this.entity = entity;
-                tl = Timeline.instance;
+        }
 
-            selected = Selections.instance.eventsSelected.Contains(this);
+        public void UpdateMarker()
-            if (eventObjID != entity.uid)
+        {
-            {
+            mouseHovering = Timeline.instance.timelineState.selected && RectTransformUtility.RectangleContainsScreenPoint(rectTransform, Input.mousePosition, Editor.instance.EditorCamera);
-                eventObjID = GameManager.instance.Beatmap.Entities.Find(a => a == entity).uid;
-                Debug.Log($"assigning uid {eventObjID}");
-            }
 
-            mouseHovering = tl.timelineState.selected && RectTransformUtility.RectangleContainsScreenPoint(rectTransform, Input.mousePosition, Editor.instance.EditorCamera);
 
-            #region Optimizations
-
-            // thank you to @chrislo27 for suggesting the fix for this.
-            // only renders blocks if they're in view of the timeline viewport
-            leftSide = rectTransform.localPosition.x;
-            rightSide = leftSide + rectTransform.sizeDelta.x;
-
-            bool visible = rightSide >= tl.leftSide && leftSide <= tl.rightSide;
-
-            if (visible != lastVisible)
-            {
-                for (int i = 0; i < this.transform.childCount; i++)
-                {
-                    // if (transform.GetChild(i).gameObject != selectedImage)
-                    this.transform.GetChild(i).gameObject.SetActive(visible);
-                }
-            }
-
-            lastVisible = visible;
-
-            #endregion
-
-            // We need a helper function for this
-            // I'm aware how messy this is, but considering this is all going to be destroyed in a while and nobody
-            // wants to touch it, I think it's fine.
-            if (visible)
-            {
-                var timelineScale = 100.0f / Timeline.instance.TimelineContent.localScale.x;
-                Icon.rectTransform.localScale = new Vector3(timelineScale, Icon.rectTransform.localScale.y, Icon.rectTransform.localScale.z);
-                Icon.rectTransform.anchoredPosition = new Vector2(0.08f * timelineScale, Icon.rectTransform.anchoredPosition.y);
-
-                if (resizeGraphicHolder != null)
-                {
-                    resizeGraphicHolder.offsetMin = new Vector2(0.04f * timelineScale, resizeGraphicHolder.offsetMin.y);
-                    resizeGraphicHolder.offsetMax = new Vector2(0.04f * -timelineScale, resizeGraphicHolder.offsetMax.y);
-                    resizeGraphicLeft.localScale = new Vector3(timelineScale, resizeGraphicLeft.localScale.y, resizeGraphicLeft.localScale.z);
-                    resizeGraphicRight.localScale = new Vector3(-timelineScale, resizeGraphicRight.localScale.y, resizeGraphicRight.localScale.z);
-                    resizeGraphicLine.offsetMin = new Vector2(0.132f * timelineScale, resizeGraphicLine.offsetMin.y);
-                    resizeGraphicLine.offsetMax = new Vector2(0.132f * -timelineScale, resizeGraphicLine.offsetMax.y);
-                }
-
-                eventLabel.rectTransform.offsetMax = new Vector2(0.04f * -timelineScale, eventLabel.rectTransform.offsetMax.y);
-                eventLabel.rectTransform.localScale = new Vector3(timelineScale * 0.01f, eventLabel.rectTransform.localScale.y, eventLabel.rectTransform.localScale.z);
-
-                outline1.localScale = new Vector3(timelineScale, outline1.localScale.y, outline1.localScale.z);
-                outline2.localScale = new Vector3(timelineScale, outline2.localScale.y, outline2.lossyScale.z);
-                outline3.offsetMin = new Vector2(0.04f * timelineScale, outline3.offsetMin.y);
-                outline3.offsetMax = new Vector2(0.04f * -timelineScale, outline3.offsetMax.y);
-                outline4.offsetMin = new Vector2(0.04f * timelineScale, outline4.offsetMin.y);
-                outline4.offsetMax = new Vector2(0.04f * -timelineScale, outline4.offsetMax.y);
-
-                leftDrag.localScale = new Vector3(timelineScale, leftDrag.localScale.y, leftDrag.localScale.z);
-                rightDrag.localScale = new Vector3(timelineScale, rightDrag.localScale.y, rightDrag.localScale.z);
-
-                SetColor(entity["track"]);
-            }
 
             if (selected)
             {
@@ -164,25 +114,21 @@ namespace HeavenStudio.Editor.Track
                 if (Input.GetKeyDown(KeyCode.Delete))
                 {
                     Selections.instance.Deselect(this);
-                    tl.DestroyEventObject(entity);
+                    Timeline.instance.DestroyEventObject(entity);
                 }
                 */
 
                 selectedImage.gameObject.SetActive(true);
-                for (int i = 0; i < outline.childCount; i++)
+                if (moving)
-                {
+                    outline.color = Color.magenta;
-                    if (moving)
+                else
-                        outline.GetChild(i).GetComponent<Image>().color = Color.magenta;
+                    outline.color = Color.cyan;
-                    else
-                        outline.GetChild(i).GetComponent<Image>().color = Color.cyan;
-                }
             }
             else
             {
                 selectedImage.gameObject.SetActive(false);
 
-                for (int i = 0; i < outline.childCount; i++)
+                outline.color = new Color32(0, 0, 0, 51);
-                    outline.GetChild(i).GetComponent<Image>().color = new Color32(0, 0, 0, 51);
             }
 
             if (Conductor.instance.NotStopped())
@@ -198,19 +144,36 @@ namespace HeavenStudio.Editor.Track
                 {
                     selected = false;
                     selectedImage.gameObject.SetActive(false);
-                    for (int i = 0; i < outline.childCount; i++)
+                    outline.color = new Color32(0, 0, 0, 51);
-                        outline.GetChild(i).GetComponent<Image>().color = new Color32(0, 0, 0, 51);
                 }
 
-                rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, tl.LayerHeight());
+
-                this.transform.localPosition = new Vector3(this.transform.localPosition.x, -entity["track"] * tl.LayerHeight());
+                // rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, Timeline.instance.LayerHeight());
+                // this.transform.localPosition = new Vector3(this.transform.localPosition.x, -entity["track"] * Timeline.instance.LayerHeight());
                 return;
             }
 
-            if (!resizing)
+            if (resizing)
+            {
+                if (moving) moving = false;
+                if (resizingLeft) SetPivot(new Vector2(1, rectTransform.pivot.y));
+
+                Vector2 sizeDelta = rectTransform.sizeDelta;
+                Vector2 mousePos;
+
+                RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, Input.mousePosition, Editor.instance.EditorCamera, out mousePos);
+
+                sizeDelta = new Vector2((resizingLeft ? -mousePos.x : mousePos.x) + 0.15f, sizeDelta.y);
+                sizeDelta = new Vector2(Mathf.Clamp(sizeDelta.x, Timeline.SnapInterval(), resizingLeft ? rectTransform.localPosition.x : Mathf.Infinity), sizeDelta.y);
+
+                rectTransform.sizeDelta = new Vector2(Mathp.Round2Nearest(sizeDelta.x, Timeline.SnapInterval()), sizeDelta.y);
+                SetPivot(new Vector2(0, rectTransform.pivot.y));
+                OnComplete(false);
+            }
+            else
             {
                 int count = 0;
-                foreach (TimelineEventObj e in tl.eventObjs)
+                foreach (TimelineEventObj e in Timeline.instance.eventObjs)
                 {
                     if (e.moving)
                     {
@@ -231,7 +194,7 @@ namespace HeavenStudio.Editor.Track
                         transform.localPosition = moveStartPos;
                         OnComplete(false);
 
-                        TimelineEventObj te = tl.CopyEventObject(this);
+                        TimelineEventObj te = Timeline.instance.CopyEventObject(this);
                         TimelineEventObj obj;
 
                         Selections.instance.DragSelect(te);
@@ -240,9 +203,9 @@ namespace HeavenStudio.Editor.Track
                         te.transform.localPosition = transform.localPosition;
                         te.moveStartPos = transform.localPosition;
 
-                        for (int i = 0; i < tl.eventObjs.Count; i++)
+                        for (int i = 0; i < Timeline.instance.eventObjs.Count; i++)
                         {
-                            obj = tl.eventObjs[i];
+                            obj = Timeline.instance.eventObjs[i];
                             obj.startPosX = mousePos.x - obj.transform.position.x;
                             obj.startPosY = mousePos.y - obj.transform.position.y;
                         }
@@ -252,7 +215,7 @@ namespace HeavenStudio.Editor.Track
                     else
                     {
                         this.transform.position = new Vector3(mousePos.x - startPosX, mousePos.y - startPosY - 0.40f, 0);
-                        this.transform.localPosition = new Vector3(Mathf.Max(Mathp.Round2Nearest(this.transform.localPosition.x, Timeline.SnapInterval()), 0), tl.SnapToLayer(this.transform.localPosition.y));
+                        this.transform.localPosition = new Vector3(Mathf.Max(Mathp.Round2Nearest(this.transform.localPosition.x, Timeline.SnapInterval()), 0), Timeline.instance.SnapToLayer(this.transform.localPosition.y));
                     }
 
                     if (lastPos != transform.localPosition)
@@ -263,23 +226,6 @@ namespace HeavenStudio.Editor.Track
                     lastPos = transform.localPosition;
                 }
             }
-            else
-            {
-                if (moving) moving = false;
-                if (resizingLeft) SetPivot(new Vector2(1, rectTransform.pivot.y));
-
-                Vector2 sizeDelta = rectTransform.sizeDelta;
-                Vector2 mousePos;
-
-                RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, Input.mousePosition, Editor.instance.EditorCamera, out mousePos);
-
-                sizeDelta = new Vector2((resizingLeft ? -mousePos.x : mousePos.x) + 0.15f, sizeDelta.y);
-                sizeDelta = new Vector2(Mathf.Clamp(sizeDelta.x, Timeline.SnapInterval(), resizingLeft ? rectTransform.localPosition.x : Mathf.Infinity), sizeDelta.y);
-
-                rectTransform.sizeDelta = new Vector2(Mathp.Round2Nearest(sizeDelta.x, Timeline.SnapInterval()), sizeDelta.y);
-                SetPivot(new Vector2(0, rectTransform.pivot.y));
-                OnComplete(false);
-            }
 
             if (Input.GetMouseButtonUp(0))
             {
@@ -291,7 +237,7 @@ namespace HeavenStudio.Editor.Track
             if (resizing && selected || inResizeRegion && selected)
             {
                 if (resizable)
-                    Cursor.SetCursor(tl.resizeCursor, new Vector2(14, 14), CursorMode.Auto);
+                    Cursor.SetCursor(Timeline.instance.resizeCursor, new Vector2(14, 14), CursorMode.Auto);
             }
             // should consider adding this someday
             // else if (moving && selected || mouseHovering && selected)
@@ -303,15 +249,15 @@ namespace HeavenStudio.Editor.Track
                 Cursor.SetCursor(null, Vector2.zero, CursorMode.Auto);
             }
 
-            rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, tl.LayerHeight());
+            rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, Timeline.instance.LayerHeight());
-            this.transform.localPosition = new Vector3(this.transform.localPosition.x, -entity["track"] * tl.LayerHeight());
+            this.transform.localPosition = new Vector3(this.transform.localPosition.x, -entity["track"] * Timeline.instance.LayerHeight());
         }
 
         #region ClickEvents
 
         public void OnClick()
         {
-            if (Input.GetMouseButton(0) && tl.timelineState.selected)
+            if (Input.GetMouseButton(0) && Timeline.instance.timelineState.selected)
             {
                 if (Input.GetKey(KeyCode.LeftShift))
                 {
@@ -331,15 +277,15 @@ namespace HeavenStudio.Editor.Track
         {
             if (Input.GetMouseButton(0))
             {
-                if (selected && tl.timelineState.selected)
+                if (selected && Timeline.instance.timelineState.selected)
                 {
                     moveStartPos = transform.localPosition;
 
-                    for (int i = 0; i < tl.eventObjs.Count; i++)
+                    for (int i = 0; i < Timeline.instance.eventObjs.Count; i++)
                     {
                         Vector3 mousePos = Editor.instance.EditorCamera.ScreenToWorldPoint(Input.mousePosition);
-                        tl.eventObjs[i].startPosX = mousePos.x - tl.eventObjs[i].transform.position.x;
+                        Timeline.instance.eventObjs[i].startPosX = mousePos.x - Timeline.instance.eventObjs[i].transform.position.x;
-                        tl.eventObjs[i].startPosY = mousePos.y - tl.eventObjs[i].transform.position.y;
+                        Timeline.instance.eventObjs[i].startPosY = mousePos.y - Timeline.instance.eventObjs[i].transform.position.y;
                     }
 
                     moving = true;
@@ -376,11 +322,11 @@ namespace HeavenStudio.Editor.Track
             // lastPos_ = this.lastPos_;
             // previousPos = this.transform.localPosition;
 
-            if (selected && tl.timelineState.selected)
+            if (selected && Timeline.instance.timelineState.selected)
             {
                 if (wasDuplicated)
                 {
-                    tl.FinalizeDuplicateEventStack();
+                    Timeline.instance.FinalizeDuplicateEventStack();
                     wasDuplicated = false;
                 }
                 if (eligibleToMove)
@@ -493,8 +439,8 @@ namespace HeavenStudio.Editor.Track
 
         private void OnComplete(bool move)
         {
-            entity.length = rectTransform.sizeDelta.x;
+            entity.length = rectTransform.sizeDelta.x / Timeline.instance.PixelsPerBeat;
-            entity.beat = this.transform.localPosition.x;
+            entity.beat = this.transform.localPosition.x / Timeline.instance.PixelsPerBeat;
             entity["track"] = GetTrack();
             
             GameManager.instance.SortEventsList();
@@ -535,9 +481,7 @@ namespace HeavenStudio.Editor.Track
             if (resizable)
             {
                 c = new Color(0, 0, 0, 0.35f);
-                transform.GetChild(1).GetChild(0).GetComponent<Image>().color = c;
+                resizeGraphic.color = c;
-                transform.GetChild(1).GetChild(1).GetComponent<Image>().color = c;
-                transform.GetChild(1).GetChild(2).GetComponent<Image>().color = c;
             }
         }