static void
PostMsg(project_state *State, char *msg)
{
    State->MsgTime = 120;
    State->Msg = msg;
}

static uint16
Source_Generate(project_data *File, project_state *State, memory *Memory, void *TempString)
{
    Assert(File->Source_Count < MAX_SOURCES);

    bool32 IsVideo = 0;
    if (AV_IsFileSupported((char *)TempString, &IsVideo)) {
        uint16 Index = Memory_Block_AllocateNew(Memory, F_Sources);
        block_source *Source = (block_source *)Memory_Block_AddressAtIndex(Memory, F_Sources, Index);
        History_Entry_Commit(Memory, "Add source");
        History_Action_Block_Swap(Memory, F_Sources, Source);

        Source->Occupied = 1;
        Source->Path_String_Index = String_AddToFile(Memory, (char *)TempString);
        if (IsVideo)
            Source->Type = source_type_video;
        else
            Source->Type = source_type_image;

        History_Action_Swap(Memory, F_File, sizeof(File->Source_Count), &File->Source_Count);
        File->Source_Count++;
        History_Entry_End(Memory);
        return Index;
    } else {
        PostMsg(State, "File not supported...");
    }

    return -1;
}

static bezier_point *
Bezier_Lookup(memory *Memory, property_channel *Property, uint16 Index)
{
    Assert(Index < MAX_KEYFRAMES_PER_BLOCK);
    block_bezier *Bezier = (block_bezier *)Memory_Block_AddressAtIndex(Memory, F_Bezier, Property->Block_Bezier_Index[0]);
    return &Bezier->Point[Index];
}

static property_channel
Property_InitFloat(char *Name, real32 Val, real32 ScrubVal, real32 MinVal = PROPERTY_REAL_MIN, real32 MaxVal = PROPERTY_REAL_MAX) { property_channel Property = {};
    Property.Name = Name;
    Property.CurrentValue = Val;
    Property.MinVal = MinVal;
    Property.MaxVal = MaxVal;
    Property.ScrubVal = ScrubVal;
    return Property;
}

static property_info
Property_GetInfo(memory *Memory, property_channel *Property)
{
    property_info PropertyInfo = {};
    for (int k = 0; k < Property->Keyframe_Count; k++) {
        bezier_point *Point = Bezier_Lookup(Memory, Property, k);
        PropertyInfo.MinVal = (Point->Pos[0].y < PropertyInfo.MinVal) ? Point->Pos[0].y : PropertyInfo.MinVal;
        PropertyInfo.MaxVal = (Point->Pos[0].y > PropertyInfo.MaxVal) ? Point->Pos[0].y : PropertyInfo.MaxVal;
    }
    return PropertyInfo;
}

static void
Layer_Interact_Evaluate(memory *Memory, project_state *State, uint16 Layer_Index_Physical, sorted_comp_info SortedCompInfo, sorted_layer *SortedLayerInfo,
                        int32 *Frame_Start, int32 *Frame_End, real32 *Vertical_Offset)
{
    if (State->Interact_Active == interact_type_layer_move) {
        *Frame_Start += (int32)(State->Interact_Offset[0] + 0);
        *Frame_End += (int32)(State->Interact_Offset[0] + 0);

        real32 DesiredOffset = *Vertical_Offset + (int32)State->Interact_Offset[1];
        bool32 Direction = ((int32)State->Interact_Offset[1] > 0) ? 1 : -1;
        int i = (Direction > 0) ? SortedCompInfo.LayerCount - 1 : 0;
        bool32 Case = 1;
        while (Case) {
            sorted_layer SortEntry = SortedLayerInfo[i];
            uint32 Index_Physical = SortEntry.Block_Layer_Index;
            block_layer *Layer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, Index_Physical);
            bool32 Test = (Direction > 0) ?
                          ((Layer->Vertical_Offset <= DesiredOffset) && (Layer->Vertical_Offset > *Vertical_Offset)) :
                          ((Layer->Vertical_Offset >= DesiredOffset) && (Layer->Vertical_Offset < *Vertical_Offset));
            if (!Layer->IsSelected && Test) {
                DesiredOffset += Direction;
            }
            i -= Direction;
            Case = (Direction > 0) ? (i >= 0) : (i < SortedCompInfo.LayerCount);
        }
        *Vertical_Offset = DesiredOffset;
    }
    else if (State->Interact_Active == interact_type_layer_timeadjust) {
        int Side[2] = {0};
        Assert(State->Interact_Offset[1] == 0 || State->Interact_Offset[1] == 1);
        Side[(int)State->Interact_Offset[1]] = 1;
        *Frame_Start += (int32)(State->Interact_Offset[0] * Side[0]);
        if (*Frame_Start >= *Frame_End)
            *Frame_Start = *Frame_End - 1;
        *Frame_End += (int32)(State->Interact_Offset[0] * Side[1]);
        if (*Frame_End <= *Frame_Start)
            *Frame_End = *Frame_Start + 1;
    }
}

