Fixed a bug where unloading assemblies caused a crash in the test patterns. Fixed another bug caused by not initializing dmx buffers linked lists to zero.

2019-12-26 18:40:14 -08:00 · 2019-12-26 18:40:14 -08:00 · 76d27e3b57
parent 2c6adaeda2
commit 76d27e3b57
7 changed files with 185 additions and 101 deletions
--- a/src/animation/foldhaus_animation.h
+++ b/src/animation/foldhaus_animation.h
@ -5,7 +5,7 @@
 // [] - will need a way to create an empty layer
 // [] - get a list of all animation procs

-#define ANIMATION_PROC(name) void name(app_state* State, r32 Time)
+#define ANIMATION_PROC(name) void name(assembly* Assembly, r32 Time)
 typedef ANIMATION_PROC(animation_proc);

 struct animation_block
@ -46,6 +46,7 @@ u32 BlocksCount;
 b32 TimelineShouldAdvance;

 // :Temporary
+    r32 AnimationStart;
 r32 AnimationEnd;
 };

--- a/src/foldhaus_app.cpp
+++ b/src/foldhaus_app.cpp
@ -277,25 +277,20 @@ INITIALIZE_APPLICATION(InitializeApplication)
        InitializeAnimationSystem(&State->AnimationSystem);
 State->AnimationSystem.SecondsPerFrame = 1.f / 24.f;
        
-        animation_block BlockZero = {0}; 
-        BlockZero.StartTime = 0;
-        BlockZero.EndTime = 2;
-        BlockZero.Proc = TestPatternOne;
-        AddAnimationBlock(BlockZero, &State->AnimationSystem);
-        
        animation_block BlockOne = {0}; 
-        BlockOne.StartTime = 3;
-        BlockOne.EndTime = 5;
+        BlockOne.StartTime = 0;
+        BlockOne.EndTime = 8;
        BlockOne.Proc = TestPatternTwo;
        AddAnimationBlock(BlockOne, &State->AnimationSystem);
        
        animation_block BlockTwo = {0};
-        BlockTwo.StartTime = 5;
-        BlockTwo.EndTime = 8;
+        BlockTwo.StartTime = 8;
+        BlockTwo.EndTime = 15;
        BlockTwo.Proc = TestPatternThree;
        AddAnimationBlock(BlockTwo, &State->AnimationSystem);
        
-        State->AnimationSystem.AnimationEnd = 10;
+        State->AnimationSystem.AnimationStart = 0;
+        State->AnimationSystem.AnimationEnd = 15;
    } // End Animation Playground
    
    
@ -303,8 +298,6 @@ INITIALIZE_APPLICATION(InitializeApplication)
        InitializePanelLayout(&State->PanelLayout);
 panel* Panel = TakeNewPanel(&State->PanelLayout);
        SetPanelDefinition(Panel, 0);
-        SplitPanelVertically(Panel, .5f, v2{0, 0}, v2{Context.WindowWidth, Context.WindowHeight}, &State->PanelLayout);
-        SetPanelDefinition(&Panel->Right->Panel, 1);
    } // End Panels Playground
 }

@ -369,6 +362,7 @@ CreateDMXBuffers(assembly Assembly, s32 BufferHeaderSize, memory_arena* Arena)
        NewBuffer->Buffer.Base = PushArray(Arena, u8, BufferSize);
        NewBuffer->Buffer.TotalSize = BufferSize;
        NewBuffer->Buffer.HeaderSize = BufferHeaderSize;
