handmade_debug.cpp

#include <stdio.h>
#include <stdlib.h>

#include "handmade_debug.h"

internal void FreeFrame(debug_state *DebugState, debug_frame *Frame);

inline debug_id
GetDebugIDFromLink(debug_tree* Tree, debug_variable_link *Link) {
    debug_id Result = {};
    Result.Value[0] = Tree;
    Result.Value[1] = Link;
    return(Result);
}

inline debug_id
GetDebugIDFromGUID(debug_tree* Tree, char* GUID) {
    debug_id Result = {};
    Result.Value[0] = Tree;
    Result.Value[1] = GUID;
    return(Result);
}

inline b32
DebugIDsAreEqual(debug_id A, debug_id B) {
    b32 Result = (A.Value[0] == B.Value[0] && A.Value[1] == B.Value[1]) ? true: false;
    return(Result);
}

inline debug_state*
DEBUGGetState(game_memory* Memory) {
    debug_state *DebugState = 0;
    if (Memory) {
        DebugState = (debug_state*)Memory->DebugStorage;
        if(!DebugState->IsInitialized) {
            DebugState = 0;
        }
    }
    return(DebugState);
}
inline debug_state*
DEBUGGetState(void) {
    debug_state *DebugState = DEBUGGetState(DebugGlobalMemory);
    return(DebugState);
}

internal debug_tree*
DEBUGAddTree(debug_state *DebugState, debug_variable_group *Group, v2 TopLeftP) {
    debug_tree* Tree = (debug_tree*)PushStruct(&DebugState->DebugArena, debug_tree);
    Tree->UIP = TopLeftP;
    Tree->Group = Group;
    
    DLIST_INSERT(&(DebugState->TreeSentinal), Tree);
    
    return(Tree);
}

inline b32
IsHex(char Char) {
    b32 Result = (((Char >= '0') && (Char <= '9')) || ((Char >= 'A')&& (Char <= 'F')));
    return(Result);
}

inline u32
GetHex(char Char) {
    u32 Result = 0;
    if (Char >= '0' && Char <= '9') {
        Result = Char - '0';
    } else if (Char >= 'A' && Char <= 'F') {
        Result = 0xA + (Char - 'A');
    }
    return(Result);
}

struct debug_statistic {
    u32 Count;
    r64 Min;
    r64 Max;
    r64 Avg;
};

inline void
BeginDebugStatistic(debug_statistic* Stat) {
    Stat->Min = Real32Maximum;
    Stat->Max = -Real32Maximum;
    Stat->Avg = 0;
    Stat->Count = 0;
}

inline void
UpdateDebugStatistic(debug_statistic* Stat, r64 Value) {
    Stat->Count++;
    if (Value < Stat->Min) {
        Stat->Min = Value;
    }
    if (Value > Stat->Max) {
        Stat->Max = Value;
    }
    Stat->Avg += Value;
    
}

inline void
EndDebugStatistic(debug_statistic* Stat) {
    if (Stat->Count != 0) {
        Stat->Avg /= (r64)Stat->Count;
        
    } else {
        Stat->Min = 0;
        Stat->Max = 0;
    }
}

internal rectangle2
DEBUGTextOp(debug_text_op Op, debug_state* DebugState, v2 P, char* String, v4 Color = v4{1.0f, 1.0f, 1.0f, 1.0f}) {
    rectangle2 Result = InvertedInfinityRectangle2();
    if (DebugState && DebugState->Font) {
        
        render_group *RenderGroup = &DebugState->RenderGroup;
        
        loaded_font* Font = DebugState->Font;
        hha_font* FontInfo = DebugState->FontInfo;
        
        u32 PrevCodePoint = 0;
        r32 TextY = P.y;
        r32 AtX = P.x;
        r32 CharScale = DebugState->FontScale;
        
        for(char* At = String;
            *At;
            ++At) {
            
            u32 CodePoint = *At;
            r32 AdvancedX = 0;
            
            if (At[0] == '\\' && IsHex(At[1]) && IsHex(At[2]) && IsHex(At[3]) && IsHex(At[4])) {
                CodePoint = ((GetHex(At[1]) << 12) | (GetHex(At[2]) << 8) | (GetHex(At[3]) << 4) | (GetHex(At[4]) << 0));
                At += 4;
            }
            if(PrevCodePoint) {
                AdvancedX = CharScale * GetHorizontalAdvanceForPair(DebugState->FontInfo, DebugState->Font, PrevCodePoint, CodePoint);
            }
            AtX += AdvancedX;
            
            if (CodePoint != ' ') {
                // proportional mode
                // AdvancedX = CharScale * (r32)(Info->Dim[0] + 2);
                bitmap_id BitmapID = GetBitmapForGlyph(RenderGroup->Assets, DebugState->FontInfo, DebugState->Font, CodePoint);
                hha_bitmap* BitmapInfo = GetBitmapInfo(RenderGroup->Assets, BitmapID);
                
                r32 BitmapScale = CharScale * (r32)BitmapInfo->Dim[1];
                v3 BitmapOffset = {AtX, TextY, 0};
                
                if (Op == DEBUGTextOp_DrawText) {
                    PushBitmap(RenderGroup, DebugState->TextTransform, BitmapID, BitmapScale, BitmapOffset, Color, 1.0f);
                    PushBitmap(RenderGroup, DebugState->ShadowTransform, BitmapID, BitmapScale, BitmapOffset + v3{2.0f, -2.0f, 0}, v4{0, 0, 0, 1}, 1.0f);
                } else {
                    Assert(Op == DEBUGTextOp_SizeText);
                    loaded_bitmap* Bitmap = GetBitmap(RenderGroup->Assets, BitmapID, RenderGroup->GenerationID);
                    if (Bitmap) {
                        used_bitmap_dim Dim = GetBitmapDim(RenderGroup, DefaultFlatTransform(), Bitmap, BitmapScale, BitmapOffset, 1.0f);
                        rectangle2 GlyphDim = RectMinDim(Dim.P.xy, Dim.Size);
                        Result = Union(Result, GlyphDim);
                    }
                }
            }
            // advance here
            
            PrevCodePoint = CodePoint;
        }
        //PushRect(RenderGroup, v3{LeftEdge, AtY, 0}, v2{1000.0f, 1.0f}, v4{1.0f, 0.0f, 0.0f, 1});
        //PushRect(RenderGroup, v3{LeftEdge, AtY + Info->Ascent, 0}, v2{1000.0f, 1.0f}, v4{0.0f, 1.0f, 0.0f, 1});
        //PushRect(RenderGroup, v3{LeftEdge, AtY - Info->Descent, 0}, v2{1000.0f, 1.0f}, v4{0.0f, 0.0f, 1.0f, 1});
    }
    return(Result);
}