// TODO(fox): Precomps!
void Layer_DeselectAll(memory *Memory, uint32 LayerCount) {
    for (uint32 i = 0; i < LayerCount; i++) {
        block_layer *Layer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, i);
        if (Layer->IsSelected)
            Layer->IsSelected = false;
    }
}

static sorted_layer *
Layer_GetSortedArray(sorted_layer *LayerArrayStart, sorted_comp_info *SortedCompStart, uint32 TargetComp)
{
    uint32 LayerOffset = 0; int s = 0;
    while (s < TargetComp) {
        LayerOffset += SortedCompStart[s].LayerCount;
        s++;
    }
    return LayerArrayStart + LayerOffset;
}

void Layer_RecursiveDeselect(memory *Memory, sorted_comp_info *SortedCompArray, sorted_layer *SortedLayerArray, uint16 TargetIndex, uint16 PrincipalIndex)
{
    block_composition *Comp = (block_composition *)Memory_Block_AddressAtIndex(Memory, F_Precomps, PrincipalIndex);
    sorted_comp_info SortedCompInfo = SortedCompArray[PrincipalIndex];
    sorted_layer *SortedLayerInfo = Layer_GetSortedArray(SortedLayerArray, SortedCompArray, PrincipalIndex);
    for (int i = 0; i < SortedCompInfo.LayerCount; i++) {
        sorted_layer SortEntry = SortedLayerInfo[i];
        uint32 Index_Physical = SortEntry.Block_Layer_Index;
        block_layer *Layer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, Index_Physical);
        if (Layer->IsPrecomp) {
            Layer_RecursiveDeselect(Memory, SortedCompArray, SortedLayerArray, TargetIndex, Layer->Block_Source_Index);
        }
        if (Layer->Block_Composition_Index != TargetIndex) {
            Layer->IsSelected = false;
        }
    }
}

void Layer_SortAll(memory *Memory, sorted_layer *LayerArrayStart, sorted_comp_info *CompStart,  uint32 LayerCount, uint32 CompCount)
{
    for (uint32 i = 0; i < LayerCount; i++) {
        block_layer *Layer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, i);
        Assert(Layer->Block_Composition_Index < CompCount);
        CompStart[Layer->Block_Composition_Index].LayerCount++;

    }
    for (uint32 i = 0; i < LayerCount; i++) {
        // SortedLayerArray->Block_Layer_Index = 0;
        block_layer *Layer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, i);
        sorted_comp_info *SortedCompInfo = &CompStart[Layer->Block_Composition_Index];
        sorted_layer *SortedLayerInfo = Layer_GetSortedArray(LayerArrayStart, CompStart, Layer->Block_Composition_Index);
        uint32 SortedIndex_Playhead = 0;
        while (SortedIndex_Playhead < SortedCompInfo->CurrentSortIndex) {
            sorted_layer LayerEntry = SortedLayerInfo[SortedIndex_Playhead];
            block_layer *TestLayer = (block_layer *)Memory_Block_AddressAtIndex(Memory, F_Layers, LayerEntry.Block_Layer_Index);
            if (-Layer->Vertical_Offset < -TestLayer->Vertical_Offset) {
                break;
            } else {
                SortedIndex_Playhead++;
            }
        }
        if (SortedIndex_Playhead != SortedCompInfo->CurrentSortIndex) {
            uint8 *Address_Start = (uint8 *)(SortedLayerInfo + SortedIndex_Playhead);
            uint8 *Address_End = (uint8 *)(SortedLayerInfo + SortedCompInfo->CurrentSortIndex) - 1;
            Assert(SortedCompInfo->CurrentSortIndex != SortedCompInfo->LayerCount);
            Arbitrary_ShiftData(Address_Start, Address_End, sizeof(sorted_layer), 1);
        }
        sorted_layer *LayerEntry = SortedLayerInfo + SortedIndex_Playhead;
        LayerEntry->Block_Layer_Index = i;
        SortedCompInfo->CurrentSortIndex++;
    }
    // Assert(CompStart[0].LayerCount == 3);
    // Assert(CompStart[1].LayerCount == 2);
    // Assert(LayerArrayStart[0].Block_Layer_Index == 0);
    // Assert(LayerArrayStart[1].Block_Layer_Index == 2);
    // Assert(LayerArrayStart[2].Block_Layer_Index == 4);
    // Assert(LayerArrayStart[4].Block_Layer_Index == 1);
    // Assert(LayerArrayStart[5].Block_Layer_Index == 3);
}