+        NewBuffer->Next = 0;
        
        // Append
        if (!Result) { 
@ -433,7 +427,12 @@ s32 CurrentFrame = (s32)(State->AnimationSystem.Time / State->AnimationSystem.Se
                if (State->AnimationSystem.Time >= Block.StartTime
                    && State->AnimationSystem.Time <= Block.EndTime)
                {
-                    Block.Proc(State, FrameTime  - Block.StartTime);
+                    for (s32 j = 0; j < State->ActiveAssemblyIndecies.Used; j++)
+                    {
+                        array_entry_handle* AssemblyHandle = GetElementAtIndex(j, State->ActiveAssemblyIndecies);
+                        assembly* Assembly = GetElementWithHandle(*AssemblyHandle, State->AssemblyList);
+                        Block.Proc(Assembly, FrameTime  - Block.StartTime);
+                    }
                }
            }
            }
@ -441,11 +440,16 @@ s32 CurrentFrame = (s32)(State->AnimationSystem.Time / State->AnimationSystem.Se
    
    s32 HeaderSize = State->NetworkProtocolHeaderSize;
    dmx_buffer_list* DMXBuffers = 0;
+    if (State->ActiveAssemblyIndecies.Used > 1)
+    {
+        s32 f = 4;
+    }
+    
    for (s32 i = 0; i < State->ActiveAssemblyIndecies.Used; i++)
    {
-        array_entry_handle AssemblyHandle = *GetElementAtIndex(i, State->ActiveAssemblyIndecies);
-        assembly Assembly = *GetElementWithHandle(AssemblyHandle, State->AssemblyList);
-        dmx_buffer_list* NewDMXBuffers = CreateDMXBuffers(Assembly, HeaderSize, &State->Transient);
+        array_entry_handle* AssemblyHandle = GetElementAtIndex(i, State->ActiveAssemblyIndecies);
+        assembly* Assembly = GetElementWithHandle(*AssemblyHandle, State->AssemblyList);
+        dmx_buffer_list* NewDMXBuffers = CreateDMXBuffers(*Assembly, HeaderSize, &State->Transient);
            DMXBuffers = DMXBufferListAppend(DMXBuffers, NewDMXBuffers);
    }
    
@ -566,9 +570,10 @@ PushRenderOrthographic(RenderBuffer, 0, 0, Context.WindowWidth, Context.WindowHe
    {
        DEBUG_TRACK_SCOPE(OverflowChecks);
        AssertAllocationsNoOverflow(State->Permanent);
-        for (s32 i = 0; i < State->AssemblyList.Used; i++)
+        for (s32 i = 0; i < State->ActiveAssemblyIndecies.Used; i++)
        {
-            assembly* Assembly = GetElementAtIndex(i, State->AssemblyList);
+            array_entry_handle* AssemblyHandle = GetElementAtIndex(i, State->ActiveAssemblyIndecies);
+            assembly* Assembly = GetElementWithHandle(*AssemblyHandle, State->AssemblyList);
            AssertAllocationsNoOverflow(Assembly->Arena);
        }
    }
--- a/src/foldhaus_app.h
+++ b/src/foldhaus_app.h
@ -74,51 +74,85 @@ internal void OpenColorPicker(app_state* State, v4* Address);

 // BEGIN TEMPORARY PATTERNS
 internal void
-TestPatternOne(app_state* State, r32 Time)
+TestPatternOne(assembly* Assembly, r32 Time)
 {
-    array_entry_handle TestAssemblyHandle = *GetElementAtIndex(0, State->ActiveAssemblyIndecies);
-    assembly TestAssembly = *GetElementWithHandle(TestAssemblyHandle, State->AssemblyList);
-    for (s32 Range = 0; Range < TestAssembly.LEDUniverseMapCount; Range++)
+    for (s32 Range = 0; Range < Assembly->LEDUniverseMapCount; Range++)
    {
-        leds_in_universe_range LEDUniverseRange = TestAssembly.LEDUniverseMap[Range];
+        leds_in_universe_range LEDUniverseRange = Assembly->LEDUniverseMap[Range];
        for (s32 LEDIdx = LEDUniverseRange.RangeStart;
             LEDIdx < LEDUniverseRange.RangeOnePastLast;
             LEDIdx++)
        {
-            led LED = TestAssembly.LEDs[LEDIdx];
-            TestAssembly.Colors[LED.Index].R = 255;
-            TestAssembly.Colors[LED.Index].B = 255;
-            TestAssembly.Colors[LED.Index].G = 255;
+            led LED = Assembly->LEDs[LEDIdx];
+            Assembly->Colors[LED.Index].R = 255;
+            Assembly->Colors[LED.Index].B = 255;
+            Assembly->Colors[LED.Index].G = 255;
        }
        }
 }

 internal void
-TestPatternTwo(app_state* State, r32 Time)
+TestPatternTwo(assembly* Assembly, r32 Time)
 {
-    if (Time > 2 * PI * 100) { Time = 0; }
-    r32 SinAdjusted = 0.5f + (GSSin(Time * 0.01f) * .5f);
-    u8 Brightness = (u8)(GSClamp01(SinAdjusted) * 255);
+    r32 PeriodicTime = (Time / PI) * 2;

-    array_entry_handle TestAssemblyHandle = *GetElementAtIndex(0, State->ActiveAssemblyIndecies);
-    assembly TestAssembly = *GetElementWithHandle(TestAssemblyHandle, State->AssemblyList);
-    for (s32 Range = 0; Range < TestAssembly.LEDUniverseMapCount; Range++)
+    r32 ZeroOneSin = (GSSin(PeriodicTime) * .5f) + .5f;
+r32 ZeroOneCos = (GSCos(PeriodicTime) * .5f) + .5f;
+    pixel Color = { (u8)(ZeroOneSin * 255), 0, (u8)(ZeroOneCos * 255) };
+    
+    v4 Center = v4{0, 0, 0, 1};
+    r32 ThetaZ = Time / 2;
+    v4 Normal = v4{GSCos(ThetaZ), 0, GSSin(ThetaZ), 0}; // NOTE(Peter): dont' need to normalize. Should always be 1
+    v4 Right = Cross(Normal, v4{0, 1, 0, 0});
+    
+    v4 FrontCenter = Center + (Normal * 25);
+    v4 BackCenter = Center - (Normal * 25);
+    
+    r32 OuterRadiusSquared = 1000000;
+    r32 InnerRadiusSquared = 0;
+    
+for (s32 Range = 0; Range < Assembly->LEDUniverseMapCount; Range++)
    {
-        leds_in_universe_range LEDUniverseRange = TestAssembly.LEDUniverseMap[Range];
+    leds_in_universe_range LEDUniverseRange = Assembly->LEDUniverseMap[Range];
 for (s32 LEDIdx = LEDUniverseRange.RangeStart;
             LEDIdx < LEDUniverseRange.RangeOnePastLast;
             LEDIdx++)
        {
-            led LED = TestAssembly.LEDs[LEDIdx];
-            TestAssembly.Colors[LED.Index].R = Brightness;
-            TestAssembly.Colors[LED.Index].B = 0;
-            TestAssembly.Colors[LED.Index].G = Brightness;
+            led LED = Assembly->LEDs[LEDIdx];
+
+        v4 Position = LED.Position;
+        
+        v4 ToFront = Position + FrontCenter;
+        v4 ToBack = Position + BackCenter;
+        
+        r32 ToFrontDotNormal = Dot(ToFront, Normal);
+        r32 ToBackDotNormal = Dot(ToBack, Normal);
+        
+        ToFrontDotNormal = GSClamp01(ToFrontDotNormal * 1000);
+        ToBackDotNormal = GSClamp01(ToBackDotNormal * 1000);
+        
+        r32 SqDistToCenter = MagSqr(Position);
+        if (SqDistToCenter < OuterRadiusSquared && SqDistToCenter > InnerRadiusSquared)
+        {
+            if (XOR(ToFrontDotNormal > 0, ToBackDotNormal > 0))
+            {
+                    Assembly->Colors[LED.Index] = Color;
+                }
+                else
+                {
+                    Assembly->Colors[LED.Index] = {};
+                }
+        }
+else
+                {
+                    Assembly->Colors[LED.Index] = {};
+                }
        }
    }
 }

 internal void
-TestPatternThree(app_state* State, r32 Time)
+TestPatternThree(assembly* Assembly, r32 Time)
 {
 r32 GreenSize = 20.0f;
    r32 BlueSize = 25.0f;
@ -128,16 +162,14 @@ r32 GreenSize = 20.0f;
    r32 BluePosition = -BlueSize + (Time * 25);
    r32 RedPosition = (100 + RedSize) + (Time * -35);
    
-    array_entry_handle TestAssemblyHandle = *GetElementAtIndex(0, State->ActiveAssemblyIndecies);
-    assembly TestAssembly = *GetElementWithHandle(TestAssemblyHandle, State->AssemblyList);
-    for (s32 Range = 0; Range < TestAssembly.LEDUniverseMapCount; Range++)
+    for (s32 Range = 0; Range < Assembly->LEDUniverseMapCount; Range++)
    {
-        leds_in_universe_range LEDUniverseRange = TestAssembly.LEDUniverseMap[Range];
+        leds_in_universe_range LEDUniverseRange = Assembly->LEDUniverseMap[Range];
        for (s32 LEDIdx = LEDUniverseRange.RangeStart;
             LEDIdx < LEDUniverseRange.RangeOnePastLast;
             LEDIdx++)
        {
-            led LED = TestAssembly.LEDs[LEDIdx];
+            led LED = Assembly->LEDs[LEDIdx];
            u8 Red = 0;
            u8 Green = 0;
            u8 Blue = 0;
@ -154,9 +186,9 @@ r32 GreenSize = 20.0f;
            r32 RedBrightness = GSClamp(0.0f, RedSize - RedDistance, RedSize) / RedSize;
            Red = (u8)(RedBrightness * 255);
            
-            TestAssembly.Colors[LED.Index].R = Red;
-            TestAssembly.Colors[LED.Index].B = Blue;
-            TestAssembly.Colors[LED.Index].G = Green;
+            Assembly->Colors[LED.Index].R = Red;
+            Assembly->Colors[LED.Index].B = Blue;
+            Assembly->Colors[LED.Index].G = Green;
        }
    }
 }
--- a/src/foldhaus_assembly.cpp
+++ b/src/foldhaus_assembly.cpp
@ -10,7 +10,7 @@ GetAssemblyMemorySizeFromDefinition(assembly_definition Definition, string Name)
 internal assembly
 ConstructAssemblyFromDefinition (assembly_definition Definition,
                                 string AssemblyName,
-                                 v3 RootPosition,
+                                 v4 RootPosition,
                                 r32 Scale,
                                 memory_arena Arena)
 {
@ -43,8 +43,8 @@ ConstructAssemblyFromDefinition (assembly_definition Definition,
        // now. The assert is to remind you to create more cases when necessary
        Assert(StripDef.InterpolationType == StripInterpolate_Points);
        
-        v4 WS_StripStart = V4(StripDef.InterpolatePositionStart * Scale, 1);
-        v4 WS_StripEnd = V4(StripDef.InterpolatePositionEnd * Scale, 1);
+        v4 WS_StripStart = RootPosition + V4(StripDef.InterpolatePositionStart * Scale, 1);
+        v4 WS_StripEnd = RootPosition + V4(StripDef.InterpolatePositionEnd * Scale, 1);
        s32 LEDsInStripCount = StripDef.LEDsPerStrip;
        
        Assert(Assembly.LEDCount + LEDsInStripCount <= Definition.TotalLEDCount);
@ -63,6 +63,9 @@ ConstructAssemblyFromDefinition (assembly_definition Definition,
    return Assembly;
 }

+static v4 TempAssemblyOffsets[] = { v4{0, 0, 0, 0}, v4{250, 0, 75, 0}, v4{-250, 0, 75, 0} };
+s32 TempAssemblyOffsetsCount = 3;
+
 internal void
 LoadAssembly (app_state* State, context Context, char* Path)
 {
@ -82,9 +85,10 @@ LoadAssembly (app_state* State, context Context, char* Path)
    AssemblyArena.Alloc = (gs_memory_alloc*)Context.PlatformAlloc;
    AssemblyArena.Realloc = (gs_memory_realloc*)Context.PlatformRealloc;
    
+    v4 Offset = TempAssemblyOffsets[State->ActiveAssemblyIndecies.Used % TempAssemblyOffsetsCount];
    assembly NewAssembly = ConstructAssemblyFromDefinition(AssemblyDefinition, 
                                                           FileName, 
-                                                           v3{0, 0, 0}, 
+                                                           Offset, 
                                                           Scale, 
                                                           AssemblyArena);
    array_entry_handle NewAssemblyHandle = PushElement(NewAssembly, &State->AssemblyList);
--- a/src/gs_array.h
+++ b/src/gs_array.h
@ -147,7 +147,6 @@ RemoveElementAtIndex (s32 Index, element_type##_array* Buffer) \
    Entry->Free.Next = Buffer->FreeList.Next; \
    Buffer->FreeList.Next = &Entry->Free; \
    \
-    --Buffer->Used; \
 } \

 // END OF CRAZY MACRO
@ -184,8 +183,12 @@ GrowBuffer(element_type##_contiguous_array* Buffer) \
 internal element_type* \
 GetElementAtIndex (s32 Index, element_type##_contiguous_array Buffer) \
                   { \
+                       element_type* Entry = 0; \
+                       if (Index <= Buffer.Used) \
+                       { \
 bucket_index BucketIndex = GetBucketIndexForIndex(Index, Buffer.BucketSize); \
-    element_type* Entry = Buffer.Buckets[BucketIndex.Bucket] + BucketIndex.IndexInBucket; \
+                           Entry = Buffer.Buckets[BucketIndex.Bucket] + BucketIndex.IndexInBucket; \
+                       } \
    return Entry; \
 } \
 \
--- a/src/panels/foldhaus_panel_animation_timeline.h
+++ b/src/panels/foldhaus_panel_animation_timeline.h
@ -17,6 +17,74 @@ PANEL_CLEANUP_PROC(AnimationTimeline_Cleanup)
    
 }

+internal r32
+DrawFrameBar (animation_system* AnimationSystem, render_command_buffer* RenderBuffer, s32 StartFrame, s32 EndFrame, v2 PanelMin, v2 PanelMax, interface_config Interface, mouse_state Mouse)
+{
+    MakeStringBuffer(TempString, 256);
+    
+    s32 FrameCount = EndFrame - StartFrame;
+    
+    r32 FrameBarHeight = 24;
+    v2 FrameBarMin = v2{PanelMin.x, PanelMax.y - FrameBarHeight};
+    v2 FrameBarMax = PanelMax;
+    
+    PushRenderQuad2D(RenderBuffer, FrameBarMin, FrameBarMax, v4{.16f, .16f, .16f, 1.f});
+    
+    // Mouse clicked inside frame nubmer bar -> change current frame on timeline
+    if (MouseButtonHeldDown(Mouse.LeftButtonState)
+        && PointIsInRange(Mouse.DownPos, FrameBarMin, FrameBarMax))
+    {
+        r32 MouseX = Mouse.DownPos.x;
+        r32 StartFrameTime = (r32)StartFrame * AnimationSystem->SecondsPerFrame;
+        r32 EndFrameTime = (r32)EndFrame * AnimationSystem->SecondsPerFrame;
+        r32 MouseTime = GSRemap(MouseX, FrameBarMin.x, FrameBarMax.x, StartFrameTime, EndFrameTime);
+        AnimationSystem->Time = MouseTime;
+    }
+    
+    // Frame Ticks
+    for (s32 f = 0; f < FrameCount; f += 10)
+    {
+        s32 Frame = StartFrame + f;
+        PrintF(&TempString, "%d", Frame);
+        
+        r32 FramePercent = (r32)f / (r32)FrameCount;
+        r32 FrameX = GSLerp(PanelMin.x, PanelMax.x, FramePercent);
+        v2 FrameTextPos = v2{FrameX, FrameBarMin.y + 2};
+        DrawString(RenderBuffer, TempString, Interface.Font, FrameTextPos, WhiteV4);
+        
+        // Frame Vertical Slices
+        v2 LineTop = v2{FrameX, FrameBarMin.y};
+        v2 LineBottom = v2{FrameX + 1, PanelMin.y};
+        PushRenderQuad2D(RenderBuffer, LineTop, LineBottom, v4{.16f, .16f, .16f, 1.f});
+    }
+    
+    return FrameBarMin.y;
+}
+
+internal rect
+DrawAnimationBlock (animation_block AnimationBlock, v4 BlockColor, r32 SecondsPerFrame, s32 FrameCount, s32 StartFrame, v2 TimelineMin, v2 TimelineMax, render_command_buffer* RenderBuffer)
+{
+    rect BlockBounds = {};
+    
+    r32 TimelineWidth = TimelineMax.x - TimelineMin.x;
+    
+    s32 BlockStartFrame = AnimationBlock.StartTime / SecondsPerFrame;
+    r32 StartFramePercent = (r32)(BlockStartFrame - StartFrame) / (r32)FrameCount;
+    r32 StartPosition = TimelineWidth * StartFramePercent;
+    
+    s32 BlockEndFrame = AnimationBlock.EndTime / SecondsPerFrame;
+    r32 EndFramePercent = (r32)(BlockEndFrame - StartFrame) / (r32)FrameCount;
+    r32 EndPosition = TimelineWidth * EndFramePercent;
+    
+    BlockBounds.Min = TimelineMin + v2{StartPosition, 25};
+    BlockBounds.Max = TimelineMin + v2{EndPosition, 75};
+    
+    PushRenderQuad2D(RenderBuffer, BlockBounds.Min, BlockBounds.Max, BlockColor);
+    PushRenderBoundingBox2D(RenderBuffer, BlockBounds.Min, BlockBounds.Max, 1, WhiteV4);
+    
+    return BlockBounds;
+}
+
 internal animation_block_handle
 DrawAnimationTimeline (animation_system* AnimationSystem, s32 StartFrame, s32 EndFrame, v2 PanelMin, v2 PanelMax, animation_block_handle SelectedBlockHandle, render_command_buffer* RenderBuffer, app_state* State, mouse_state Mouse)
 {
@ -27,44 +95,26 @@ s32 FrameCount = EndFrame - StartFrame;
    
    r32 AnimationPanelHeight = PanelMax.y - PanelMin.y;
    r32 AnimationPanelWidth = PanelMax.x - PanelMin.x;
-    PushRenderQuad2D(RenderBuffer, PanelMin, PanelMax, v4{.22f, .22f, .22f, 1.f});
    
-    // Frame Bar
-    r32 FrameBarHeight = 24;
-    v2 FrameBarMin = v2{PanelMin.x, PanelMax.y - FrameBarHeight};
-    v2 FrameBarMax = PanelMax;
-    PushRenderQuad2D(RenderBuffer, FrameBarMin, FrameBarMax, v4{.16f, .16f, .16f, 1.f});
-    
-// Mouse clicked inside frame nubmer bar -> change current frame on timeline
-    if (MouseButtonHeldDown(Mouse.LeftButtonState)
-        && PointIsInRange(Mouse.DownPos, FrameBarMin, FrameBarMax))
    {
-        r32 MouseX = Mouse.DownPos.x;
-        r32 MousePercentX = (MouseX - FrameBarMin.x) / (FrameBarMax.x - FrameBarMin.y);
-        s32 MouseFrame = (s32)((MousePercentX * FrameCount) + StartFrame);
-        r32 MouseFrameTime = (r32)MouseFrame * AnimationSystem->SecondsPerFrame;
-        AnimationSystem->Time = MouseFrameTime;
+        s32 FirstPlayableFrame = (AnimationSystem->AnimationStart / AnimationSystem->SecondsPerFrame);
+        s32 LastPlayableFrame = (AnimationSystem->AnimationEnd / AnimationSystem->SecondsPerFrame);
+        
+        r32 FirstPlayablePercentX = ((r32)(FirstPlayableFrame - StartFrame) / (r32)FrameCount);
+        r32 LastPlayablePercentX = ((r32)(LastPlayableFrame - StartFrame) / (r32)FrameCount);
+        
+        v2 PlayableMin = v2{(FirstPlayablePercentX * AnimationPanelWidth) + PanelMin.x, PanelMin.y };
+        v2 PlayableMax = v2{(LastPlayablePercentX * AnimationPanelWidth) + PanelMin.x, PanelMax.y };
+        
+        PushRenderQuad2D(RenderBuffer, PanelMin, PanelMax, v4{.16f, .16f, .16f, 1.f});
+        PushRenderQuad2D(RenderBuffer, PlayableMin, PlayableMax, v4{.22f, .22f, .22f, 1.f});
    }
    
-    for (s32 f = 0; f < FrameCount; f += 10)
-    {
-        s32 Frame = StartFrame + f;
-        PrintF(&TempString, "%d", Frame);
-        
-        r32 FramePercent = (r32)f / (r32)FrameCount;
-        r32 FrameX = GSLerp(PanelMin.x, PanelMax.x, FramePercent);
-        v2 FrameTextPos = v2{FrameX, FrameBarMin.y + 2};
-        DrawString(RenderBuffer, TempString, State->Interface.Font, FrameTextPos, WhiteV4);
-        
-        // Frame Vertical Slices
-        v2 LineTop = v2{FrameX, FrameBarMin.y};
-        v2 LineBottom = v2{FrameX + 1, PanelMin.y};
-        PushRenderQuad2D(RenderBuffer, LineTop, LineBottom, v4{.16f, .16f, .16f, 1.f});
-    }
+    r32 FrameBarBottom = DrawFrameBar(AnimationSystem, RenderBuffer, StartFrame, EndFrame, PanelMin, PanelMax, State->Interface, Mouse);
    
    // Animation Blocks
    v2 TimelineMin = PanelMin;
-    v2 TimelineMax = v2{PanelMax.x, FrameBarMin.y};
+    v2 TimelineMax = v2{PanelMax.x, FrameBarBottom};
    b32 MouseDownAndNotHandled = MouseButtonTransitionedDown(Mouse.LeftButtonState);
    for (u32 i = 0; i < AnimationSystem->BlocksCount; i++)
    {
@ -77,27 +127,15 @@ for (u32 i = 0; i < AnimationSystem->BlocksCount; i++)
        
        animation_block AnimationBlockAt = AnimationBlockEntry.Block;
        
-        s32 BlockStartFrame = AnimationBlockAt.StartTime / AnimationSystem->SecondsPerFrame;
-        r32 StartFramePercent = (r32)(BlockStartFrame - StartFrame) / (r32)FrameCount;
-        r32 StartPosition = AnimationPanelWidth * StartFramePercent;
-        
-        s32 BlockEndFrame = AnimationBlockAt.EndTime / AnimationSystem->SecondsPerFrame;
-        r32 EndFramePercent = (r32)(BlockEndFrame - StartFrame) / (r32)FrameCount;
-        r32 EndPosition = AnimationPanelWidth * EndFramePercent;
-        
-        v2 Min = TimelineMin + v2{StartPosition, 25};
-        v2 Max = TimelineMin + v2{EndPosition, 75};
-        
        v4 BlockColor = BlackV4;
        if (AnimationBlockHandlesAreEqual(SelectedBlockHandle, CurrentBlockHandle))
        {
            BlockColor = PinkV4;
        }
        
-        PushRenderQuad2D(RenderBuffer, Min, Max, BlockColor);
-        PushRenderBoundingBox2D(RenderBuffer, Min, Max, 1, WhiteV4);
+        rect BlockBounds = DrawAnimationBlock(AnimationBlockAt, BlockColor, AnimationSystem->SecondsPerFrame, FrameCount, StartFrame, TimelineMin, TimelineMax, RenderBuffer);
        
-        if (PointIsInRange(Mouse.Pos, Min, Max)
+        if (PointIsInRange(Mouse.Pos, BlockBounds.Min, BlockBounds.Max)
            && MouseButtonTransitionedDown(Mouse.LeftButtonState))
        {
            MouseDownAndNotHandled = false;
@ -115,7 +153,7 @@ for (u32 i = 0; i < AnimationSystem->BlocksCount; i++)
    
    // Time Slider
    s32 SliderFrame = AnimationSystem->Time / AnimationSystem->SecondsPerFrame;
-    r32 TimePercent = (r32)SliderFrame / (r32)EndFrame;
+    r32 TimePercent = (r32)(SliderFrame - StartFrame) / (r32)FrameCount;
    r32 SliderX = PanelMin.x + (AnimationPanelWidth * TimePercent);
    v2 SliderMin = v2{SliderX, PanelMin.y};
    v2 SliderMax = v2{SliderX + 1, PanelMax.y - 25};
@ -125,7 +163,7 @@ s32 SliderFrame = AnimationSystem->Time / AnimationSystem->SecondsPerFrame;
    
    r32 SliderHalfWidth = 10;
    v2 HeadMin = v2{SliderX - SliderHalfWidth, SliderMax.y};
-    v2 HeadMax = v2{SliderX + SliderHalfWidth, SliderMax.y + FrameBarHeight};
+    v2 HeadMax = v2{SliderX + SliderHalfWidth, PanelMax.y};
    PushRenderQuad2D(RenderBuffer, HeadMin, HeadMax, TimeSliderColor);
    
    PrintF(&TempString, "%d", SliderFrame);
@ -158,9 +196,10 @@ PANEL_RENDER_PROC(AnimationTimeline_Render)
    v2 TimelineMax = v2{PanelMax.x, PanelMax.y - OptionsRowHeight};
    if (TimelineMax.y - TimelineMin.y > 0)
    {
+        s32 FrameStart = (s32)(State->AnimationSystem.AnimationStart / State->AnimationSystem.SecondsPerFrame);
        s32 FrameEnd = (s32)(State->AnimationSystem.AnimationEnd / State->AnimationSystem.SecondsPerFrame);
        SelectedBlockHandle = DrawAnimationTimeline(&State->AnimationSystem, 
-                                                    0, FrameEnd,
+                                                    FrameStart - 20, FrameEnd + 20,
                                                    TimelineMin, TimelineMax, 
                                                    SelectedBlockHandle, 
                                                    RenderBuffer, State, Mouse);
--- a/src/panels/foldhaus_panel_hierarchy.h
+++ b/src/panels/foldhaus_panel_hierarchy.h
@ -51,7 +51,7 @@ array_entry_handle AssemblyHandle = *GetElementAtIndex(i, State->ActiveAssemblyI
            if (MouseButtonTransitionedUp(Mouse.LeftButtonState) 
                && PointIsInRange(Mouse.Pos, XLowerLeft, LineMax))
            {
-                UnloadAssembly(i, State, Context);
+                UnloadAssembly(AssemblyHandle.Index, State, Context);
            }
        }
        else if (i == State->ActiveAssemblyIndecies.Used)