#include "imgui/imgui.h" #include "my_imgui_internal_widgets.h" #include "imgui_ops.h" // 0 for timeline keyframe, 1 for graph keyframe, 2 for left graph handle, 3 for right graph handle static void ImGui_KeyframeDragging(project_data *File, project_state *State, ui *UI, property_channel *Property, int32 b, ImGuiIO io, int16 Type) { keyframe *Keyframe = KeyframeLookupMemory(Property, b); if (ImGui::IsItemActive()) { if (!Keyframe->IsSelected && ImGui::IsItemActivated()) { if (!io.KeyShift) { temp_keyframe_list Bad = GetSelectedKeyframes(File); for (int i = 0; i < Bad.Amount; i++) Bad.SelectedKeyframe[i]->IsSelected = false; } Keyframe->IsSelected = true; State->RecentSelectionType = selection_keyframe; } if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1)) { ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); if (Type == 0 || Type == 1) { UI->DraggingKeyframeThreshold += io.MouseDelta.x; if (abs(UI->DraggingKeyframeThreshold) >= UI->TimelineZoom) { int16 Increment = UI->DraggingKeyframeThreshold/UI->TimelineZoom; // temp_keyframe_list Bad = GetSelectedKeyframes(File); // for (int b = 0; b < Bad.Amount; b++) { // keyframe *SelectedKeyframe = Bad.SelectedKeyframe[b]; if (!(Keyframe->FrameNumber == 0 && Increment == -1)) { Keyframe->FrameNumber += Increment; CheckKeyframeSort(Property, Increment, b); // SortAndCacheKeyframeAtFrame(SelectedKeyframe->FrameNumber, &File.LayerPTR[i]->Property[a], &Cache); ClampSurroundingKeyframeHandles(Property, b); } // } UI->DraggingKeyframeThreshold += -1*Increment*UI->TimelineZoom; State->UpdateFrame = true; State->UpdateKeyframes = true; // Cache.Frame[File.CurrentFrame].Cached = false; } } if (Type != 0) { if (Type == 1) { real32 IncrementsPerPixel = (Property->LocalMaxVal.f - Property->LocalMinVal.f)/Property->GraphLength; Keyframe->Value.f -= io.MouseDelta.y*IncrementsPerPixel; CalculatePropertyMinMax(Property); } if (Type == 2) { Keyframe->TangentLeft.x += io.MouseDelta.x/UI->TimelineZoom; Keyframe->TangentLeft.y -= io.MouseDelta.y; ClampKeyframeHandles(Property, b, 0); } if (Type == 3) { Keyframe->TangentRight.x += io.MouseDelta.x/UI->TimelineZoom; Keyframe->TangentRight.y -= io.MouseDelta.y; ClampKeyframeHandles(Property, b, 1); } State->UpdateFrame = true; State->UpdateKeyframes = true; } } } } static void ImGui_DebugMemoryViewer(project_data *File, memory *Memory) { ImGui::SetNextWindowSize(ImVec2(800, 200)); ImGui::Begin("memoryviewer"); ImVec2 ViewportMin = ImGui::GetCursorScreenPos(); ImVec2 ViewportScale = ImGui::GetContentRegionAvail(); ImVec2 ViewportMax = ImVec2(ViewportMin.x + ViewportScale.x, ViewportMin.y + ViewportScale.y); memory_table *Table = &Memory->Slot[B_LoadedBitmaps]; real32 TotalMB = Table->Size/1024/1024; real32 LineAmount = 50; real32 IncrementMB = TotalMB / LineAmount; real32 ScreenIncrement = ViewportScale.x / LineAmount; real32 CubeHeight = ImGui::GetFontSize(); real32 TotalHeight = CubeHeight*4; ImDrawList* draw_list = ImGui::GetWindowDrawList(); draw_list->AddRectFilled(ViewportMin, ViewportMax, IM_COL32(50, 50, 50, 255)); for (float x = 0; x < LineAmount; x++) { uint32 LineColor = IM_COL32(200, 200, 200, 40); ImVec2 Min = ImVec2(ViewportMin.x + ScreenIncrement * x, ViewportMin.y); ImVec2 Max = ImVec2(Min.x + 2, ViewportMax.y); draw_list->AddLine(Min, Max, LineColor); } // CurrentPosition line { uint32 LineColor = IM_COL32(000, 100, 200, 200); real32 CurPosMB = (real32)Table->CurrentPosition/1024/1024; ImVec2 Min = ImVec2(ViewportMin.x + (CurPosMB/IncrementMB * ScreenIncrement), ViewportMin.y); ImVec2 Max = ImVec2(Min.x + 2, ViewportMax.y); draw_list->AddLine(Min, Max, LineColor); } for (uint32 i = 0; i < Table->NumberOfPointers; i++) { if (Memory->Bitmap[i].SourceOwner) { void *DataStart = Memory->Bitmap[i].Data; void *NextDataStart; int pp = 1; for (;;) { if (Memory->Bitmap[i+pp].SourceOwner) { NextDataStart = Memory->Bitmap[i+pp].Data; break; } pp++; } uint64 BytesBetween = (uint8 *)NextDataStart - (uint8 *)DataStart; source *Source = Memory->Bitmap[i].SourceOwner; real32 Pos = Memory_NormalizedPosition(&File->Source[0], File->NumberOfSources, sizeof(source), Source); ImVec4 col = ImColor::HSV(Pos, 0.3, 0.6, 1.0f); uint64 BitmapSize = Bitmap_CalcTotalBytes(Source->Info.Width, Source->Info.Height, Source->Info.BytesPerPixel); if (BitmapSize > BytesBetween && i != Table->NumberOfPointers - 1) { col = ImColor::HSV(Pos, 1.0, 1.0, 1.0f); } uint64 DataStart2 = (uint8 *)DataStart - (uint8 *)Table->Address; real32 StartReal = ((real32)DataStart2/1024/1024); ImVec2 Min = ImVec2(ViewportMin.x + (StartReal/IncrementMB * ScreenIncrement), ViewportMin.y + (ViewportScale.y / 2) - (TotalHeight / 2) + TotalHeight*Pos); real32 SizeReal = ((real32)BitmapSize/1024/1024); ImVec2 Size = ImVec2(SizeReal/IncrementMB * ScreenIncrement, CubeHeight); ImGui::SetCursorScreenPos(Min); ImGui::PushID(i); ImGui::PushStyleColor(ImGuiCol_Button, col); char buf2[256]; sprintf(buf2, "%i##mempos", Memory->Bitmap[i].Frame); ImGui::Button(buf2, Size); ImGui::PopStyleColor(); if (ImGui::IsItemHovered()) { char buf[1024]; sprintf(buf, "Source owner: %s\nSize: %.02f MB\n Frame number: %i\n Index: %i", Memory->Bitmap[i].SourceOwner->Path, SizeReal, Memory->Bitmap[i].Frame, i); ImGui::BeginTooltip(); ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f); ImGui::TextUnformatted(buf); ImGui::PopTextWrapPos(); ImGui::EndTooltip(); } ImGui::PopID(); ImVec2 Max = ImVec2(ViewportMax.x, Min.y + CubeHeight); // draw_list->AddRectFilled(Min, Max, IM_COL32(200, 200, 200, 255)); } } ImGui::SetCursorScreenPos(ImVec2(ViewportMin.x, ViewportMax.y - CubeHeight*2)); char buf[1024]; sprintf(buf, "Current index: %i\nAmount of pointers: %i", Table->PointerIndex, Table->NumberOfPointers); ImGui::Text(buf); ImGui::End(); } static void ImGui_PropertiesPanel(project_data *File, project_state *State, ui *UI, memory *Memory) { if (State->MostRecentlySelectedLayer > -1) { project_layer *Layer = File->Layer[State->MostRecentlySelectedLayer]; char buf[256]; sprintf(buf, "Properties: %s###Properties", Layer->Name); ImGui::Begin(buf); if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) UI->FocusedWindow = focus_properties; ImGui::Text("Transform"); for (int h = 0; h < AmountOf(Layer->Property); h++) { property_channel *Property = &Layer->Property[h]; ImGui::PushID(Property); if (ImGui::Button("K")) ManualKeyframeInsertF(Property, Memory, File->CurrentFrame, Property->CurrentValue.f); ImGui::SameLine(); if (ImGui::DragScalar(Property->Name, ImGuiDataType_Float, &Property->CurrentValue.f, Property->ScrubVal.f, &Property->MinVal.f, &Property->MaxVal.f, "%f")) { State->UpdateFrame = true; } ImGui::PopID(); } for (int h = 0; h < Layer->NumberOfEffects; h++) { effect *Effect = Layer->Effect[h]; ImGui::Button("V"); ImGui::SameLine(); ImGui::Text(Effect->Name); if (Effect->DisplayType == standard) { for (int i = 0; i < Effect->NumberOfProperties; i++) { property_channel *Property = &Effect->Property[i]; ImGui::PushID(Property); if (Property->VarType == type_real) ImGui::DragScalar(Property->Name, ImGuiDataType_Float, &Property->CurrentValue.f, 0.005f, &Property->MaxVal.f, &Property->MaxVal.f, "%f"); if (Property->VarType == type_color) if (ImGui::ColorEdit4("color 1", &Property->CurrentValue.f, ImGuiColorEditFlags_Float)) State->UpdateFrame = true; if (Property->VarType == type_blendmode) { uint32 *item_current_idx = (uint32 *)&Property->CurrentValue.blendmode; // Here we store our selection data as an index. if (ImGui::BeginListBox("Blend mode")) { for (int n = 0; n < IM_ARRAYSIZE(BlendmodeNames); n++) { const bool is_selected = (*item_current_idx == n); if (ImGui::Selectable(BlendmodeNames[n], is_selected)) { *item_current_idx = n; State->UpdateFrame = true; } // Set the initial focus when opening the combo (scrolling + keyboard navigation focus) if (is_selected) ImGui::SetItemDefaultFocus(); } ImGui::EndListBox(); } } ImGui::PopID(); } } else if (Effect->DisplayType == levels) { real32 *Min = &Effect->Property[0].CurrentValue.f; real32 *Mid = &Effect->Property[1].CurrentValue.f; real32 *Max = &Effect->Property[2].CurrentValue.f; ImGui::SliderLevels("f", Mid, Min, Max); } } } else { char buf[256]; sprintf(buf, "Properties: empty###Properties"); ImGui::Begin(buf); if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) UI->FocusedWindow = focus_properties; } ImGui::End(); } static v2 CalculateAnchorPointUV(project_layer *Layer, comp_buffer *Buffer); static void ImGui_Viewport(project_data File, project_state *State, ui *UI, comp_buffer CompBuffer, ImGuiIO io, GLuint textureID) { ImGui::Begin("Viewport"); if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) UI->FocusedWindow = focus_viewport; // Primarily taken from the Custom Rendering section of the demo ImVec2 ViewportMin = ImGui::GetCursorScreenPos(); ImVec2 ViewportScale = ImGui::GetContentRegionAvail(); ViewportScale.y -= ImGui::GetFontSize(); if (ViewportScale.x < 50.0f) ViewportScale.x = 50.0f; if (ViewportScale.y < 50.0f) ViewportScale.y = 50.0f; ImVec2 ViewportMax = ImVec2(ViewportMin.x + ViewportScale.x, ViewportMin.y + ViewportScale.y); if (UI->Initializing) { UI->CompZoom = ImVec2(CompBuffer.Width, CompBuffer.Height); UI->CompPos = ImVec2(ViewportMin.x + ((ViewportMax.x - ViewportMin.x)/2 - UI->CompZoom.x/2), ViewportMin.y + ((ViewportMax.y - ViewportMin.y)/2 - UI->CompZoom.y/2)); } ImDrawList* draw_list = ImGui::GetWindowDrawList(); draw_list->AddRectFilled(ViewportMin, ViewportMax, IM_COL32(50, 50, 50, 255)); draw_list->AddRect(ViewportMin, ViewportMax, IM_COL32(255, 255, 255, 255)); ImGui::InvisibleButton("canvas", ViewportScale, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight); bool32 IsHovered = ImGui::IsItemHovered(); bool32 IsActive = ImGui::IsItemActive(); bool32 IsActivated = ImGui::IsItemActivated(); if (IsHovered && IsActivated && ImGui::IsMouseDown(ImGuiMouseButton_Left)) { v2 LocalMousePos = (V2(io.MousePos) - V2(ViewportMin)); v2 LocalCompPos = V2(UI->CompPos) - V2(ViewportMin); v2 MouseScreenUV = LocalMousePos - LocalCompPos; UI->TempZoomRatio = MouseScreenUV / V2(UI->CompZoom); // AKA actual normalized UV of comp if (!ImGui::IsKeyDown(ImGuiKey_Z)) { for (int i = File.NumberOfLayers - 1; i >= 0; i--) { if (!io.KeyShift) DeselectAllLayers(&File, State); if (TestPointInLayer(File.Layer[i], &CompBuffer, UI->TempZoomRatio) && !File.Layer[i]->IsSelected) { SelectLayer(File.Layer[i], State, i); break; } } } } if (IsActive && ImGui::IsMouseDragging(ImGuiMouseButton_Right, -1.0f)) { UI->CompPos.x += io.MouseDelta.x; UI->CompPos.y += io.MouseDelta.y; } // if (IsActive && ImGui::IsMouseDown(ImGuiMouseButton_Right)) // { // Debug.ToggleRenders = true; // } ImGui::OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonMiddle); if (ImGui::BeginPopup("context")) { if (ImGui::MenuItem("Scalar", NULL, false, InstructionMode != instruction_mode_scalar)) { InstructionMode = instruction_mode_scalar; State->UpdateFrame = true; } if (ImGui::MenuItem("SSE", NULL, false, InstructionMode != instruction_mode_sse)) { InstructionMode = instruction_mode_sse; State->UpdateFrame = true; } if (ImGui::MenuItem("AVX2", NULL, false, InstructionMode != instruction_mode_avx)) { InstructionMode = instruction_mode_avx; State->UpdateFrame = true; } ImGui::EndPopup(); } if (IsActive && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1.0f) && ImGui::IsKeyDown(ImGuiKey_Z)) { real32 Distance = io.MouseDelta.x + io.MouseDelta.y; UI->CompZoom.x += (Distance)*(real32)CompBuffer.Width/CompBuffer.Height; UI->CompZoom.y += (Distance); UI->CompPos.x -= ((Distance)*(real32)CompBuffer.Width/CompBuffer.Height)*UI->TempZoomRatio.x; UI->CompPos.y -= Distance*UI->TempZoomRatio.y; } draw_list->PushClipRect(ViewportMin, ViewportMax, true); draw_list->AddImage((void *)(intptr_t)textureID, ImVec2(UI->CompPos.x, UI->CompPos.y), ImVec2(UI->CompPos.x + UI->CompZoom.x, UI->CompPos.y + UI->CompZoom.y)); if (State->MostRecentlySelectedLayer > -1) { project_layer *Layer = File.Layer[State->MostRecentlySelectedLayer]; ImVec2 AUV = ImVec2(Layer->x.CurrentValue.f / CompBuffer.Width, Layer->y.CurrentValue.f / CompBuffer.Height); ImVec2 ScreenAP = ImVec2(UI->CompPos.x + AUV.x * UI->CompZoom.x, UI->CompPos.y + AUV.y * UI->CompZoom.y); draw_list->AddNgon(ScreenAP, 20, ImGui::GetColorU32(ImGuiCol_ScrollbarGrab), 8, 10.0f); } draw_list->PopClipRect(); ImGui::Text("%.1f", 100.0f * (UI->CompZoom.x / CompBuffer.Width)); if (State->MsgTime > 0) { ImGui::SameLine(); ImGui::SetCursorPosX((ViewportScale.x / 5)*4); ImGui::Text(State->Msg); State->MsgTime--; } ImGui::End(); } // 1 for left, 2 for right, 3 for both static bool32 ImGui_SlidingLayer(project_layer *Layer, real32 *DraggingThreshold, real32 Delta, int16 TimelineZoom, int16 Side) { bool32 Result = 0; if (ImGui::IsItemActive() && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1)) { ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); *DraggingThreshold += Delta; if (abs(*DraggingThreshold) >= TimelineZoom) { int16 Increment = *DraggingThreshold/TimelineZoom; // TODO(fox): Properly handle the start and end points wrapping. if (!(Increment < 0 && Layer->StartFrame == 0 && Side & 1)) { if (Side & 1) Layer->StartFrame += Increment; if (Side & 2) Layer->EndFrame += Increment; if (Side == 3) { IncrementKeyframesInLayer(Layer, Increment); if (Layer->Source->SourceType == source_type_video) { Layer->BitmapInfo.FrameOffset += Increment; } } } *DraggingThreshold += -1*Increment*TimelineZoom; } Result = 1; } return Result; } static void ImGui_File(project_data *File, project_state *State, memory *Memory, ui *UI, ImGuiIO io) { ImGui::Begin("Files"); ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate); if (State->DemoButton) { if (ImGui::Button("Generate demo scene")) { // CreateDemoScene(File, Memory); State->UpdateKeyframes = true; State->UpdateFrame = true; State->DemoButton = false; } } if (State->GridButton) { ImGui::SameLine(); if (ImGui::Button("Generate square grid")) { // CreateGrid(File, Memory); State->UpdateKeyframes = true; State->UpdateFrame = true; State->GridButton = false; } } ImGui::Text("Sources:"); for (int i = 0; i < File->NumberOfSources; i++) { ImGui::Text(File->Source[i].Path); ImGui::OpenPopupOnItemClick("sourcecontext", ImGuiPopupFlags_MouseButtonRight); if (ImGui::BeginPopup("sourcecontext")) { if (ImGui::MenuItem("Create layer from source")) { Layer_CreateFromSource(File, State, Memory, &File->Source[i]); } ImGui::EndPopup(); } } // static char Input[1024]; // ImGui::InputText("##sourceinput", Input, STRING_SIZE); // ImGui::SameLine(); // if (ImGui::Button("Create Layer")) { // // AddSource(File, State, Memory, Input); // } #if DEBUG for (int i = 0; i < Debug.WatchedProperties; i++) { if (Debug.DebugPropertyType[i] == d_float) { ImGui::Text("%s: %f", Debug.String[i], Debug.Val[i].f); } else if (Debug.DebugPropertyType[i] == d_int) { ImGui::Text("%s: %i", Debug.String[i], Debug.Val[i].i); } else if (Debug.DebugPropertyType[i] == d_uint) { ImGui::Text("%s: %u", Debug.String[i], Debug.Val[i].u); } } #endif ImGui::End(); } static void ImGui_EffectsPanel(project_data *File, project_state *State, memory *Memory, ui *UI, ImGuiIO io) { ImGui::Begin("Effects list", NULL); if (State->RerouteEffects) { ImGui::SetKeyboardFocusHere(); State->RerouteEffects = 0; } int value_changed = ImGui::InputText("Effect name...", State->filter.InputBuf, IM_ARRAYSIZE(State->filter.InputBuf), ImGuiInputTextFlags_CallbackCompletion, EffectConsoleCallback); if (Hacko) { if (!io.KeyShift) EffectSel++; else EffectSel--; Hacko = 0; } if (value_changed) { State->filter.Build(); EffectSel = -1; } // Enter conveniently deactivates the InputText field if (ImGui::IsItemDeactivated() && ImGui::IsKeyPressed(ImGuiKey_Enter)) { int32 p = 0; for (int32 i = 0; i < AmountOf(EffectList); i++) { if (State->filter.PassFilter(EffectList[i].Name)) { if (EffectSel == p && State->MostRecentlySelectedLayer != -1) { AddEffect(File->Layer[State->MostRecentlySelectedLayer], Memory, i); } p++; } } EffectSel = -1; } int32 p = 0; for (int32 i = 0; i < AmountOf(EffectList); i++) { if (State->filter.PassFilter(EffectList[i].Name)) { bool t = false; if (EffectSel == p) { t = true; } ImGui::Selectable(EffectList[i].Name, &t); if (ImGui::IsItemClicked()) { if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left) && State->MostRecentlySelectedLayer != -1) { AddEffect(File->Layer[State->MostRecentlySelectedLayer], Memory, i); } } p++; } } ImGui::End(); } static void ImGui_Timeline(project_data *File, project_state *State, memory *Memory, ui *UI, ImGuiIO io) { ImVec2 FramePadding = ImGui::GetStyle().FramePadding; ImVec2 ItemSpacing = ImGui::GetStyle().ItemSpacing; ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0)); ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0)); // makes setting up the layout easier ImGui::Begin("Timeline", NULL); if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) UI->FocusedWindow = focus_timeline; real32 FontHeight = ImGui::GetFontSize(); ImVec2 WindowSize = ImGui::GetWindowSize(); if (WindowSize.x < 50.0f) WindowSize.x = 50.0f; // prevent crashing if the window gets too small if (WindowSize.y < 50.0f) WindowSize.y = 50.0f; // (still crashes) ImVec2 WindowMinAbs = ImGui::GetWindowPos(); ImVec2 WindowMaxAbs = WindowMinAbs + WindowSize; ImVec2 ButtonSize = ImVec2(FontHeight*2, FontHeight*2); real32 TopbarHeight = FontHeight*4; ImVec2 TopbarMax = ImVec2(WindowMaxAbs.x, WindowMinAbs.y + TopbarHeight); ImVec2 TimelineBorderPadding = ImVec2(FontHeight, FontHeight); ImVec2 TopbarSize = ImVec2(WindowSize.x, TopbarHeight); ImVec2 TopbarButtonSize = ImVec2(TopbarHeight, TopbarHeight); // NOTE(fox): StartingPos values include X and Y scroll, primarily used for // the keyframes/layers. Absolute doesn't include scroll, primarily used // for the clip rects. ImVec2 SidebarSize = ImVec2(UI->TimelineSplit, WindowSize.y - TopbarHeight); ImVec2 SidebarSizeWithBorder = SidebarSize - TimelineBorderPadding*2; ImVec2 SidebarAbsolutePos = WindowMinAbs + ImVec2(0, TopbarSize.y) + TimelineBorderPadding; ImVec2 SidebarStartingPos = SidebarAbsolutePos + ImVec2(0, UI->ScrollYOffset); ImVec2 TimelineSize = ImVec2(WindowSize.x - SidebarSize.x, SidebarSize.y); ImVec2 TimelineSizeWithBorder = TimelineSize - TimelineBorderPadding*2; ImVec2 TimelineAbsolutePos = WindowMinAbs + ImVec2(SidebarSize.x, TopbarSize.y) + TimelineBorderPadding; ImVec2 TimelineStartingPos = SidebarStartingPos + ImVec2(SidebarSize.x + UI->ScrollXOffset, 0); // Timeline and sidebar size including the padding between them ImVec2 TimelineFullSize = TimelineSizeWithBorder + SidebarSizeWithBorder + ImVec2(TimelineBorderPadding.x*2, 0); ImVec2 KeyframeSize = ImVec2(FontHeight, FontHeight); ImVec2 PlayheadPos = ImVec2(TimelineStartingPos.x + UI->TimelineZoom * File->CurrentFrame, WindowMinAbs.y + TopbarSize.y/2); // NOTE(fox): The InvisibleButton hitbox that handles mouse inputs on the // graph occludes the hitbox that handles box drag selection, so I'm using // this struct to carry over the state from the former to the latter. imgui_buttonstate AnimationCurves = {}; if (UI->Initializing) { UI->TimelineZoom = TimelineSizeWithBorder.x / (File->NumberOfFrames + 1); } ImDrawList* draw_list = ImGui::GetWindowDrawList(); draw_list->AddRectFilled(WindowMinAbs, WindowMaxAbs, IM_COL32(255, 255, 255, 50)); draw_list->AddRectFilled(WindowMinAbs, TopbarMax, IM_COL32(255, 255, 255, 50)); // ImGui::BeginChild("Topbar", TopbarSize, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar); // ImGui::Text /* ImGui::Button("V", TopbarButtonSize); ImGui::SameLine(); ImGui::Button("V", TopbarButtonSize); ImGui::SameLine(); ImGui::Button("V", TopbarButtonSize); ImGui::SameLine(); */ ImGui::SetCursorScreenPos(PlayheadPos); ImGui::Button("P", ButtonSize); if (ImGui::IsItemActive()) { if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1)) { UI->DraggingKeyframeThreshold += io.MouseDelta.x; if (abs(UI->DraggingKeyframeThreshold) >= UI->TimelineZoom) { int16 Increment = UI->DraggingKeyframeThreshold/UI->TimelineZoom; if (File->CurrentFrame <= 0 && Increment < File->StartFrame) File->CurrentFrame = 0; else if (File->CurrentFrame >= File->EndFrame && Increment > File->EndFrame) { File->CurrentFrame = File->EndFrame; } else { File->CurrentFrame += Increment; } State->UpdateFrame = true; State->UpdateKeyframes = true; UI->DraggingKeyframeThreshold += -1*Increment*UI->TimelineZoom; } } } ImGui::EndChild(); /// ImGui::BeginChild("Sidebar", SidebarSize, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar); ImGui::SetCursorScreenPos(SidebarStartingPos); ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ItemSpacing); ImGui::PushClipRect(SidebarAbsolutePos, SidebarAbsolutePos + SidebarSizeWithBorder, true); for (int i = File->NumberOfLayers - 1; i >= 0; i--) { project_layer *Layer = File->Layer[i]; ImGui::PushID(i); ImGui::SetCursorScreenPos(ImVec2(SidebarStartingPos.x, ImGui::GetCursorScreenPos().y)); draw_list->PushClipRect(SidebarAbsolutePos, SidebarAbsolutePos + TimelineFullSize, true); if (Layer->IsSelected) { real32 Y = ImGui::GetCursorScreenPos().y; draw_list->AddRectFilled(ImVec2(SidebarAbsolutePos.x, Y), ImVec2(TimelineAbsolutePos.x + TimelineSize.x, Y + FontHeight + FramePadding.y*2), IM_COL32(255, 255, 255, 50)); } draw_list->PopClipRect(); ImGui::Button("V"); ImGui::SameLine(); ImGui::Button("I"); ImGui::SameLine(); ImGui::Text(Layer->Name); ImGui::SameLine(); ImGui::Button(BlendmodeNames[Layer->BlendMode]); ImGui::OpenPopupOnItemClick("blendmode_picker", ImGuiPopupFlags_MouseButtonLeft); if (ImGui::BeginPopup("blendmode_picker")) { for (int16 b = 0; b < AmountOf(BlendmodeNames); b++) { if (ImGui::MenuItem(BlendmodeNames[b], NULL, false, Layer->BlendMode != b)) { Layer->BlendMode = (blend_mode)b; State->UpdateFrame = true; } // using IsActivated here instead of above loop doesn't seem to // work; the popup gets closed instead if (ImGui::IsItemHovered() && io.KeyCtrl) { Layer->BlendMode = (blend_mode)b; State->UpdateFrame = true; } } ImGui::EndPopup(); } ImGui::SameLine(); ImGui::SetCursorScreenPos(ImVec2(SidebarStartingPos.x, ImGui::GetCursorScreenPos().y)); ImGui::Button("##mover", ImVec2(SidebarSizeWithBorder.x, FontHeight + FramePadding.y*2)); // Layer dragging interaction if (ImGui::IsItemActive()) { if (ImGui::IsItemActivated() && !Layer->IsSelected) { if (!io.KeyShift) DeselectAllLayers(File, State); SelectLayer(Layer, State, i); } if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1) ) { ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); UI->DraggingLayerThreshold -= io.MouseDelta.y; real32 Threshold = FontHeight + FramePadding.y*2; if (abs(UI->DraggingLayerThreshold) >= Threshold) { int16 Increment = UI->DraggingLayerThreshold/abs(UI->DraggingLayerThreshold); MoveLayersByIncrement(File, State, Increment); UI->DraggingLayerThreshold += -1*Increment*Threshold; State->UpdateFrame = true; // Cache.Frame[File->CurrentFrame].Cached = false; } } } // Properties gap ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, ItemSpacing.y * UI->KeyframeSpacing)); for (int a = 0; a < AmountOf(Layer->Property); a++) { if (Layer->Property[a].IsToggled) { property_channel *Property = &Layer->Property[a]; ImGui::PushID(Property); // if (Property->IsSelected) { // real32 Y = ImGui::GetCursorScreenPos().y; // draw_list->AddRectFilled(ImVec2(SidebarAbsolutePos.x, Y), // ImVec2(TimelineAbsolutePos.x, Y + FontHeight + FramePadding.y*2), // IM_COL32(100, 0, 255, 50)); // } ImGui::SetCursorScreenPos(ImVec2(SidebarStartingPos.x, ImGui::GetCursorScreenPos().y)); ImGui::Text(Property->Name); real32 YInit = ImGui::GetCursorScreenPos().y; ImGui::SameLine(); if (ImGui::Button("K")) ManualKeyframeInsertF(Property, Memory, File->CurrentFrame, Property->CurrentValue.f); ImGui::SameLine(); if (ImGui::Button("G")) { SwitchBool(Property->IsGraphToggled); // TODO(fox): Make system to init things like these automatically? if (!Property->GraphLength) { Property->GraphLength = 150; Property->GraphYOffset = (Property->GraphWindowHeight - Property->GraphLength)/2; } } ImGui::SetCursorScreenPos(ImVec2(ImGui::GetCursorScreenPos().x, YInit)); if (Property->IsGraphToggled) { ImGui::Dummy(ImVec2(5, Property->GraphWindowHeight)); } ImGui::PopID(); } } ImGui::PopStyleVar(); ImGui::PopID(); } ImGui::PopClipRect(); /// Split size adjuster ImGui::SetCursorScreenPos(ImVec2(WindowMinAbs.x + UI->TimelineSplit - TimelineBorderPadding.x, TimelineAbsolutePos.y)); ImGui::InvisibleButton("##SplitMove", ImVec2(TimelineBorderPadding.x, SidebarSizeWithBorder.y), ImGuiButtonFlags_MouseButtonLeft); if (ImGui::IsItemHovered()) { ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); } if (ImGui::IsItemActive() && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1)) { UI->TimelineSplit += io.MouseDelta.x; } ImGui::PopStyleVar(); ImGui::EndChild(); ImGui::SameLine(); /// ImGui::BeginChild("Timeline", TimelineSize, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar); ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, ItemSpacing.y)); ImGui::SetCursorScreenPos(TimelineStartingPos); ImGui::PushClipRect(TimelineAbsolutePos, TimelineAbsolutePos + TimelineSizeWithBorder, true); draw_list->PushClipRect(TimelineAbsolutePos, TimelineAbsolutePos + TimelineSizeWithBorder, true); for (int i = File->NumberOfLayers - 1; i >= 0; i--) { // The actual layer bars project_layer *Layer = File->Layer[i]; ImGui::PushID(i); uint16 LayerTLSpan = Layer->EndFrame - Layer->StartFrame; // if (Layer->SourceType == video) { // video_source *Source = (video_source *)Layer->RenderInfo; // real32 XMin = TimelineMinX + UI->TimelineZoom*Source->VideoFrameOffset; // // real32 YMin = StartingCursorPosAbs.y + (FontHeight + FramePadding.y*2 + ItemSpacing.y)*i; // real32 YMin = ImGui::GetCursorScreenPos().y; // draw_list->AddRect(ImVec2(WindowMin.x, YMin), // ImVec2(WindowMaxAbs.x, YMin + FontHeight + FramePadding.y*2), // IM_COL32(255, 255, 255, 50), 2); // } ImGui::SetCursorScreenPos(ImVec2(TimelineStartingPos.x + UI->TimelineZoom*Layer->StartFrame, ImGui::GetCursorScreenPos().y)); ImGui::Button("##leftbound", ImVec2(0.5 * UI->TimelineZoom, 0)); ImGui::SameLine(); if (ImGui::IsItemHovered()) { ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); } ImGui_SlidingLayer(Layer, &UI->DraggingKeyframeThreshold, io.MouseDelta.x, UI->TimelineZoom, 1); // TODO(fox): Investigate why this button doesn't get lined up with // leftbound in certain cases. (i.e. rotation property expanded with keyframes) ImGui::Button("##layer", ImVec2((LayerTLSpan * UI->TimelineZoom), 0)); ImGui::SameLine(); if (ImGui::IsItemClicked()) { if (!io.KeyShift) DeselectAllLayers(File, State); SelectLayer(Layer, State, i); } if (ImGui_SlidingLayer(Layer, &UI->DraggingLayerThreshold, io.MouseDelta.x, UI->TimelineZoom, 3)) { // TODO(fox): This will be removed once video caching is implemented. UI->TemporaryUpdateOverride = true; } ImGui::Button("##rightbound", ImVec2(0.5 * UI->TimelineZoom, 0)); if (ImGui::IsItemHovered()) { ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); } ImGui_SlidingLayer(Layer, &UI->DraggingKeyframeThreshold, io.MouseDelta.x, UI->TimelineZoom, 2); for (int a = Layer->StartFrame; a < Layer->EndFrame; a++) { cached_bitmap *Bitmap = Cache_CheckBitmap(Layer->Source, &Layer->BitmapInfo, Memory, a); if (Bitmap) { ImVec2 MinPos = ImVec2(TimelineStartingPos.x + UI->TimelineZoom * a, ImGui::GetCursorScreenPos().y); draw_list->AddRect(MinPos, ImVec2(MinPos.x + UI->TimelineZoom, MinPos.y + 2.0f), ImColor(0, 255, 0, 255)); } } ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, ItemSpacing.y * UI->KeyframeSpacing)); ImGui::SetCursorPosY(ImGui::GetCursorPos().y + (ItemSpacing.y * UI->KeyframeSpacing / 2)); for (int a = 0; a < AmountOf(Layer->Property); a++) { if (Layer->Property[a].IsToggled) { real32 InitialY = ImGui::GetCursorScreenPos().y; ImGui::NewLine(); real32 NextY = ImGui::GetCursorScreenPos().y; property_channel *Property = &Layer->Property[a]; ImGui::PushID(Property); for (int b = 0; b < Layer->Property[a].NumberOfTotalKeyframes; b++) { keyframe *Keyframe = KeyframeLookupMemory(Property, b); real32 KeyframeOrigin = TimelineStartingPos.x + UI->TimelineZoom*Keyframe->FrameNumber; ImVec2 KeyframePosition = ImVec2(KeyframeOrigin - FontHeight/2, InitialY); ImGui::PushID(Keyframe); ImGui::SetCursorScreenPos(KeyframePosition); // sadly ImGui::Selectable doesn't work here if (Keyframe->IsSelected) ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetColorU32(ImGuiCol_ButtonHovered)); ImGui::Button("##keyframe", ImVec2(FontHeight, FontHeight)); ImGui::SameLine(); if (Keyframe->IsSelected) ImGui::PopStyleColor(); if (UI->BoxSelectActive && UI->BoxStart.y < NextY) { if (IsRectTouching(UI->BoxStart, UI->BoxEnd, KeyframePosition, KeyframePosition + KeyframeSize)) { SelectKeyframe(File, Layer, Property, Keyframe); State->RecentSelectionType = selection_keyframe; } else if (!io.KeyShift) { Keyframe->IsSelected = false; } } ImGui_KeyframeDragging(File, State, UI, Property, b, io, 0); ImGui::PopID(); } ImGui::SetCursorScreenPos(ImVec2(ImGui::GetCursorScreenPos().x, NextY)); if (Property->IsGraphToggled) { uint16 GraphWindowHeight = File->Layer[i]->Property[a].GraphWindowHeight; real32 GraphWindowLocalYMin = ImGui::GetCursorPosY(); ImDrawList* draw_list = ImGui::GetWindowDrawList(); real32 ScreenY = NextY; ImVec2 MinPos = ImVec2(TimelineAbsolutePos.x, ScreenY); ImVec2 MaxPos = ImVec2(TimelineAbsolutePos.x + TimelineSizeWithBorder.x, ScreenY + GraphWindowHeight); draw_list->AddRectFilled(MinPos, MaxPos, IM_COL32(00, 00, 30, 65)); draw_list->PushClipRect(MinPos, MaxPos, true); ImVec2 LeftPos[2]; ImVec2 MidPos[2]; ImVec2 RightPos[2]; ImU32 col = ImGui::GetColorU32(ImGuiCol_ScrollbarGrab); for (int b = 0; b < Property->NumberOfTotalKeyframes; b++) { keyframe *Keyframe = KeyframeLookupMemory(Property, b); // int32 Index = KeyframeMemoryToIndex(Property, b); ImGui::PushID(Keyframe); real32 MinVal = Property->LocalMinVal.f; real32 MaxVal = Property->LocalMaxVal.f; // Normalized ratio between the smallest and largest value real32 HandleYRatio = (Keyframe->Value.f - MaxVal) / (MaxVal - MinVal); real32 HandleYRatio_L = (Keyframe->Value.f + Keyframe->TangentLeft.y - MaxVal) / (MaxVal - MinVal); real32 HandleYRatio_R = (Keyframe->Value.f + Keyframe->TangentRight.y - MaxVal) / (MaxVal - MinVal); real32 LocalHandlePosX = UI->TimelineZoom*Keyframe->FrameNumber; real32 LocalHandlePosX_L = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentLeft.x; real32 LocalHandlePosX_R = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentRight.x; real32 HandlePosX = TimelineStartingPos.x + LocalHandlePosX - FontHeight*0.5; real32 HandlePosX_L = TimelineStartingPos.x + LocalHandlePosX_L - FontHeight*0.5; real32 HandlePosX_R = TimelineStartingPos.x + LocalHandlePosX_R - FontHeight*0.5; real32 LocalHandlePosY = HandleYRatio * Property->GraphLength; real32 LocalHandlePosY_L = HandleYRatio_L * Property->GraphLength; real32 LocalHandlePosY_R = HandleYRatio_R * Property->GraphLength; real32 HandlePosY = MinPos.y - LocalHandlePosY + Property->GraphYOffset; real32 HandlePosY_L = MinPos.y - LocalHandlePosY_L + Property->GraphYOffset; real32 HandlePosY_R = MinPos.y - LocalHandlePosY_R + Property->GraphYOffset; ImVec2 HandlePos = ImVec2(HandlePosX, HandlePosY); ImVec2 HandlePos_L = ImVec2(HandlePosX_L, HandlePosY_L); ImVec2 HandlePos_R = ImVec2(HandlePosX_R, HandlePosY_R); if (UI->BoxSelectActive && UI->BoxStart.y >= NextY) { if (IsRectTouching(UI->BoxStart, UI->BoxEnd, HandlePos, HandlePos + KeyframeSize)) { Keyframe->IsSelected = true; State->RecentSelectionType = selection_keyframe; } else if (!io.KeyShift) { Keyframe->IsSelected = false; } } ImGui::PushStyleColor(ImGuiCol_Button, col); ImGui::SetCursorScreenPos(ImVec2(HandlePosX - FontHeight*1.5, HandlePosY - FontHeight*1.5)); ImGui::Text("%.02f", Keyframe->Value.f); ImGui::SetCursorScreenPos(ImVec2(HandlePosX - FontHeight*1.0, HandlePosY - FontHeight*1.0)); ImGui::InvisibleButton("##keyframepoint", ImVec2(FontHeight*2, FontHeight*2), ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight); draw_list->AddRect(ImVec2(HandlePosX - FontHeight*0.5, HandlePosY - FontHeight*0.5), ImVec2(HandlePosX + FontHeight*0.5, HandlePosY + FontHeight*0.5), ImGui::GetColorU32(ImGuiCol_ButtonHovered)); ImGui_KeyframeDragging(File, State, UI, Property, b, io, 1); if (Keyframe->IsSelected && Keyframe->Type == bezier) { ImGui::SetCursorScreenPos(ImVec2(HandlePosX_L, HandlePosY_L)); draw_list->AddCircle(ImVec2(HandlePosX_L, HandlePosY_L), 2, col, 16, 1); ImGui::Button("##keyframehandleleft", ImVec2(FontHeight, FontHeight)); ImGui_KeyframeDragging(File, State, UI, Property, b, io, 2); ImGui::SetCursorScreenPos(ImVec2(HandlePosX_R, HandlePosY_R)); ImGui::Button("##keyframehandleright", ImVec2(FontHeight, FontHeight)); ImGui_KeyframeDragging(File, State, UI, Property, b, io, 3); draw_list->AddLine(MidPos[b & 1], RightPos[b & 1], col, 1.0f); draw_list->AddLine(MidPos[b & 1], LeftPos[b & 1], col, 1.0f); } ImGui::PopStyleColor(); ImGui::PopID(); } // TODO(fox): Reformat this so it's all done in one loop. for (int b = 0; b < Property->NumberOfTotalKeyframes; b++) { keyframe *Keyframe = KeyframeLookupIndex(Property, b); real32 MinVal = Property->LocalMinVal.f; real32 MaxVal = Property->LocalMaxVal.f; real32 HandleYRatio = (Keyframe->Value.f - MaxVal) / (MaxVal - MinVal); real32 HandleYRatio_L = (Keyframe->Value.f + Keyframe->TangentLeft.y - MaxVal) / (MaxVal - MinVal); real32 HandleYRatio_R = (Keyframe->Value.f + Keyframe->TangentRight.y - MaxVal) / (MaxVal - MinVal); real32 LocalHandlePosX = UI->TimelineZoom*Keyframe->FrameNumber; real32 LocalHandlePosX_L = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentLeft.x; real32 LocalHandlePosX_R = LocalHandlePosX + UI->TimelineZoom*Keyframe->TangentRight.x; real32 HandlePosX = TimelineStartingPos.x + LocalHandlePosX - FontHeight*0.5; real32 HandlePosX_L = TimelineStartingPos.x + LocalHandlePosX_L - FontHeight*0.5; real32 HandlePosX_R = TimelineStartingPos.x + LocalHandlePosX_R - FontHeight*0.5; real32 LocalHandlePosY = HandleYRatio * Property->GraphLength; real32 LocalHandlePosY_L = HandleYRatio_L * Property->GraphLength; real32 LocalHandlePosY_R = HandleYRatio_R * Property->GraphLength; real32 HandlePosY = MinPos.y - LocalHandlePosY + Property->GraphYOffset; real32 HandlePosY_L = MinPos.y - LocalHandlePosY_L + Property->GraphYOffset; real32 HandlePosY_R = MinPos.y - LocalHandlePosY_R + Property->GraphYOffset; ImVec2 HandlePos = ImVec2(HandlePosX, HandlePosY); ImVec2 HandlePos_L = ImVec2(HandlePosX_L, HandlePosY_L); ImVec2 HandlePos_R = ImVec2(HandlePosX_R, HandlePosY_R); MidPos[b & 1] = HandlePos; LeftPos[b & 1] = HandlePos_L; RightPos[b & 1] = HandlePos_R; if (b != 0) { if (b & 1) { if (Keyframe->Type == linear) draw_list->AddLine(MidPos[0], MidPos[1], col, 1.0f); else if (Keyframe->Type == bezier) draw_list->AddBezierCubic(MidPos[0], RightPos[0], LeftPos[1], MidPos[1], col, 1.0f, 8); } else { if (Keyframe->Type == linear) draw_list->AddLine(MidPos[1], MidPos[0], col, 1.0f); else if (Keyframe->Type == bezier) draw_list->AddBezierCubic(MidPos[1], RightPos[1], LeftPos[0], MidPos[0], col, 1.0f, 8); } } } // Horiziontal value lines // uint32 LineColor = IM_COL32(200, 200, 200, 40); // for (int i = 0; i < 10; i++) { // real32 YPos = MinPos.y + (UI->TimelineZoom/2 * i) + 5; // ImVec2 Min = ImVec2(TimelineStartingPos.x, YPos); // ImVec2 Max = ImVec2(TimelineStartingPos.x + TimelineSize.x, YPos); // draw_list->AddLine(Min, Max, LineColor); // } draw_list->PopClipRect(); // ImGui::SetCursorScreenPos(ImVec2(MinPos.x, MinPos.y)); // ImGui::Button("##SplitMove", ImVec2(TimelineBorderPadding.x, SidebarSizeWithBorder.y)); // if (ImGui::IsItemActive() && ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1)) // { // UI->TimelineSplit += io.MouseDelta.x; // } ImGui::SetCursorScreenPos(ImVec2(MinPos.x, MinPos.y)); ImGui::InvisibleButton("AnimationCurves", ImVec2(TimelineSize.x - 20, GraphWindowHeight), ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight); // NOTE(fox): I'm reusing this struct for the other // channels, so I'm OR'ing it. Also persists across layers. AnimationCurves.IsItemHovered |= ImGui::IsItemHovered(); AnimationCurves.IsItemActive |= ImGui::IsItemActive(); AnimationCurves.IsItemActivated |= ImGui::IsItemActivated(); AnimationCurves.IsItemDeactivated |= ImGui::IsItemDeactivated(); AnimationCurves.LeftClick |= ImGui::IsMouseDown(ImGuiMouseButton_Left); AnimationCurves.RightClick |= ImGui::IsMouseDown(ImGuiMouseButton_Right); if (AnimationCurves.IsItemHovered && AnimationCurves.IsItemActivated && ImGui::IsMouseDown(ImGuiMouseButton_Right)) { real32 LocalMousePos = io.MousePos.y - MinPos.y - Property->GraphYOffset; UI->TempZoomRatioGraph = LocalMousePos / Property->GraphLength; } // DebugWatchVar("LocalMousePos", &LocalMousePos, d_float); if (AnimationCurves.IsItemActive && ImGui::IsMouseDragging(ImGuiMouseButton_Right, -1)) { Property->GraphLength += io.MouseDelta.x; Property->GraphYOffset -= io.MouseDelta.x*UI->TempZoomRatioGraph; Property->GraphYOffset += io.MouseDelta.y; } } ImGui::PopID(); } } ImGui::SetCursorPosY(ImGui::GetCursorPos().y - (ItemSpacing.y * UI->KeyframeSpacing / 2)); ImGui::PopStyleVar(); ImGui::PopID(); } // Timeline frame ticks ImGui::SetCursorScreenPos(TimelineStartingPos); if (UI->TimelineZoom > 10) { for (float x = 0; x < File->NumberOfFrames + 2; x += 1) { uint32 LineColor = IM_COL32(200, 200, 200, 40); ImVec2 Min = ImVec2(TimelineStartingPos.x + UI->TimelineZoom * x, TimelineStartingPos.y); ImVec2 Max = ImVec2(Min.x + 2, WindowMaxAbs.y); if (x == File->CurrentFrame) continue; draw_list->AddLine(Min, Max, LineColor); } } draw_list->PopClipRect(); ImGui::PopClipRect(); // Playhead line uint32 LineColor = IM_COL32(200, 200, 200, 200); ImVec2 Min = PlayheadPos; ImVec2 Max = ImVec2(Min.x + 2, Min.y + TimelineSizeWithBorder.y + TopbarSize.y/2); draw_list->AddLine(Min, Max, LineColor); ImGui::PopStyleVar(); // General timeline interaction ImGui::SetCursorScreenPos(TimelineAbsolutePos); ImGui::InvisibleButton("TimelineMoving", TimelineSizeWithBorder, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight); bool32 IsHovered = ImGui::IsItemHovered(); bool32 IsActive = ImGui::IsItemActive(); bool32 IsItemActivated = ImGui::IsItemActivated(); bool32 IsItemDeactivated = ImGui::IsItemDeactivated(); bool32 LeftClick = ImGui::IsMouseDown(ImGuiMouseButton_Left); bool32 RightClick = ImGui::IsMouseDown(ImGuiMouseButton_Right); if (IsActive || AnimationCurves.IsItemActive) { if (LeftClick) { if (io.KeyCtrl && IsActive) { real32 LocalMousePos = ImGui::GetMousePos().x - TimelineStartingPos.x; real32 ZoomRatio = LocalMousePos / UI->TimelineZoom; File->CurrentFrame = (int32)(ZoomRatio + 0.5); State->UpdateFrame = true; State->UpdateKeyframes = true; } else { if (IsItemActivated || AnimationCurves.IsItemActivated) { if (!io.KeyShift) { // DeselectAllKeyframes(&State); // DeselectAllLayers(File, State); } UI->BoxStart = ImGui::GetMousePos(); UI->BoxSelectActive = true; } if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, -1) ) { UI->BoxEnd = ImGui::GetMousePos(); draw_list->AddRectFilled(UI->BoxStart, UI->BoxEnd, IM_COL32(0, 0, 200, 50)); } } // Timeline zooming interaction } else if (RightClick && IsActive) { if (IsItemActivated) { real32 LocalMousePos = io.MousePos.x - WindowMinAbs.x - UI->TimelineSplit; UI->TempZoomRatioTimeline = LocalMousePos / TimelineSize.x; } if (ImGui::IsMouseDragging(ImGuiMouseButton_Right, -1) ) { UI->TimelineZoom += io.MouseDelta.x; ImGui::SetScrollX(ImGui::GetScrollMaxX() * UI->TempZoomRatioTimeline); } } } if (IsItemDeactivated || AnimationCurves.IsItemDeactivated) { UI->BoxStart = {0, 0}; UI->BoxEnd = {0, 0}; UI->BoxSelectActive = false; if (!io.KeyShift) DeselectAllLayers(File, State); } ImGui::EndChild(); ImGui::PopStyleVar(2); if (IsRectTouching(WindowMinAbs, WindowMaxAbs, io.MousePos, io.MousePos + 1)) { if (io.KeyCtrl && io.MouseWheel) { real32 ZoomAmount = io.MouseWheel*16; real32 LocalMousePos = ImGui::GetMousePos().x - TimelineStartingPos.x; real32 ZoomRatio = LocalMousePos / UI->TimelineZoom; UI->TimelineZoom += ZoomAmount; UI->ScrollXOffset -= ZoomAmount*ZoomRatio; } else if (io.KeyShift && io.MouseWheel) { UI->ScrollXOffset += io.MouseWheel*16; } else { UI->ScrollXOffset += io.MouseWheelH*16; UI->ScrollYOffset += io.MouseWheel*16; } } ImGui::End(); } static void ImGui_ProcessInputs(project_data *File, project_state *State, comp_buffer *CompBuffer, memory *Memory, ui *UI, ImGuiIO io) { if (io.KeysData[ImGuiKey_Q].Down) State->IsRunning = false; if (ImGui::IsKeyPressed(ImGuiKey_D)) { IncrementFrame(File, -1); State->UpdateFrame = true; State->UpdateKeyframes = true; } if (ImGui::IsKeyPressed(ImGuiKey_F)) { IncrementFrame(File, 1); State->UpdateFrame = true; State->UpdateKeyframes = true; } if (ImGui::IsKeyPressed(ImGuiKey_Space)) { if (io.KeyShift) { State->RerouteEffects = true; } else { SwitchBool(State->IsPlaying); } } if (State->IsPlaying && !IsRendering) { IncrementFrame(File, 1); State->UpdateFrame = true; State->UpdateKeyframes = true; } if (ImGui::IsKeyPressed(ImGuiKey_R) && State->NumberOfSelectedLayers) TransformsInteract(File, State, UI, sliding_rotation); if (ImGui::IsKeyPressed(ImGuiKey_S) && State->NumberOfSelectedLayers) TransformsInteract(File, State, UI, sliding_scale); if (ImGui::IsKeyPressed(ImGuiKey_G) && State->NumberOfSelectedLayers) TransformsInteract(File, State, UI, sliding_position); if (ImGui::IsKeyPressed(ImGuiKey_A) && State->NumberOfSelectedLayers) TransformsInteract(File, State, UI, sliding_anchorpoint); if (ImGui::IsKeyPressed(ImGuiKey_1)) LoadTestFootage(File, State, Memory); if (ImGui::IsKeyPressed(ImGuiKey_Delete)) { switch (State->RecentSelectionType) { case selection_none: { } break; case selection_layer: { } break; case selection_effect: { } break; case selection_keyframe: { DeleteSelectedKeyframes(File, Memory); State->UpdateKeyframes = true; State->UpdateFrame = true; } break; } } #if DEBUG if (ImGui::IsKeyPressed(ImGuiKey_W)) { SwitchBool(Debug.ToggleWindow); } if (ImGui::IsKeyPressed(ImGuiKey_M)) { Debug.Markers[Debug.MarkerIndex] = File->CurrentFrame; Debug.MarkerIndex++; } #endif bool32 Ended = ImGui::IsMouseDown(ImGuiMouseButton_Left); if (State->IsInteracting) { ImVec2 MouseIncrement = io.MouseDelta * (ImVec2(CompBuffer->Width, CompBuffer->Height) / UI->CompZoom); switch (State->TransformsHotkeyInteract) { case sliding_position: { InteractProperty(0, File, State, Ended, MouseIncrement.x, Memory); InteractProperty(1, File, State, Ended, MouseIncrement.y, Memory); } break; case sliding_anchorpoint: { InteractProperty(2, File, State, Ended, MouseIncrement.x, Memory); InteractProperty(3, File, State, Ended, MouseIncrement.y, Memory); } break; case sliding_rotation: { InteractProperty(4, File, State, Ended, MouseIncrement.x / 10.0, Memory); } break; case sliding_scale: { InteractProperty(5, File, State, Ended, MouseIncrement.x / 200.0, Memory); } break; } } if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) { UI->DraggingLayerThreshold = 0; UI->DraggingTimelineThreshold = 0; UI->DraggingKeyframeThreshold = 0; } } static char ImGuiPrefs[] = "[Window][DockSpaceViewport_11111111]" "\nPos=0,0" "\nSize=3200,1800" "\nCollapsed=0" "\n" "\n[Window][Debug##Default]" "\nPos=60,60" "\nSize=400,400" "\nCollapsed=0" "\n" "\n[Window][Viewport]" "\nPos=528,0" "\nSize=2168,1171" "\nCollapsed=0" "\nDockId=0x00000005,0" "\n" "\n[Window][###Properties]" "\nPos=0,0" "\nSize=526,1171" "\nCollapsed=0" "\nDockId=0x00000003,0" "\n" "\n[Window][Timeline]" "\nPos=0,1173" "\nSize=3200,627" "\nCollapsed=0" "\nDockId=0x00000002,0" "\n" "\n[Window][Dear ImGui Demo]" "\nPos=1881,692" "\nSize=550,680" "\nCollapsed=0" "\n" "\n[Window][Files]" "\nPos=2698,0" "\nSize=502,913" "\nCollapsed=0" "\nDockId=0x00000007,0" "\n" "\n[Window][Effects list]" "\nPos=2698,915" "\nSize=502,256" "\nCollapsed=0" "\nDockId=0x00000008,0" "\n" "\n[Docking][Data]" "\nDockSpace ID=0x8B93E3BD Window=0xA787BDB4 Pos=0,0 Size=3200,1800 Split=Y Selected=0x13926F0B" "\n DockNode ID=0x00000001 Parent=0x8B93E3BD SizeRef=3200,1171 Split=X Selected=0x13926F0B" "\n DockNode ID=0x00000003 Parent=0x00000001 SizeRef=526,1171 Selected=0xDBB8CEFA" "\n DockNode ID=0x00000004 Parent=0x00000001 SizeRef=2672,1171 Split=X Selected=0x13926F0B" "\n DockNode ID=0x00000005 Parent=0x00000004 SizeRef=2115,1171 CentralNode=1 Selected=0x13926F0B" "\n DockNode ID=0x00000006 Parent=0x00000004 SizeRef=502,1171 Split=Y Selected=0x86FA2F90" "\n DockNode ID=0x00000007 Parent=0x00000006 SizeRef=502,913 Selected=0x86FA2F90" "\n DockNode ID=0x00000008 Parent=0x00000006 SizeRef=502,256 Selected=0x812F222D" "\n DockNode ID=0x00000002 Parent=0x8B93E3BD SizeRef=3200,627 HiddenTabBar=1 Selected=0x0F18B61B";