internal void
DEBUGTextOutAt(v2 P, char* String, v4 Color = {1, 1, 1, 1}) {
    debug_state* DebugState = DEBUGGetState();
    if (DebugState) {
        DEBUGTextOp(DEBUGTextOp_DrawText, DebugState, P, String, Color);
    }
}

internal rectangle2
DEBUGGetTextSize(debug_state *DebugState, char* String) {
    rectangle2 Result = DEBUGTextOp(DEBUGTextOp_SizeText, DebugState, v2{ 0, 0 }, String);
    return(Result);
}

internal void
DEBUGTextLine(char *String) {
    debug_state* DebugState = DEBUGGetState();
    if (DebugState) {
        DEBUGTextOutAt(v2{DebugState->LeftEdge, DebugState->AtY - DebugState->FontScale * GetStartingBaselineY(DebugState->FontInfo)}, String);
        DebugState->AtY -= GetLineAdvancedFor(DebugState->FontInfo) * DebugState->FontScale;
    }
}

enum debug_var_to_text_flag {
    DebugVarToText_AddDebugUI = 0x1,
    DebugVarToText_AddName = 0x2,
    DebugVarToText_FloatSuffix = 0x4,
    DebugVarToText_LineFeedEnd = 0x8,
    DebugVarToText_NullTerminator = 0x10,
    DebugVarToText_Colon = 0x20,
    DebugVarToText_PrettyBools = 0x40,
    DebugVarToText_StartAtLastSlash = 0x80,
    DebugVarToText_AddValue = 0x100,
};


internal memory_index
DEBUGEventToText(char* Buffer, char *End, debug_event* Event, u32 Flags) {
    
    char *At = Buffer;
    char *Name = Event->GUID;
    
    if (Flags & DebugVarToText_AddDebugUI) {
        At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                          "#define DEBUGUI_");
    } 
    
    if (Flags & DebugVarToText_AddName) {
        char *UseName = Name;
        if (Flags & DebugVarToText_StartAtLastSlash) {
            for (char *Scan = Name; *Scan; ++Scan) {
                if (Scan[0] == '/' && Scan[1] != 0) {
                    UseName = Scan + 1;
                }
            }
        }
        At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), "%s%s ", UseName, 
                          ((Flags & DebugVarToText_Colon)? ":": ""));
    }
    if (Flags & DebugVarToText_AddValue) {
        switch (Event->Type) {
            case DebugType_b32:{
                if (Flags & DebugVarToText_PrettyBools) {
                    At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                      "%s", Event->Value_b32? "True": "False");
                } else {
                    At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                      "%d", Event->Value_b32);
                }
                
            } break;
            case DebugType_s32: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "%i", Event->Value_s32);
            } break;
            case DebugType_u32: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "%u", Event->Value_u32);
            } break;
            case DebugType_r32: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "%f", Event->Value_r32);
                if (Flags & DebugVarToText_FloatSuffix) {
                    *At++ = 'f';
                }
            } break;
            case DebugType_v2: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "V2(%f, %f)", Event->Value_v2.x, Event->Value_v2.y);
            } break;
            case DebugType_v3: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "V3(%f, %f, %f)", Event->Value_v3.x, Event->Value_v3.y, Event->Value_v3.z);
            } break;
            case DebugType_v4: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "V4(%ff, %ff, %ff, %ff)", Event->Value_v4.x, Event->Value_v4.y, Event->Value_v4.z, Event->Value_v4.w);
            } break;
            
            case DebugType_rectangle2: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "Min(v2):%f, %f / Max(v2):%f, %f",
                                  Event->Value_rectangle2.Min.x, Event->Value_rectangle2.Min.y,
                                  Event->Value_rectangle2.Max.x, Event->Value_rectangle2.Max.y);
            } break;
            
            case DebugType_rectangle3: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "Min(v3):%f, %f, %f / Max(v3):%f, %f, %f",
                                  Event->Value_rectangle3.Min.x, Event->Value_rectangle3.Min.y, Event->Value_rectangle3.Min.z,
                                  Event->Value_rectangle3.Max.x, Event->Value_rectangle3.Max.y, Event->Value_rectangle3.Max.z);
            } break;
            
            case DebugType_CounterThreadList:
            case DebugType_OpenDataBlock:
            case DebugType_bitmap_id: {
            } break;
            
            default: {
                At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                  "UNHANDLED: %s", Event->GUID);
            } break;
        }
    }
    if (Flags & DebugVarToText_LineFeedEnd) {
        *At++ = '\n'; 
    }
    if (Flags & DebugVarToText_NullTerminator) {
        *At++ = 0;
    }
    return(At - Buffer);
}