block_layer * Layer_Init(project_data *File, memory *Memory)
{
    block_layer *Layer = (block_layer *)Memory_Block_AllocateAddress(Memory, F_Layers);
    History_Action_Block_Swap(Memory, F_Layers, Layer);

    *Layer = {};
    Layer->Occupied = 1;

    Layer->Block_String_Index = Memory_Block_AllocateNew(Memory, F_Strings);
    block_string *String = (block_string *)Memory_Block_AddressAtIndex(Memory, F_Strings, Layer->Block_String_Index);
    sprintf(String->Char, "Layer %i", File->Layer_Count + 1);  // CSbros...
    String->Occupied = 1;

    Layer->x =        Property_InitFloat("X Position",   0.0f, 1.0f);
    Layer->y =        Property_InitFloat("Y Position",   0.0f, 1.0f);
    Layer->ax =       Property_InitFloat("Anchor X",     0.5f, 0.005f);
    Layer->ay =       Property_InitFloat("Anchor Y",     0.5f, 0.005f);
    Layer->scale =    Property_InitFloat("Scale",        1.0f, 0.005f);
    Layer->rotation = Property_InitFloat("Rotation",     0.0f, 1.0f);
    Layer->opacity =  Property_InitFloat("Opacity",      1.0f, 0.005f, 0.0f, 1.0f);
    Layer->time =     Property_InitFloat("Frame Number", 0.0f, 1.0f, 0, 100000);

    Layer->IsVisible = 1;

    History_Action_Swap(Memory, F_File, sizeof(File->Layer_Count), &File->Layer_Count);
    File->Layer_Count++;

    return Layer;
}


static void
Layer_CreateFromSource(project_data *File, project_state *State, memory *Memory, uint16 SourceIndex, int32 Frame_End)
{
    if (File->Layer_Count + 1 > MAX_LAYERS) {
        Assert(0);
    }
    History_Entry_Commit(Memory,"Add layer from source");
    block_layer *Layer = Layer_Init(File, Memory);
    Layer->Block_Source_Index = SourceIndex;
    Layer->Frame_End = Frame_End;
    History_Entry_End(Memory);

    State->UpdateFrame = true;
}

#if 0
static void
IncrementFrame(project_data *File, int16 Amount) {
    if ((File->CurrentFrame <= 0 && Amount < File->StartFrame) || (File->CurrentFrame >= File->EndFrame)) {
        File->CurrentFrame = 0;
    } else {
        File->CurrentFrame += Amount;
    }
}

static void
CreateKeyframeBlock(property_channel *Property, memory *Memory)
{
    int16 a = Property->NumberOfKeyframeBlocks++;
    Assert(a < MAX_KEYFRAME_BLOCKS);

    Property->KeyframeBlock[a] = (keyframe_block *)AllocateMemory(Memory, sizeof(keyframe_block), F_Keyframes);
}

// Note we use total bytes here so we can use this memory for both packed and unpacked bitmaps.
void * Layer_AllocateBitmap(memory *Memory, uint16 Width, uint16 Height, uint16 BytesPerPixel)
{
    uint64 TotalBytes = Bitmap_CalcTotalBytes(Width, Height, BytesPerPixel);
    void *Address = AllocateMemory(Memory, TotalBytes, B_LayerBitmaps);
    return Address;
}