struct debug_variable_iterator {
    debug_variable_link* Link;
    debug_variable_link* Sentinal;
};

internal void
WriteZhaConfig(debug_state* DebugState) {
    
#if 0    
    char Temp[4096];
    char *At = Temp;
    char* End = Temp + sizeof(Temp);
    u32 Depth = 0;
    debug_variable_iterator Stack[DEBUG_MAX_VARIABLE_STACK_SIZE];
    Stack[Depth].Link = DebugState->RootGroup->VarGroup.Next;
    Stack[Depth].Sentinal = &DebugState->RootGroup->VarGroup;
    ++Depth;
    while (Depth > 0) {
        debug_variable_iterator *Iter = Stack + (Depth - 1);
        if (Iter->Link == Iter->Sentinal) {
            --Depth;
        } else {
            debug_variable* Var = Iter->Link->Var;
            Iter->Link = Iter->Link->Next;
            if (DEBUGShouldBeWritten(Var->Type))  {
                if (Var->Type == DebugVariableType_VarGroup) {
                    At += _snprintf_s(At, (size_t)(End - At), (size_t)(End - At), 
                                      "//");
                }
                At += DEBUGVariableToText(At, End, Var,
                                          DebugVarToText_AddDebugUI|DebugVarToText_AddName|
                                          DebugVarToText_LineFeedEnd|DebugVarToText_FloatSuffix);
            }
            if (Var->Type == DebugVariableType_VarGroup) {
                Iter = Stack + Depth;
                Iter->Link = Var->VarGroup.Next;
                Iter->Sentinal = &Var->VarGroup;
                Depth++;
            }
            
        }
    }
    Platform.DEBUGWriteEntireFile("../code/zha_config.h", (u32)(At - Temp), Temp);
    if (!DebugState->Compiling) {
        DebugState->Compiling = true;
        DebugState->Compiler = Platform.DEBUGExecuteSystemCommand("../code/", "c:\\windows\\system32\\cmd.exe", "/C build.bat");
    }
#endif
    
}

inline debug_interaction 
EventInteraction(debug_id ID, debug_interaction_type Type, debug_event *Event) {
    debug_interaction Result = {};
    Result.ID = ID;
    Result.Type = Type;
    Result.Event = Event;
    return(Result);
}

inline debug_interaction 
DebugIDInteraction(debug_interaction_type Type, debug_id ID) {
    debug_interaction Result = {};
    Result.ID = ID;
    Result.Type = Type;
    return(Result);
}

inline b32
InteractionAreEqual(debug_interaction A, debug_interaction B) {
    b32 Result = (DebugIDsAreEqual(A.ID, B.ID) && A.Type == B.Type && A.Generic == B.Generic);
    return(Result);
}

inline b32
InteractionIsHot(debug_state* DebugState, debug_interaction A) {
    b32 Result = InteractionAreEqual(A, DebugState->HotInteraction);
    return(Result);
}

internal void
DEBUG_HIT(debug_id ID, r32 ZValue){
    debug_state *DebugState = DEBUGGetState();
    if (DebugState) {
        DebugState->NextHotInteraction = DebugIDInteraction(DebugInteraction_Select, ID);
    }
};

internal void
ClearSelection(debug_state *DebugState) {
    DebugState->SelectIDCount = 0;
}



inline b32
IsSelected(debug_state *DebugState, debug_id ID) {
    b32 Result = false;
    for (u32 Index = 0; Index < DebugState->SelectIDCount; ++Index) {
        if (DebugIDsAreEqual(ID, DebugState->Selected[Index])) {
            Result = true;
            break;
        };
    }
    
    return(Result);
}