static cached_bitmap *
Cache_CheckBitmap(source *Source, layer_bitmap_info *BitmapInfo, memory *Memory, int32 TimelineFrame)
{
    if (!Source || !BitmapInfo)
        return 0;
    memory_table *Table = &Memory->Slot[B_LoadedBitmaps];
    int32 FrameToSeek = TimelineFrame - BitmapInfo->FrameOffset;
    if (FrameToSeek < 0) {
        FrameToSeek = 0;
    }
    // Stills have a frame index of one.
    if (Source->SourceType == source_type_image) {
        FrameToSeek = 0;
    }
    for (int i = 0; i < Table->NumberOfPointers; i++) {
        cached_bitmap *Bitmap = &Memory->Bitmap[i];
        if (Bitmap->Frame == FrameToSeek && Bitmap->SourceOwner == Source) {
            return Bitmap;
        }
    }
    return 0;
}

static cached_bitmap *
STB_LoadStill(source *Source, layer_bitmap_info *BitmapInfo, memory *Memory)
{
    int n = 0;
    int h, w;
    void *temp = stbi_load(Source->Path, &w, &h, &n, 4);
    Assert(temp);
    cached_bitmap *Bitmap = Memory_RollingBitmap(Memory, Source, 0);
    // Note the use of Unpacked since we haven't packed the bitmap and don't have any padding.
    uint64 Size = Bitmap_CalcUnpackedBytes(Source->Info.Width, Source->Info.Height, Source->Info.BytesPerPixel);
    Bitmap_CopyToPointer(temp, Bitmap->Data, Source->Info.BytesPerPixel, Size);
    return Bitmap;
}

static void
Layer_InitSource(project_layer *Layer, source *Source, memory *Memory)
{
    uint16 Width = Source->Info.Width;
    uint16 Height = Source->Info.Height;
    uint16 BytesPerPixel = Source->Info.BytesPerPixel;
    Layer->BitmapInfo.BitmapBuffer = Layer_AllocateBitmap(Memory, Width, Height, BytesPerPixel);
}

static void
Layer_PositionCenter(project_layer *Layer, uint16 Width, uint16 Height) {
    Layer->x.CurrentValue.f = Width/2;
    Layer->y.CurrentValue.f = Height/2;
}

static void
Layer_CreateFromSource(project_data *File, project_state *State, memory *Memory, source *Source)
{
    if (File->NumberOfLayers + 1 > MAX_LAYERS) {
        // TODO(fox): Output!
    }
    project_layer *Layer = Layer_Init(File, Memory);
    Layer->Source = Source;
    State->UpdateFrame = true;
}