internal void
AddToSelection(debug_state *DebugState, debug_id ID) {
    if (DebugState->SelectIDCount < ArrayCount(DebugState->Selected) && !IsSelected(DebugState, ID)) {
        DebugState->Selected[DebugState->SelectIDCount++] = ID;
    }
}

internal b32
DEBUG_HIGHLIGHTED(debug_id ID, v4 *Color) {
    debug_state *DebugState = DEBUGGetState();
    b32 Result = false;
    if (DebugState) {
        if (IsSelected(DebugState, ID)) {
            *Color = V4(0, 1, 1, 1);
            Result = true;
        }
        if (DebugIDsAreEqual(DebugState->HotInteraction.ID, ID)) {
            *Color = V4(1, 1, 0, 1);
            Result = true;
        }
        
    }
    
    return(Result);
}

internal b32
DEBUG_REQUESTED(debug_id ID) {
    debug_state *DebugState = DEBUGGetState();
    b32 Result = false;
    if (DebugState) {
        Result = IsSelected(DebugState, ID) || DebugIDsAreEqual(DebugState->HotInteraction.ID, ID);
    }
    return(Result);
}


internal void
DrawProfile(debug_state *DebugState, rectangle2 ProfileRect, v2 MouseP) {
    PushRect(&DebugState->RenderGroup, DefaultFlatTransform(), ProfileRect, 0, V4(0, 0, 0, 0.25f));
    
    r32 BarSpacing = 4.0f;
    r32 LaneHeight = 0.0f;
    u32 LaneCount = DebugState->FrameBarLaneCount;
    r32 FrameBarScale = Real32Maximum;
    
    for (debug_frame *Frame = DebugState->OldestFrame; Frame; Frame = Frame->Next) {
        
        if (Frame->FrameBarScale < FrameBarScale) {
            FrameBarScale = Frame->FrameBarScale;
        }
    }
    
    u32 MaxFrame = DebugState->FrameCount;
    if (MaxFrame > 10) {
        MaxFrame = 10;
    }
    if (MaxFrame > 0 && LaneCount > 0) {
        LaneHeight = (GetDim(ProfileRect).y / ((r32)MaxFrame) - BarSpacing) / (r32)LaneCount;
    }
    
    
    r32 BarHeight = LaneHeight * LaneCount;
    r32 BarAdvance = BarHeight + BarSpacing;
    
    r32 ChartHeight = BarAdvance * MaxFrame;
    r32 ChartWidth = GetDim(ProfileRect).x;
    
    r32 ChartLeft = ProfileRect.Min.x;
    r32 ChartTop = ProfileRect.Max.y;
    
    r32 Scale = ChartWidth * FrameBarScale;
    v3 Colors[] = {
        {1, 0, 0},
        {0, 1, 0},
        {0, 0, 1},
        {1, 1, 0},
        {0, 1, 1},
        {1, 0, 1},
        {1, 0.5f, 0},
        {0, 1, 0.5f},
        {1, 0, 0.5f},
        {0.5f, 1, 0},
        {0, 0.5f, 1},
        {0.5f, 0, 1},
    };
    
#if 0    
    u32 FrameIndex = 0;
    for (debug_frame *Frame = DebugState->OldestFrame; Frame; Frame = Frame->Next, ++FrameIndex) {
        
        r32 StackX = ChartLeft;
        r32 StackY = ChartTop - (r32)FrameIndex * BarAdvance;
        
        for(u32 RegionIndex = 0; RegionIndex < Frame->RegionCount; ++RegionIndex) {
            debug_frame_region* Region = Frame->Regions + RegionIndex;
            
            v3 Color = Colors[Region->ColorIndex % ArrayCount(Colors)];
            r32 ThisMinX = StackX + Scale * Region->MinT;
            r32 ThisMaxX = StackX + Scale * Region->MaxT;
            rectangle2 RegionRect = RectMinMax(v2{ThisMinX, StackY - (Region->LaneIndex + 1) * LaneHeight}, 
                                               v2{ThisMaxX, StackY - Region->LaneIndex * LaneHeight});
            
            PushRect(DebugState->RenderGroup, RegionRect, 0.0f, V4(Color, 1));
            if (IsInRectangle(RegionRect, MouseP)) {
                debug_event* Event = Region->Event;
                char TextBuffer[256];
                _snprintf_s(TextBuffer, sizeof(TextBuffer), 
                            "%s: %10I64ucy %s(%d)",
                            Event->BlockName,
                            Region->CycleCount,
                            Event->FileName,
                            Event->LineNumber
                            );
                DEBUGTextOutAt(MouseP + v2{0, 10.0f}, TextBuffer);
                //HotRecord = Record;
            }
        }
    }
#endif
    //PushRect(DEBUGRenderGroup, v3{ChartLeft, ChartMinY + ChartHeight, 0}, v2{ChartWidth, 1}, v4{1, 1, 1, 1});
}

struct layout {
    v2 At;
    u32 Depth;
    r32 LineAdvance;
    r32 SpacingY;
    v2 MouseP;
    debug_state *DebugState;
};

struct layout_element {
    layout* Layout;
    v2 *Dim;
    v2 *Size;
    debug_interaction Interaction;
    rectangle2 Bounds;
};

inline layout_element
BeginElementRectangle(layout *Layout, v2 *Dim) {
    layout_element Element = {};
    Element.Layout = Layout;
    Element.Dim = Dim;
    return(Element);
}

inline void
SetElementSizable(layout_element* Element) {
    Element->Size = Element->Dim;
}

inline void
EndElement(layout_element *Element) {
    layout* Layout = Element->Layout;
    debug_state* DebugState = Layout->DebugState;
    object_transform NoTransform = DefaultFlatTransform();
    r32 SizeHandlePixels = 4.0f;
    v2 Frame = {0, 0};
    if (Element->Size) {
        Frame.x = SizeHandlePixels;
        Frame.y = SizeHandlePixels;
    }
    v2 TotalDim = *Element->Dim + 2.0f * Frame;
    
    v2 TotalMinCorner = {Layout->At.x + Layout->Depth * Layout->LineAdvance * 2.0f, Layout->At.y - TotalDim.y};
    v2 TotalMaxCorner = TotalMinCorner + TotalDim;
    rectangle2 TotalBounds = RectMinMax(TotalMinCorner, TotalMaxCorner);
    
    v2 MinCorner = TotalMinCorner + Frame;
    // v2 MaxCorner = TotalMaxCorner - Frame;
    v2 MaxCorner = TotalMinCorner + *Element->Dim;
    Element->Bounds = RectMinMax(MinCorner, MaxCorner);
    
    PushRect(&DebugState->RenderGroup, NoTransform, RectMinMax(v2{TotalMinCorner.x, MinCorner.y}, v2{MinCorner.x, MaxCorner.y}), 0.0f, v4{0, 0, 0, 1});
    PushRect(&DebugState->RenderGroup, NoTransform, RectMinMax(v2{MaxCorner.x, MinCorner.y}, v2{TotalMaxCorner.x, MaxCorner.y}), 0.0f, v4{0, 0, 0, 1});
    
    PushRect(&DebugState->RenderGroup, NoTransform, RectMinMax(v2{MinCorner.x, MaxCorner.y}, v2{MaxCorner.x, TotalMaxCorner.y}), 0.0f, v4{0, 0, 0, 1});
    PushRect(&DebugState->RenderGroup, NoTransform, RectMinMax(v2{MinCorner.x, TotalMinCorner.y}, v2{MaxCorner.x, MinCorner.y}), 0.0f, v4{0, 0, 0, 1});
    
    if (Element->Interaction.Type && IsInRectangle(Element->Bounds, Layout->MouseP)) {
        DebugState->NextHotInteraction = Element->Interaction;
    }
    
    if (Element->Size) {
        v2 SizeP = {GetMaxCorner(Element->Bounds).x, GetMinCorner(Element->Bounds).y};
        rectangle2 SizeRect= RectMinMax(v2{MaxCorner.x, TotalMinCorner.y}, v2{TotalMaxCorner.x, MinCorner.y});
        
        debug_interaction SizeInteraction = {};
        SizeInteraction.Type = DebugInteraction_Resize;
        SizeInteraction.P = Element->Size;
        PushRect(&DebugState->RenderGroup, NoTransform, SizeRect, 0.0f, 
                 (InteractionIsHot(DebugState, SizeInteraction))? v4{1, 1, 0, 1}: v4{1, 1, 1, 1});
        if (IsInRectangle(SizeRect, Layout->MouseP)) {
            DebugState->NextHotInteraction = SizeInteraction;
        }
    }
    
    
    
    r32 SpacingY = Layout->SpacingY;
    if (0) {
        SpacingY = 0;
    }
    Layout->At.y = GetMinCorner(TotalBounds).y - SpacingY;
}

inline void
SetElementDefaultInteraction(layout_element *Element, debug_interaction Interaction) {
    Element->Interaction = Interaction;
}

internal debug_view*
GetDebugViewFor(debug_state *DebugState, debug_id ID) {
    debug_view *Result = 0;
    u32 HashIndex = (((u32)ID.Value[0] >> 2) + ((u32)ID.Value[1] >> 2)) % ArrayCount(DebugState->ViewHash);
    debug_view **HashSlot = DebugState->ViewHash + HashIndex;
    for (debug_view *Search = *HashSlot; Search; Search = Search->NextInHash) {
        if (DebugIDsAreEqual(Search->ID, ID)) {
            Result = Search;
            break;
        }
    }
    if (!Result) {
        Result = (debug_view *)PushStruct(&DebugState->DebugArena, debug_view);
        Result->ID = ID;
        Result->Type = DebugViewType_Unknown;
        Result->NextInHash = *HashSlot;
        *HashSlot = Result;
        
    }
    return(Result);
}