static void
Layer_UpdateBitmap(project_data *File, project_layer *Layer, memory *Memory, int32 CurrentFrame) {
    source *Source = Layer->Source;
    layer_bitmap_info *BitmapInfo = &Layer->BitmapInfo;

    // AVInfo is created here instead of on layer creation so we can save
    // having to keep some state in the undo/delete commands.
    if (!BitmapInfo->AVInfo) {
        BitmapInfo->AVInfo = AllocateMemory(Memory, sizeof(av_info), P_AVInfo);
        AV_Init(Source, (av_info *)BitmapInfo->AVInfo, Memory);
        Layer_InitSource(Layer, Source, Memory);
        Layer_PositionCenter(Layer, File->Width, File->Height);
    }

    cached_bitmap *Bitmap = Cache_CheckBitmap(Source, BitmapInfo, Memory, CurrentFrame);
    if (!Bitmap)  {
        if (Source->SourceType == source_type_image) {
            Bitmap = STB_LoadStill(Source, BitmapInfo, Memory);
        } else {
            Bitmap = AV_LoadVideoFrame(Source, BitmapInfo, Memory, CurrentFrame);
        }
    }
    uint16 Width = Source->Info.Width;
    uint16 Height = Source->Info.Height;
    uint16 BytesPerPixel = Source->Info.BytesPerPixel;
    void *DestBuffer = BitmapInfo->BitmapBuffer;
    uint64 UnpackedSize = Bitmap_CalcUnpackedBytes(Source->Info.Width, Source->Info.Height, Source->Info.BytesPerPixel);
#if PACKEDRGB
    uint64 PackedSize = Bitmap_CalcTotalBytes(Source->Info.Width, Source->Info.Height, Source->Info.BytesPerPixel);

    if (Layer->NumberOfMasks == 0 && Layer->NumberOfEffects == 0) {
        Bitmap_ConvertPacking(Bitmap->Data, Memory->Scratch, Width, Height, BytesPerPixel, 0);
        Bitmap_CopyToPointer(Memory->Scratch, DestBuffer, BytesPerPixel, PackedSize);
    } else {
        Bitmap_CopyToPointer(Bitmap->Data, DestBuffer, BytesPerPixel, UnpackedSize);
        // GL_InitTexture(&BitmapInfo->Test, DestBuffer, Width, Height);
        // GL_MaskTexture(&BitmapInfo->TestM, DestBuffer, Width, Height);

        if (Layer->NumberOfMasks) {
            for (int i = 0; i < Layer->NumberOfMasks; i++) {
                mask *Mask = &Layer->Mask[i];
                if (Mask->IsClosed)
                    Mask_TriangulateAndRasterize(Memory, Layer, Mask);
            }
        }

        for (int i = 0; i < Layer->NumberOfEffects; i++)
        {
            if (Layer->Effect[i]->IsActive)
                Layer->Effect[i]->func(Source, BitmapInfo, Memory, Layer->Effect[i]->Property);
        }
        Bitmap_ConvertPacking(DestBuffer, Memory->Scratch, Width, Height, BytesPerPixel, 0);
        Bitmap_CopyToPointer(Memory->Scratch, DestBuffer, BytesPerPixel, PackedSize);
    }
#else
        Bitmap_CopyToPointer(Bitmap->Data, DestBuffer, BytesPerPixel, UnpackedSize);
        GL_UpdateTexture(&BitmapInfo->Test, DestBuffer, Width, Height, 0);
        GL_UpdateTexture(&BitmapInfo->TestM, DestBuffer, Width, Height, 1);

        if (Layer->NumberOfMasks) {
            for (int i = 0; i < Layer->NumberOfMasks; i++) {
                mask *Mask = &Layer->Mask[i];
                if (Mask->IsClosed)
                    Mask_TriangulateAndRasterize(Memory, Layer, Mask);
            }
            Bitmap_StencilAlpha(Bitmap->Data, DestBuffer, BytesPerPixel, UnpackedSize);
        }

        if (Layer->NumberOfEffects) {
            for (int i = 0; i < Layer->NumberOfEffects; i++)
            {
                if (Layer->Effect[i]->IsActive)
                    Layer->Effect[i]->func(Source, BitmapInfo, Memory, Layer->Effect[i]->Property);
            }
        }
#endif
}

static ImVec2
Layer_LocalToScreenSpace(project_layer *Layer, ui *UI, comp_buffer CompBuffer, v2 Point)
{
    real32 Rad = (Layer->rotation.CurrentValue.f * (PI / 180));
    real32 s = Layer->scale.CurrentValue.f;
    real32 AX = Layer->ax.CurrentValue.f;
    real32 AY = Layer->ay.CurrentValue.f;
    source *Source = Layer->Source;

    v2 XAxis = (Point.x - AX*Source->Info.Width)  * s  * V2(cos(Rad), sin(Rad));
    v2 YAxis = (Point.y - AY*Source->Info.Height) * -s * V2(sin(Rad), -cos(Rad));
    v2 LocalPoint = XAxis + YAxis;
    v2 CompUV = V2((Layer->x.CurrentValue.f + LocalPoint.x) / CompBuffer.Width,
                   (Layer->y.CurrentValue.f + LocalPoint.y) / CompBuffer.Height);
    v2 ScreenPoint = V2(UI->CompPos.x + CompUV.x * UI->CompZoom.x,
                        UI->CompPos.y + CompUV.y * UI->CompZoom.y);

    return ImVec2(ScreenPoint.x, ScreenPoint.y);
}