internal void
DEBUGDrawEvent(layout *Layout, debug_stored_event* StoredEvent, debug_id ID) {
    debug_state *DebugState = Layout->DebugState;
    render_group* RenderGroup = &DebugState->RenderGroup;
    if (StoredEvent) {
        debug_event *Event = &StoredEvent->Event;
        debug_interaction AutoInteraction = EventInteraction(ID, DebugInteraction_AutoModifyVariable, Event);
        
        b32 IsHot = InteractionAreEqual(DebugState->HotInteraction, AutoInteraction);
        v4 ItemColor = (IsHot)? v4{1, 1, 0, 1}: v4{1, 1, 1, 1};
        
        debug_view *View = GetDebugViewFor(DebugState, ID);
        
        object_transform NoTransform = DefaultFlatTransform();
        
        switch(Event->Type) {
            
            case DebugType_bitmap_id: {
                loaded_bitmap* Bitmap = GetBitmap(RenderGroup->Assets, Event->Value_bitmap_id, RenderGroup->GenerationID);
                r32 BitmapScale = View->InlineBlock.Dim.y;
                if (Bitmap) {
                    used_bitmap_dim Dim = GetBitmapDim(RenderGroup, NoTransform, Bitmap, BitmapScale, V3(0, 0, 0), 1.0f);
                    View->InlineBlock.Dim.x = Dim.Size.x;
                }
                debug_interaction TearInteraction = EventInteraction(ID, DebugInteraction_TearValue, Event);
                
                layout_element Element = BeginElementRectangle(Layout, &View->InlineBlock.Dim);
                SetElementSizable(&Element);
                SetElementDefaultInteraction(&Element, TearInteraction);
                EndElement(&Element);
                PushRect(RenderGroup, NoTransform, Element.Bounds, 0.0f, v4{0, 0, 0, 1.0f});
                PushBitmap(RenderGroup, NoTransform, Event->Value_bitmap_id, BitmapScale, V3(GetMinCorner(Element.Bounds), 0.0f), v4{1, 1, 1, 1}, 0.0f);
            } break;
            case DebugType_CounterFunctionList: {
                layout_element LayoutElement = BeginElementRectangle(Layout, &View->InlineBlock.Dim);
                SetElementSizable(&LayoutElement);
                EndElement(&LayoutElement);
                DrawProfile(DebugState, LayoutElement.Bounds, Layout->MouseP);
            } break;
            default: {
                char Text[256];
                DEBUGEventToText(Text, Text + sizeof(Text), Event, DebugVarToText_AddName|DebugVarToText_AddValue
                                 |DebugVarToText_Colon|DebugVarToText_NullTerminator|DebugVarToText_PrettyBools);
                rectangle2 TextBound = DEBUGGetTextSize(DebugState, Text);
                
                v2 Dim = {GetDim(TextBound).x, Layout->LineAdvance};
                layout_element Element = BeginElementRectangle(Layout, &Dim);
                SetElementDefaultInteraction(&Element, AutoInteraction);
                EndElement(&Element);
                
                DEBUGTextOutAt(V2(GetMinCorner(Element.Bounds).x, GetMaxCorner(Element.Bounds).y - DebugState->FontScale * GetStartingBaselineY(DebugState->FontInfo)), Text, ItemColor);
            } break;
        }
    }
}

internal void
DEBUGDrawElement(layout *Layout, debug_tree *Tree, debug_element *Element, debug_id ID) {
    debug_stored_event *OldestEvent = Element->OldestEvent;
    debug_state *DebugState = Layout->DebugState;
    if (OldestEvent) {
        debug_view *View = GetDebugViewFor(DebugState, ID);
        switch(OldestEvent->Event.Type) {
            case DebugType_CounterThreadList: {
                layout_element LayoutElement = BeginElementRectangle(Layout, &View->InlineBlock.Dim);
                SetElementSizable(&LayoutElement);
                EndElement(&LayoutElement);
                DrawProfile(DebugState, LayoutElement.Bounds, Layout->MouseP);
            } break;
            default: {
                debug_stored_event *Event = Element->LatestEvent;
                DEBUGDrawEvent(Layout, Event, ID);
            } break;
        }
    }
}