static v2
Layer_ScreenSpaceToLocal(project_layer *Layer, ui *UI, comp_buffer CompBuffer, ImVec2 ViewportMin, ImVec2 Point)
{
    source *Source = Layer->Source;
    v2 CompUV =  ImGui_ScreenPointToCompUV(ViewportMin, UI->CompPos, UI->CompZoom, Point);
    v2 LayerUV = CompUVToLayerUV(Layer, &CompBuffer, CompUV);
    return V2(LayerUV.x * Source->Info.Width, LayerUV.y * Source->Info.Height);
}

static void
LoadTestFootage(project_data *File, project_state *State, memory *Memory)
{
    void *SourceString = String_GenerateFromChar(Memory, "../asset/a.jpg");
    Source_Generate(File, State, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/24.mp4");
    Source_Generate(File, State, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/b.jpg");
    Source_Generate(File, State, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/c.jpg");
    Source_Generate(File, State, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/p.mp4");
    Source_Generate(File, State, Memory, SourceString);

    Layer_CreateFromSource(File, State, Memory, &File->Source[0]);
    Keyframe_Insert(&File->Layer[0]->x, Memory, 01, -10);
    Keyframe_Insert(&File->Layer[0]->x, Memory, 10, -5);
    Keyframe_Insert(&File->Layer[0]->x, Memory, 23, 0);
    Keyframe_Insert(&File->Layer[0]->x, Memory, 34, 5);

    for (int i = 0; i < 5; i++) {
        keyframe *Keyframe = KeyframeLookup(&File->Layer[0]->x, i);
        Keyframe->TangentLeft = V2(-3, 0);
        Keyframe->TangentRight = V2(1.5, 0);
        Keyframe->Type = bezier;
    }

    File->Layer[0]->x.IsToggled = true;
    SelectLayer(File->Layer[0], State, 0);
    // AddEffect(File->Layer[0], Memory, 1);
    // property_channel *Property = &File->Layer[0]->x;
    // for (int i = 0; i < 16; i++)
    //     Keyframe_Insert(Property, Memory, i*2, i*2*100);
    // Keyframe_Insert(Property, Memory, 1, 100);
    // Keyframe_Insert(Property, Memory, 15, 1500);
    // Keyframe_Insert(Property, Memory, 16, 1600);
    // Keyframe_Insert(Property, Memory, 31, 3100);

    // Keyframe_Delete(Property, Memory, 1);
    // History_Undo(Memory);
    // History_Redo(Memory);

        // Property->IsToggled = true;


    /*
    mask *Mask = &File->Layer[0]->Mask[0];
    File->Layer[0]->NumberOfMasks = 1;
    Mask->Point[0].Pos = V2(200, 200);
    Mask->Point[1].Pos = V2(210, 400);
    Mask->Point[2].Pos = V2(220, 520);
    Mask->Point[3].Pos = V2(1380, 520);
    Mask->Point[4].Pos = V2(1480, 200);

    Mask->Point[0].TangentLeft = V2(-50, 0);
    Mask->Point[1].TangentLeft = V2(-50, 0);
    Mask->Point[2].TangentLeft = V2(-50, 0);
    Mask->Point[3].TangentLeft = V2(-50, 0);
    Mask->Point[4].TangentLeft = V2(-50, 0);

    Mask->Point[0].TangentRight = V2(50, 0);
    Mask->Point[1].TangentRight = V2(50, 0);
    Mask->Point[2].TangentRight = V2(50, 0);
    Mask->Point[3].TangentRight = V2(50, 0);
    Mask->Point[4].TangentRight = V2(50, 0);

    Mask->Point[0].HandleBezier = true;
    Mask->Point[1].HandleBezier = true;
    Mask->Point[2].HandleBezier = true;
    Mask->Point[3].HandleBezier = true;
    Mask->Point[4].HandleBezier = true;

    Mask->NumberOfPoints = 5;
    Mask->IsClosed = true;
    */

    /*
    Mask_DeletePoint(Memory, Mask, 1);

    History_Undo(Memory);
    // History_Redo(Memory);

    Mask_AddPointToCurve(Memory, Mask, 1, 0.5);

    History_Undo(Memory);
    History_Redo(Memory);
    */

    // if (!Source_Generate(File, Memory, "../asset/test.png"))
    //     PostMsg(State, "File open fail...");
    // if (!Source_Generate(File, Memory, "../asset/debug.png"))
    //     PostMsg(State, "File open fail...");

    // property_channel *Property = &File->Layer[0]->x;
    // Keyframe_Insert(Property, Memory, 1, 500);
    // Keyframe_Insert(Property, Memory, 30, 800);
    // Keyframe_Insert(Property, Memory, 15, 400);
    // Keyframe_Insert(Property, Memory, 20, 100);
    // Property->IsToggled = true;
    // Property->IsGraphToggled = true;
    // Property->GraphLength = 150;
    // Property->GraphYOffset = (Property->GraphWindowHeight - Property->GraphLength)/2;

    // Layer_CreateFromSource(File, State, Memory, Source);

    // if (!Source_Generate(File, Memory, "../asset/p.mp4"))
    //     PostMsg(State, "File open fail...");
    // source *Source2 = &File->Source[1];
    // project_layer *Layer2 = Layer_Init(File, Memory);
    // AV_Init(Source2, &Layer2->BitmapInfo, Memory);
    // Layer_InitSource(Layer2, Source2, Memory);
    // Layer2->StartFrame = 11;
    // Layer2->EndFrame = 23;

    // void *SourceString1 = String_GenerateFromChar(Memory, "../asset/b.jpg");
    // if (!Source_Generate(File, Memory, SourceString1))
    //     PostMsg(State, "File open fail...");
    // source *Source1 = &File->Source[1];
    // for (int i = 0; i < 25; i++)
    //     Layer_CreateFromSource(File, State, Memory, Source1);
    // project_layer *Layer2 = Layer_Init(File, Memory);
    // Layer_InitSource(Layer2, Source2, Memory);

    // AddEffect(File->Layer[0], Memory, 2);
    // project_layer *Layer1 = CreateDebugLayer(&File, &Memory, 9, 14);
    // project_layer *Layer1 = CreateSolidLayer(&File, &Memory, 9, 13, V4(1.0, 1.0, 1.0, 1.0));
    // Layer1->x.CurrentValue.f = 7;
    // Layer1->y.CurrentValue.f = 4;
    // Layer1->StartFrame = 0;
    // Layer1->EndFrame = File.EndFrame;
}

static void
CreateDemoScene(project_data *File, project_state *State, memory *Memory)
{
    Layer_CreateFromSource(File, State, Memory, &File->Source[1]);
    project_layer *Layer1 = File->Layer[0];
    Layer1->x.CurrentValue.f = 1920/2;
    Layer1->y.CurrentValue.f = 1080/2;
    Layer1->StartFrame = 0;
    Layer1->EndFrame = File->EndFrame;
    Layer_CreateFromSource(File, State, Memory, &File->Source[2]);
    project_layer *Layer2 = File->Layer[1];
    Layer2->x.CurrentValue.f = 1920/2;
    Layer2->y.CurrentValue.f = 1080/2;
    Layer2->StartFrame = 0;
    Layer2->EndFrame = File->EndFrame;
    Keyframe_Insert(&Layer2->rotation, Memory, 2, 0);
    Keyframe_Insert(&Layer2->rotation, Memory, 50, 360);
    Layer2->rotation.IsToggled = true;
    Layer2->scale.IsToggled = true;
    Layer_CreateFromSource(File, State, Memory, &File->Source[3]);
    project_layer *Layer3 = File->Layer[2];
    Layer3->x.CurrentValue.f = 1920/4;
    Layer3->y.CurrentValue.f = 1080/4;
    Layer3->opacity.CurrentValue.f = 0.5f;
    Layer3->StartFrame = 0;
    Layer3->EndFrame = File->EndFrame;
    Keyframe_Insert(&Layer3->x, Memory, 2,  Layer3->x.CurrentValue.f);
    Keyframe_Insert(&Layer3->x, Memory, 30, Layer3->x.CurrentValue.f+(1280/2));
    Keyframe_Insert(&Layer3->x, Memory, 60, Layer3->x.CurrentValue.f+(1280/3));
    Layer3->x.IsToggled = true;
    Layer3->y.IsToggled = true;
}
#endif