internal void
DEBUGDrawMainMenu(debug_state* DebugState, render_group* RenderGroup, v2 MouseP) {
    for (debug_tree* Tree = DebugState->TreeSentinal.Next;
         Tree != &DebugState->TreeSentinal; 
         Tree = Tree->Next) {
        layout Layout = {};
        
        Layout.At = Tree->UIP;
        Layout.LineAdvance = GetLineAdvancedFor(DebugState->FontInfo) * DebugState->FontScale;
        Layout.SpacingY = 4.0f;
        Layout.MouseP = MouseP;
        Layout.Depth = 0;
        Layout.DebugState = DebugState;
        
        char Text[256];
        
        u32 Depth = 0;
        
        debug_variable_group *Group = Tree->Group;
        
        if (Group) {
            debug_variable_iterator Stack[DEBUG_MAX_VARIABLE_STACK_SIZE];
            Stack[Depth].Link = Group->Sentinal.Next;
            Stack[Depth].Sentinal = &Group->Sentinal;
            ++Depth;
            while (Depth > 0) {
                debug_variable_iterator *Iter = Stack + (Depth - 1);
                if (Iter->Link == Iter->Sentinal) {
                    --Depth;
                } else {
                    Layout.Depth = Depth;
                    debug_variable_link *Link = Iter->Link;
                    
                    Iter->Link = Iter->Link->Next;
                    if (Link->Children) {
                        debug_id ID = GetDebugIDFromLink(Tree, Link);
                        debug_view *View = GetDebugViewFor(DebugState, ID);
                        debug_interaction AutoInteraction = DebugIDInteraction(DebugInteraction_ToggleExpansion, ID);
                        
                        Text[0] = 0;
                        Assert((Link->Children->NameLength + 1) < ArrayCount(Text));
                        Copy(Link->Children->NameLength, Link->Children->Name, Text);
                        Text[Link->Children->NameLength] = 0;
                        
                        r32 LeftX = Layout.At.x + Layout.Depth * Layout.LineAdvance * 2.0f;
                        r32 TopY = Layout.At.y;
                        rectangle2 TextBound = DEBUGGetTextSize(DebugState, Text);
                        
                        v2 Dim = {GetDim(TextBound).x, Layout.LineAdvance};
                        layout_element Element = BeginElementRectangle(&Layout, &Dim);
                        SetElementDefaultInteraction(&Element, AutoInteraction);
                        EndElement(&Element);
                        b32 IsHot = InteractionAreEqual(DebugState->HotInteraction, AutoInteraction);
                        v4 ItemColor = (IsHot)? v4{1, 1, 0, 1}: v4{1, 1, 1, 1};
                        DEBUGTextOutAt(V2(GetMinCorner(Element.Bounds).x, GetMaxCorner(Element.Bounds).y - DebugState->FontScale * GetStartingBaselineY(DebugState->FontInfo)), Text, ItemColor);
                        
                        
                        if (View->Collapsible.ExpandedAlways) {
                            Iter = Stack + Depth;
                            Iter->Link = Link->Children->Sentinal.Next;
                            Iter->Sentinal = &Link->Children->Sentinal;
                            Depth++;
                        }
                        
                    } else {
                        debug_id ID = GetDebugIDFromLink(Tree, Link);
                        DEBUGDrawElement(&Layout, Tree, Link->Element, ID);
                    }
                }
            }
        }
        DebugState->AtY = Layout.At.y;
        {
            debug_interaction MoveInteraction = {};
            MoveInteraction.Type = DebugInteraction_Move;
            MoveInteraction.P = &Tree->UIP;
            
            rectangle2 MoveRect = RectMinDim(Tree->UIP - v2{5.0f, 5.0f}, v2{5.0f, 5.0f});
            PushRect(RenderGroup, DefaultFlatTransform(), MoveRect, 0.0f, 
                     InteractionIsHot(DebugState, MoveInteraction)? v4{1, 1, 0, 1}: v4{1, 1, 1, 1});
            
            if (IsInRectangle(MoveRect, MouseP)) {
                DebugState->NextHotInteraction = MoveInteraction;
            }
            
        }
    }
}

internal void
DEBUGBeginInteract(debug_state *DebugState, game_input *Input, v2 MouseP, b32 AltUI) {
    if (DebugState->HotInteraction.Type) {
        if (DebugState->HotInteraction.Type == DebugInteraction_AutoModifyVariable) {
            switch(DebugState->HotInteraction.Event->Type) {
                
                case DebugType_b32: {
                    DebugState->HotInteraction.Type = DebugInteraction_ToggleValue;
                } break;
                
                case DebugType_r32: {
                    DebugState->HotInteraction.Type = DebugInteraction_DragValue;
                } break;
                case DebugType_OpenDataBlock: {
                    DebugState->HotInteraction.Type = DebugInteraction_ToggleValue;
                } break;
            }
            
            if (AltUI) {
                DebugState->HotInteraction.Type = DebugInteraction_TearValue;
            } else {
            }
        }
        
        switch(DebugState->HotInteraction.Type) {
            case DebugInteraction_TearValue: {
#if 0                
                debug_variable* Group = DEBUGAddRootGroup(DebugState, "Tear");
                DEBUGPushVariableToGroup(DebugState, Group, DebugState->HotInteraction.Var);
                debug_tree *Tree = DEBUGAddTree(DebugState, Group, MouseP);
                Tree->UIP = MouseP;
                DebugState->HotInteraction.Type = DebugInteraction_Move;
                DebugState->HotInteraction.P = &Tree->UIP;
#endif
            } break;
            case DebugInteraction_Select: { 
                if (!Input->ShiftDown) {
                    ClearSelection(DebugState);
                }
                AddToSelection(DebugState, DebugState->HotInteraction.ID);
            } break;
        }
        
        DebugState->Interaction = DebugState->HotInteraction;
    } else {
        
        DebugState->Interaction.Type = DebugInteraction_NOP;
    }
}

internal void
DEBUGEndInteract(debug_state *DebugState, game_input *Input, v2 MouseP) {
    switch(DebugState->Interaction.Type) {
        case DebugInteraction_ToggleExpansion: {
            debug_view *View = GetDebugViewFor(DebugState, DebugState->Interaction.ID);
            View->Collapsible.ExpandedAlways = !View->Collapsible.ExpandedAlways;
        } break;
        case DebugInteraction_ToggleValue: {
            debug_event *Event = DebugState->Interaction.Event;
            Assert(Event);
            switch (Event->Type) {
                case DebugType_b32: {
                    Event->Value_b32 = !Event->Value_b32;
                } break;
            }
        } break;
        default: {
        } break;
    }
    
    DebugState->Interaction.Type = DebugInteraction_None;
    DebugState->Interaction.Generic = 0;
}


internal void
DEBUGInteract(debug_state* DebugState, game_input *Input, v2 MouseP) {
    v2 dMouseP = MouseP - DebugState->LastMouseP;
    
    if (DebugState->Interaction.Type) {
        debug_event* Event = DebugState->Interaction.Event;
        // mouse handle
        debug_tree* Tree = DebugState->Interaction.Tree;
        v2* P = DebugState->Interaction.P;
        switch(DebugState->Interaction.Type) {
            case DebugInteraction_DragValue: {
                switch(Event->Type) {
                    case DebugType_r32: {
                        Event->Value_r32 += 0.1f * dMouseP.x;
                    } break;
                }
            } break;
            case DebugInteraction_Resize: {
                *P += v2{dMouseP.x, -dMouseP.y};
                P->x = Maximum(P->x, 10.0f);
                P->y = Maximum(P->y, 10.0f);
                
            } break;
            
            case DebugInteraction_Move: {
                *P += v2{dMouseP.x, dMouseP.y};
            } break;
            
            case DebugInteraction_ToggleValue: {
            } break;
            
        }
        // click handle
        b32 AltUI = Input->MouseButtons[PlatformMouseButton_Right].EndedDown;
        for (u32 TransitionIndex = Input->MouseButtons[PlatformMouseButton_Left].HalfTransitionCount;
             TransitionIndex > 1;
             --TransitionIndex) {
            DEBUGEndInteract(DebugState, Input, MouseP);
            DEBUGBeginInteract(DebugState, Input, MouseP, AltUI);
        }
        if (!(Input->MouseButtons[PlatformMouseButton_Left].EndedDown)) {
            DEBUGEndInteract(DebugState, Input, MouseP);
        }
    } else {
        DebugState->HotInteraction = DebugState->NextHotInteraction;
        b32 AltUI = Input->MouseButtons[PlatformMouseButton_Right].EndedDown;
        for (u32 TransitionIndex = Input->MouseButtons[PlatformMouseButton_Left].HalfTransitionCount;
             TransitionIndex > 1;
             --TransitionIndex) {
            DEBUGBeginInteract(DebugState, Input, MouseP, AltUI);
            DEBUGEndInteract(DebugState, Input, MouseP);
        }
        if (Input->MouseButtons[PlatformMouseButton_Left].EndedDown) {
            DEBUGBeginInteract(DebugState, Input, MouseP, AltUI);
        }
    }
    DebugState->LastMouseP = MouseP;
}

global_variable debug_table GlobalDebugTable_;
debug_table* GlobalDebugTable = &GlobalDebugTable_;

inline u32
GetLaneFromtThreadIndex(debug_state *DebugState, u32 ThreadIndex) {
    u32 Result = 0;
    return(Result);
}

internal debug_thread *
GetDebugThread(debug_state *DebugState, u32 ThreadID) {
    debug_thread *Result = 0;
    for (debug_thread* Thread = DebugState->FirstThread; Thread; Thread = Thread->Next) {
        if (Thread->ID == ThreadID) {
            Result = Thread;
            break;
        }
    }
    if (!Result) {
        FREELIST_ALLOC(DebugState->FirstFreeThread, Result, PushStruct(&DebugState->DebugArena, debug_thread));
        
        Result->Next = DebugState->FirstThread;
        DebugState->FirstThread = Result;
        
        Result->ID = ThreadID;
        Result->FirstOpenCodeBlock = 0;
        Result->FirstOpenDataBlock = 0;
        Result->LaneIndex = DebugState->FrameBarLaneCount++;
    }
    return (Result);
}

#if 0
internal debug_frame_region *
AddRegion(debug_state *DebugState, debug_frame* CurrentFrame) {
    Assert(CurrentFrame->RegionCount < MAX_REGIONS_PER_FRAME);
    debug_frame_region* Result = CurrentFrame->Regions + CurrentFrame->RegionCount++;
    return(Result);
}
#endif


internal debug_variable_group*
CreateVariableGroup(debug_state *DebugState, char* Name, u32 NameLength) {
    debug_variable_group *Group = PushStruct(&DebugState->DebugArena, debug_variable_group);
    DLIST_INIT(&Group->Sentinal);
    Group->NameLength = NameLength;