1377 lines
46 KiB
C++
1377 lines
46 KiB
C++
//
|
|
// Created by Matty on 2022-01-28.
|
|
//
|
|
#define IMGUI_DEFINE_MATH_OPERATORS
|
|
|
|
#include "imgui_neo_sequencer.h"
|
|
#include "imgui_internal.h"
|
|
#include "imgui_neo_internal.h"
|
|
|
|
#include <unordered_map>
|
|
|
|
namespace ImGui
|
|
{
|
|
// Internal state, used for deletion of old keyframes.
|
|
struct ImGuiNeoTimelineKeyframes
|
|
{
|
|
ImGuiID TimelineID;
|
|
ImVector<int32_t> KeyframesToDelete;
|
|
};
|
|
|
|
// Internal struct holding how many times was keyframe on certain frame rendered, used as offset for duplicates
|
|
struct ImGuiNeoKeyframeDuplicate
|
|
{
|
|
int32_t Frame;
|
|
uint32_t Count;
|
|
};
|
|
|
|
enum class SelectionState
|
|
{
|
|
Idle, // Doing nothing related
|
|
Selecting, // Selecting selection
|
|
Dragging // Dragging selection
|
|
};
|
|
|
|
struct ImGuiNeoSequencerInternalData
|
|
{
|
|
ImVec2 TopLeftCursor = {0, 0}; // Cursor on top of whole widget
|
|
ImVec2 TopBarStartCursor = {0, 0}; // Cursor on top, below Zoom slider
|
|
ImVec2 StartValuesCursor = {0, 0}; // Cursor on top of values
|
|
ImVec2 ValuesCursor = {0, 0}; // Current cursor position, used for values drawing
|
|
|
|
ImVec2 Size = {0, 0}; // Size of whole sequencer
|
|
ImVec2 TopBarSize = {0, 0}; // Size of top bar without Zoom
|
|
|
|
FrameIndexType StartFrame = 0;
|
|
FrameIndexType EndFrame = 0;
|
|
FrameIndexType OffsetFrame = 0; // Offset from start
|
|
|
|
float ValuesWidth = 32.0f; // Width of biggest label in timeline, used for offset of timeline
|
|
|
|
float FilledHeight = 0.0f; // Height of whole sequencer
|
|
|
|
float Zoom = 1.0f;
|
|
|
|
ImGuiID Id;
|
|
|
|
ImGuiID LastSelectedTimeline = 0;
|
|
ImGuiID SelectedTimeline = 0;
|
|
bool LastTimelineOpenned = false;
|
|
|
|
ImVector<ImGuiID> TimelineStack;
|
|
ImVector<ImGuiID> GroupStack;
|
|
|
|
FrameIndexType CurrentFrame = 0;
|
|
bool HoldingCurrentFrame = false; // Are we draging current frame?
|
|
ImVec4 CurrentFrameColor; // Color of current frame, we have to save it because we render on EndNeoSequencer, but process at BeginneoSequencer
|
|
|
|
bool HoldingZoomSlider = false;
|
|
|
|
//Selection
|
|
ImVector<ImGuiID> Selection; // Contains ids of keyframes
|
|
ImVec2 SelectionMouseStart = {0, 0};
|
|
SelectionState StateOfSelection = SelectionState::Idle;
|
|
ImVec2 DraggingMouseStart = {0, 0};
|
|
bool StartDragging = true;
|
|
ImVector<int32_t> DraggingSelectionStart; // Contains start values of all selection elements
|
|
bool DraggingEnabled = true;
|
|
bool SelectionEnabled = true;
|
|
bool IsSelectionRightClicked = false;
|
|
|
|
//Last keyframe data
|
|
bool IsLastKeyframeHovered = false;
|
|
bool IsLastKeyframeSelected = false;
|
|
bool IsLastKeyframeRightClicked = false;
|
|
|
|
//Deletion
|
|
bool DeleteDataDirty = false;
|
|
bool DeleteEnabled = true;
|
|
ImVector<ImGuiNeoTimelineKeyframes> SelectionData;
|
|
};
|
|
|
|
static ImGuiNeoSequencerStyle style; // NOLINT(cert-err58-cpp)
|
|
|
|
//Global context stuff
|
|
static bool inSequencer = false;
|
|
|
|
// Height of timeline right now
|
|
static float currentTimelineHeight = 0.0f;
|
|
|
|
// Current active sequencer
|
|
static ImGuiID currentSequencer;
|
|
|
|
// Current timeline depth, used for offset of label
|
|
static uint32_t currentTimelineDepth = 0;
|
|
|
|
static ImVector<ImGuiColorMod> sequencerColorStack;
|
|
|
|
// Data of all sequencers, this is main c++ part and I should create C alternative or use imgui ImVector or something
|
|
static std::unordered_map<ImGuiID, ImGuiNeoSequencerInternalData> sequencerData;
|
|
|
|
static ImVector<ImGuiNeoKeyframeDuplicate> keyframeDuplicates;
|
|
|
|
///////////// STATIC HELPERS ///////////////////////
|
|
|
|
static float getPerFrameWidth(ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
return GetPerFrameWidth(context.Size.x, context.ValuesWidth, context.EndFrame, context.StartFrame,
|
|
context.Zoom);
|
|
}
|
|
|
|
static float getKeyframePositionX(FrameIndexType frame, ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
const auto perFrameWidth = getPerFrameWidth(context);
|
|
return (float) (frame - context.OffsetFrame - context.StartFrame) * perFrameWidth;
|
|
}
|
|
|
|
static float getWorkTimelineWidth(ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
const auto perFrameWidth = getPerFrameWidth(context);
|
|
return context.Size.x - context.ValuesWidth - perFrameWidth;
|
|
}
|
|
|
|
// Dont pull frame from context, its used for dragging
|
|
static ImRect getCurrentFrameBB(FrameIndexType frame, ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
const auto& imStyle = GetStyle();
|
|
const auto width = style.CurrentFramePointerSize * GetIO().FontGlobalScale;
|
|
const auto cursor =
|
|
context.TopBarStartCursor + ImVec2{context.ValuesWidth + imStyle.FramePadding.x - width / 2.0f, 0};
|
|
const auto currentFrameCursor = cursor + ImVec2{getKeyframePositionX(frame, context), 0};
|
|
|
|
float pointerHeight = style.CurrentFramePointerSize * 2.5f;
|
|
ImRect rect{currentFrameCursor, currentFrameCursor + ImVec2{width, pointerHeight * GetIO().FontGlobalScale}};
|
|
|
|
return rect;
|
|
}
|
|
|
|
static void processCurrentFrame(FrameIndexType* frame, ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
auto pointerRect = getCurrentFrameBB(*frame, context);
|
|
pointerRect.Min -= ImVec2{2.0f, 2.0f};
|
|
pointerRect.Max += ImVec2{2.0f, 2.0f};
|
|
|
|
const auto& imStyle = GetStyle();
|
|
|
|
const auto timelineXmin = context.TopBarStartCursor.x + context.ValuesWidth + imStyle.FramePadding.x;
|
|
|
|
const ImVec2 timelineXRange = {
|
|
timelineXmin, //min
|
|
timelineXmin + context.Size.x - context.ValuesWidth
|
|
};
|
|
|
|
const auto hovered = ItemHoverable(pointerRect, GetCurrentWindow()->GetID("##_top_selector_neo"), 0);
|
|
|
|
context.CurrentFrameColor = GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_FramePointer);
|
|
|
|
if (hovered)
|
|
{
|
|
context.CurrentFrameColor = GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_FramePointerHovered);
|
|
}
|
|
|
|
if (context.HoldingCurrentFrame)
|
|
{
|
|
if (IsMouseDragging(ImGuiMouseButton_Left, 0.0f))
|
|
{
|
|
const auto mousePosX = GetMousePos().x;
|
|
const auto v = mousePosX - timelineXRange.x;// Subtract min
|
|
|
|
const auto normalized = v / getWorkTimelineWidth(context); //Divide by width to remap to 0 - 1 range
|
|
|
|
const auto clamped = ImClamp(normalized, 0.0f, 1.0f);
|
|
|
|
const auto viewSize = (float) (context.EndFrame - context.StartFrame) / context.Zoom;
|
|
|
|
const auto frameViewVal = (float) context.StartFrame + (clamped * (float) viewSize);
|
|
|
|
const auto finalFrame = (FrameIndexType) round(frameViewVal) + context.OffsetFrame;
|
|
|
|
context.CurrentFrameColor = GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_FramePointerPressed);
|
|
|
|
*frame = finalFrame;
|
|
}
|
|
|
|
if (!IsMouseDown(ImGuiMouseButton_Left))
|
|
{
|
|
context.HoldingCurrentFrame = false;
|
|
context.CurrentFrameColor = GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_FramePointer);
|
|
}
|
|
}
|
|
|
|
if (hovered && IsMouseDown(ImGuiMouseButton_Left) && !context.HoldingCurrentFrame)
|
|
{
|
|
context.HoldingCurrentFrame = true;
|
|
context.CurrentFrameColor = GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_FramePointerPressed);
|
|
}
|
|
|
|
context.CurrentFrame = *frame;
|
|
}
|
|
|
|
static void finishPreviousTimeline(ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
context.ValuesCursor = {context.TopBarStartCursor.x, context.ValuesCursor.y};
|
|
currentTimelineHeight = 0.0f;
|
|
}
|
|
|
|
static ImColor getKeyframeColor(ImGuiNeoSequencerInternalData& context, bool hovered, bool inSelection)
|
|
{
|
|
if (inSelection)
|
|
{
|
|
return ColorConvertFloat4ToU32(GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_KeyframeSelected));
|
|
}
|
|
|
|
return hovered ?
|
|
ColorConvertFloat4ToU32(
|
|
GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_KeyframeHovered)) :
|
|
ColorConvertFloat4ToU32(GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_Keyframe));
|
|
}
|
|
|
|
static void addKeyframeToDeleteData(int32_t value, ImGuiNeoSequencerInternalData& context, const ImGuiID timelineId)
|
|
{
|
|
bool foundTimeline = false;
|
|
for (auto&& val: context.SelectionData)
|
|
{
|
|
if (val.TimelineID == timelineId)
|
|
{
|
|
foundTimeline = true;
|
|
if (!val.KeyframesToDelete.contains(value))
|
|
val.KeyframesToDelete.push_back(value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundTimeline)
|
|
{
|
|
context.SelectionData.push_back({});
|
|
auto& data = context.SelectionData.back();
|
|
data.TimelineID = timelineId;
|
|
data.KeyframesToDelete.push_back(value);
|
|
}
|
|
}
|
|
|
|
static bool
|
|
getKeyframeInSelection(int32_t value, ImGuiID id, ImGuiNeoSequencerInternalData& context, const ImRect bb)
|
|
{
|
|
//TODO(matej.vrba): This is kinda slow, it works for smaller data sample, but for bigger sample it should be changed to hashset
|
|
const ImGuiID timelineId = context.TimelineStack.back();
|
|
|
|
if (context.DeleteDataDirty && context.Selection.contains(id))
|
|
{
|
|
addKeyframeToDeleteData(value, context, timelineId);
|
|
}
|
|
|
|
if (context.StateOfSelection != SelectionState::Selecting)
|
|
{
|
|
return context.Selection.contains(id);
|
|
}
|
|
|
|
ImRect sel = {context.SelectionMouseStart, GetMousePos()};
|
|
|
|
if (sel.Min.y > sel.Max.y)
|
|
{
|
|
ImVec2 tmp = sel.Min;
|
|
sel.Min = sel.Max;
|
|
sel.Max = tmp;
|
|
}
|
|
|
|
if (sel.Min.x > sel.Max.x)
|
|
{
|
|
float tmp = sel.Min.x;
|
|
sel.Min.x = sel.Max.x;
|
|
sel.Max.x = tmp;
|
|
}
|
|
|
|
const bool overlaps = bb.Overlaps(sel);
|
|
|
|
const bool forceRemove = IsKeyDown(style.ModRemoveKey);
|
|
const bool forceAdd = IsKeyDown(style.ModAddKey);
|
|
|
|
|
|
auto removeKeyframe = [&]()
|
|
{
|
|
for (auto&& val: context.SelectionData)
|
|
{
|
|
if (val.TimelineID == timelineId)
|
|
{
|
|
val.KeyframesToDelete.find_erase(value);
|
|
break;
|
|
}
|
|
}
|
|
context.Selection.find_erase(id);
|
|
};
|
|
|
|
if (overlaps)
|
|
{
|
|
if (forceRemove)
|
|
{
|
|
removeKeyframe();
|
|
return context.Selection.contains(id);
|
|
} else
|
|
{
|
|
if (!context.Selection.contains(id))
|
|
{
|
|
addKeyframeToDeleteData(value, context, timelineId);
|
|
|
|
context.Selection.push_back(id);
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
if (!forceRemove && !forceAdd)
|
|
{
|
|
removeKeyframe();
|
|
} else
|
|
{
|
|
return context.Selection.contains(id);
|
|
}
|
|
}
|
|
return overlaps;
|
|
}
|
|
|
|
static ImGuiID getKeyframeID(int32_t* frame)
|
|
{
|
|
return GetCurrentWindow()->GetID(frame);
|
|
}
|
|
|
|
static bool createKeyframe(int32_t* frame)
|
|
{
|
|
const auto& imStyle = GetStyle();
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
const auto timelineOffset = getKeyframePositionX(*frame, context);
|
|
|
|
float offset = 0.0f;
|
|
|
|
for (auto&& duplicateData: keyframeDuplicates)
|
|
{
|
|
if (duplicateData.Frame == *frame)
|
|
{
|
|
offset = (float) duplicateData.Count * style.CollidedKeyframeOffset;
|
|
duplicateData.Count++;
|
|
}
|
|
}
|
|
|
|
if (offset < style.CollidedKeyframeOffset)
|
|
{
|
|
keyframeDuplicates.push_back({});
|
|
keyframeDuplicates.back().Frame = *frame;
|
|
keyframeDuplicates.back().Count = 1;
|
|
}
|
|
|
|
const auto pos = ImVec2{context.StartValuesCursor.x + imStyle.FramePadding.x, context.ValuesCursor.y} +
|
|
ImVec2{timelineOffset + context.ValuesWidth + offset, 0};
|
|
|
|
const auto bbPos = pos - ImVec2{currentTimelineHeight / 2, 0};
|
|
|
|
const ImRect bb = {bbPos, bbPos + ImVec2{currentTimelineHeight, currentTimelineHeight}};
|
|
|
|
const auto drawList = ImGui::GetWindowDrawList();
|
|
|
|
const ImGuiID id = getKeyframeID(frame);
|
|
|
|
bool hovered = ItemHoverable(bb, id, 0);
|
|
|
|
if (context.SelectionEnabled && context.Selection.contains(id) &&
|
|
(context.StateOfSelection != SelectionState::Selecting))
|
|
{
|
|
// process dragging
|
|
if (bb.Contains(GetMousePos()) && IsMouseClicked(ImGuiMouseButton_Left) &&
|
|
context.StateOfSelection != SelectionState::Dragging &&
|
|
context.DraggingEnabled)
|
|
{
|
|
//Start dragging
|
|
context.StartDragging = true;
|
|
}
|
|
|
|
if (context.StateOfSelection == SelectionState::Dragging)
|
|
{
|
|
ImGuiID* it = context.Selection.find(id);
|
|
int32_t index = context.Selection.index_from_ptr(it);
|
|
|
|
if (context.DraggingSelectionStart.size() < index + 1 || context.DraggingSelectionStart[index] == -1)
|
|
{
|
|
if (context.DraggingSelectionStart.size() < index + 1)
|
|
{
|
|
context.DraggingSelectionStart.resize(index + 1, -1);
|
|
}
|
|
|
|
context.DraggingSelectionStart[index] = *frame;
|
|
}
|
|
float mouseDelta = GetMousePos().x - context.DraggingMouseStart.x;
|
|
|
|
auto offsetA = int32_t(
|
|
mouseDelta / (context.Size.x / (float) context.EndFrame - (float) context.StartFrame));
|
|
|
|
*frame = context.DraggingSelectionStart[index] + offsetA;
|
|
}
|
|
}
|
|
|
|
const bool inSelection = getKeyframeInSelection(*frame, id, context, bb);
|
|
|
|
context.IsLastKeyframeSelected = inSelection;
|
|
|
|
if (timelineOffset >= 0.0f)
|
|
{
|
|
|
|
ImColor color = getKeyframeColor(context, hovered, inSelection);
|
|
|
|
drawList->AddCircleFilled(pos + ImVec2{0, currentTimelineHeight / 2.f}, currentTimelineHeight / 3.0f,
|
|
color, 4);
|
|
}
|
|
|
|
context.IsLastKeyframeHovered = hovered;
|
|
context.IsLastKeyframeRightClicked = hovered && IsMouseClicked(ImGuiMouseButton_Right);
|
|
|
|
if (context.Selection.contains(id) && context.IsLastKeyframeRightClicked)
|
|
{
|
|
context.IsSelectionRightClicked = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static uint32_t idCounter = 0;
|
|
static char idBuffer[16];
|
|
|
|
const char* generateID()
|
|
{
|
|
idBuffer[0] = '#';
|
|
idBuffer[1] = '#';
|
|
memset(idBuffer + 2, 0, 14);
|
|
snprintf(idBuffer + 2, 14, "%o", idCounter++);
|
|
|
|
return &idBuffer[0];
|
|
}
|
|
|
|
void resetID()
|
|
{
|
|
idCounter = 0;
|
|
}
|
|
|
|
static void renderCurrentFrame(ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
const auto bb = getCurrentFrameBB(context.CurrentFrame, context);
|
|
|
|
const auto drawList = ImGui::GetWindowDrawList();
|
|
|
|
RenderNeoSequencerCurrentFrame(
|
|
GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_FramePointerLine),
|
|
context.CurrentFrameColor,
|
|
bb,
|
|
context.Size.y - context.TopBarSize.y,
|
|
style.CurrentFrameLineWidth,
|
|
drawList
|
|
);
|
|
}
|
|
|
|
static float calculateZoomBarHeight()
|
|
{
|
|
const auto& imStyle = GetStyle();
|
|
return GetFontSize() * style.ZoomHeightScale + imStyle.FramePadding.y * 2.0f;
|
|
}
|
|
|
|
static void
|
|
processAndRenderZoom(ImGuiNeoSequencerInternalData& context, const ImVec2& cursor, bool allowEditingLength,
|
|
FrameIndexType* start,
|
|
FrameIndexType* end)
|
|
{
|
|
const auto& imStyle = GetStyle();
|
|
ImGuiWindow* window = GetCurrentWindow();
|
|
|
|
const auto zoomHeight = calculateZoomBarHeight();
|
|
|
|
auto* drawList = GetWindowDrawList();
|
|
|
|
//Input width
|
|
const auto inputWidth = CalcTextSize("123456").x;
|
|
|
|
const auto inputWidthWithPadding = inputWidth + imStyle.ItemSpacing.x;
|
|
|
|
const auto cursorV = allowEditingLength ? cursor + ImVec2{inputWidthWithPadding, 0}
|
|
: cursor;
|
|
|
|
const auto size = allowEditingLength ?
|
|
context.Size.x - 2 * inputWidthWithPadding :
|
|
context.Size.x;
|
|
|
|
const ImRect bb{cursorV, cursorV + ImVec2{size, zoomHeight}};
|
|
|
|
|
|
const auto zoomBarEndWithSpacing = ImVec2{bb.Max.x + imStyle.ItemSpacing.x, bb.Min.y};
|
|
|
|
FrameIndexType startFrameVal = *start;
|
|
FrameIndexType endFrameVal = *end;
|
|
|
|
if (allowEditingLength)
|
|
{
|
|
const float sideOffset = imStyle.ItemSpacing.x / 2.0f;
|
|
auto prevWindowCursor = window->DC.CursorPos;
|
|
|
|
window->DC.CursorPos = cursor;
|
|
|
|
window->DC.CursorPos.x += sideOffset;
|
|
|
|
PushItemWidth(inputWidth);
|
|
InputScalar("##input_start_frame", ImGuiDataType_U32, &startFrameVal, NULL, NULL, "%i",
|
|
allowEditingLength ? 0 : ImGuiInputTextFlags_ReadOnly);
|
|
|
|
window->DC.CursorPos = ImVec2{zoomBarEndWithSpacing.x, cursor.y};
|
|
window->DC.CursorPos.x -= sideOffset;
|
|
|
|
PushItemWidth(inputWidth);
|
|
InputScalar("##input_end_frame", ImGuiDataType_U32, &endFrameVal, NULL, NULL, "%i",
|
|
allowEditingLength ? 0 : ImGuiInputTextFlags_ReadOnly);
|
|
|
|
window->DC.CursorPos = prevWindowCursor;
|
|
}
|
|
|
|
//if (startFrameVal < 0)
|
|
// startFrameVal = (int32_t) *start;
|
|
//
|
|
//if (endFrameVal < 0)
|
|
// endFrameVal = (int32_t) *end;
|
|
|
|
if (endFrameVal <= startFrameVal)
|
|
endFrameVal = (int32_t) *end;
|
|
|
|
*start = startFrameVal;
|
|
*end = endFrameVal;
|
|
|
|
//drawList->AddText(startFrameTextCursor + ImVec2{frameNumberBorderSize.x, 0} - ImVec2{numberTextWidth,0},IM_COL32_WHITE,numberText);
|
|
|
|
//Background
|
|
drawList->AddRectFilled(bb.Min, bb.Max,
|
|
ColorConvertFloat4ToU32(GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_ZoomBarBg)),
|
|
10.0f);
|
|
|
|
const auto baseWidth = bb.GetSize().x -
|
|
imStyle.ItemInnerSpacing.x; //There is just half spacing applied, doing it normally makes big gap on sides
|
|
|
|
const auto sliderHeight = bb.GetSize().y - imStyle.ItemInnerSpacing.y;
|
|
|
|
const auto sliderWidth = baseWidth / context.Zoom;
|
|
|
|
const auto sliderMin = bb.Min + imStyle.ItemInnerSpacing / 2.0f;
|
|
|
|
//const auto sliderMax = bb.Max - imStyle.ItemInnerSpacing / 2.0f;
|
|
|
|
const auto sliderMaxWidth = baseWidth;
|
|
|
|
const auto totalFrames = (*end - *start);
|
|
|
|
const auto singleFrameWidthOffset = sliderMaxWidth / (float) totalFrames;
|
|
|
|
const auto zoomSliderOffset = singleFrameWidthOffset * (float) context.OffsetFrame;
|
|
|
|
const auto sliderStart = sliderMin + ImVec2{zoomSliderOffset, 0};
|
|
|
|
const float sideSize = sliderHeight;
|
|
|
|
const ImRect finalSliderBB{sliderStart, sliderStart + ImVec2{sliderWidth, sliderHeight}};
|
|
|
|
const ImRect finalSliderInteractBB = {finalSliderBB.Min + ImVec2{sideSize, 0},
|
|
finalSliderBB.Max - ImVec2{sideSize, 0}};
|
|
|
|
|
|
const auto viewWidth = (uint32_t) ((float) totalFrames / context.Zoom);
|
|
|
|
const bool hovered = ItemHoverable(bb, GetCurrentWindow()->GetID("##zoom_slider"), 0);
|
|
|
|
if (hovered)
|
|
{
|
|
SetKeyOwner(ImGuiKey_MouseWheelY, GetItemID());
|
|
const float currentScroll = GetIO().MouseWheel;
|
|
|
|
context.Zoom = ImClamp(context.Zoom + float(currentScroll) * 0.3f, 1.0f, (float) viewWidth);
|
|
const auto newZoomWidth = (FrameIndexType) ceil((float) totalFrames / (context.Zoom));
|
|
|
|
if (*start + context.OffsetFrame + newZoomWidth > *end)
|
|
context.OffsetFrame = ImMax(0U, totalFrames - viewWidth);
|
|
}
|
|
|
|
if (context.HoldingZoomSlider)
|
|
{
|
|
if (IsMouseDragging(ImGuiMouseButton_Left, 0.01f))
|
|
{
|
|
const auto currentX = GetMousePos().x;
|
|
|
|
const auto v = currentX - bb.Min.x;// Subtract min
|
|
|
|
const auto normalized = v / bb.GetWidth(); //Divide by width to remap to 0 - 1 range
|
|
|
|
const auto sliderWidthNormalized = 1.0f / context.Zoom;
|
|
|
|
const auto singleFrameWidthOffsetNormalized = singleFrameWidthOffset / bb.GetWidth();
|
|
|
|
FrameIndexType finalFrame = (FrameIndexType) ((float) (normalized - sliderWidthNormalized / 2.0f) /
|
|
singleFrameWidthOffsetNormalized);
|
|
|
|
if (normalized - sliderWidthNormalized / 2.0f < 0.0f)
|
|
{
|
|
finalFrame = 0;
|
|
}
|
|
|
|
|
|
if (normalized + sliderWidthNormalized / 2.0f > 1.0f)
|
|
{
|
|
finalFrame = totalFrames - viewWidth;
|
|
}
|
|
|
|
|
|
context.OffsetFrame = finalFrame;
|
|
}
|
|
|
|
if (!IsMouseDown(ImGuiMouseButton_Left))
|
|
{
|
|
context.HoldingZoomSlider = false;
|
|
}
|
|
}
|
|
|
|
if (hovered && IsMouseDown(ImGuiMouseButton_Left))
|
|
{
|
|
context.HoldingZoomSlider = true;
|
|
}
|
|
|
|
|
|
const auto res = ItemAdd(finalSliderInteractBB, 0);
|
|
|
|
|
|
const auto viewStart = *start + context.OffsetFrame;
|
|
const auto viewEnd = viewStart + viewWidth;
|
|
|
|
if (res)
|
|
{
|
|
auto sliderColor = GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_ZoomBarSlider);
|
|
|
|
if (IsItemHovered())
|
|
{
|
|
sliderColor = GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_ZoomBarSliderHovered);
|
|
}
|
|
|
|
//Render bar
|
|
drawList->AddRectFilled(finalSliderBB.Min, finalSliderBB.Max, ColorConvertFloat4ToU32(sliderColor), 10.0f);
|
|
|
|
const auto sliderCenter = finalSliderBB.GetCenter();
|
|
|
|
char overlayTextBuffer[128];
|
|
|
|
snprintf(overlayTextBuffer, sizeof(overlayTextBuffer), "%i - %i", viewStart, viewEnd);
|
|
|
|
const auto overlaySize = CalcTextSize(overlayTextBuffer);
|
|
|
|
drawList->AddText(sliderCenter - overlaySize / 2.0f, IM_COL32_WHITE, overlayTextBuffer);
|
|
}
|
|
}
|
|
|
|
static void processSelection(ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
context.DeleteDataDirty = false;
|
|
|
|
if (context.StartDragging)
|
|
{
|
|
context.StateOfSelection = SelectionState::Dragging;
|
|
context.DraggingMouseStart = GetMousePos();
|
|
context.StartDragging = false;
|
|
return;
|
|
}
|
|
|
|
const auto windowWorkRect = GetCurrentWindow()->ClipRect;
|
|
|
|
const auto sequencerWorkRect = ImRect{
|
|
context.TopBarStartCursor + ImVec2{context.ValuesWidth, context.TopBarSize.y},
|
|
context.TopBarStartCursor + context.Size - ImVec2{0, context.TopBarSize.y}};
|
|
|
|
if (IsMouseDown(ImGuiMouseButton_Left) && windowWorkRect.Contains(GetMousePos()) &&
|
|
sequencerWorkRect.Contains(GetMousePos()))
|
|
{
|
|
// Not dragging yet
|
|
switch (context.StateOfSelection)
|
|
{
|
|
case SelectionState::Idle:
|
|
{
|
|
if (!IsMouseClicked(ImGuiMouseButton_Left)) return;
|
|
|
|
context.SelectionMouseStart = GetMousePos();
|
|
context.StateOfSelection = SelectionState::Selecting;
|
|
break;
|
|
}
|
|
case SelectionState::Selecting:
|
|
{
|
|
break;
|
|
}
|
|
case SelectionState::Dragging:
|
|
{
|
|
|
|
break;
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
switch (context.StateOfSelection)
|
|
{
|
|
case SelectionState::Idle:
|
|
{
|
|
break;
|
|
}
|
|
case SelectionState::Selecting:
|
|
{
|
|
context.SelectionMouseStart = {0, 0};
|
|
context.StateOfSelection = SelectionState::Idle;
|
|
break;
|
|
}
|
|
case SelectionState::Dragging:
|
|
{
|
|
context.DraggingSelectionStart.resize(0);
|
|
context.StateOfSelection = SelectionState::Idle;
|
|
context.DraggingMouseStart = {0, 0};
|
|
context.DeleteDataDirty = true;
|
|
for (auto&& t: context.SelectionData)
|
|
t.KeyframesToDelete.resize(0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void renderSelection(ImGuiNeoSequencerInternalData& context)
|
|
{
|
|
if (context.StateOfSelection != SelectionState::Selecting)
|
|
{
|
|
return;
|
|
}
|
|
const ImVec2 currentMousePosition = GetMousePos();
|
|
|
|
auto* drawList = GetWindowDrawList();
|
|
|
|
ImRect sel{context.SelectionMouseStart,
|
|
currentMousePosition};
|
|
|
|
if (sel.Min.y > sel.Max.y)
|
|
{
|
|
ImVec2 tmp = sel.Min;
|
|
sel.Min = sel.Max;
|
|
sel.Max = tmp;
|
|
}
|
|
|
|
if (sel.Min.x > sel.Max.x)
|
|
{
|
|
float tmp = sel.Min.x;
|
|
sel.Min.x = sel.Max.x;
|
|
sel.Max.x = tmp;
|
|
}
|
|
|
|
if (sel.GetArea() < 32.0f)
|
|
return;
|
|
|
|
// Inner
|
|
drawList->AddRectFilled(
|
|
context.SelectionMouseStart,
|
|
currentMousePosition,
|
|
ColorConvertFloat4ToU32(style.Colors[ImGuiNeoSequencerCol_Selection])
|
|
);
|
|
|
|
// border
|
|
drawList->AddRect(
|
|
context.SelectionMouseStart,
|
|
currentMousePosition,
|
|
ColorConvertFloat4ToU32(style.Colors[ImGuiNeoSequencerCol_SelectionBorder]),
|
|
0.0f,
|
|
0,
|
|
0.5f
|
|
);
|
|
}
|
|
|
|
static bool groupBehaviour(const ImGuiID id, bool* open, const ImVec2 labelSize)
|
|
{
|
|
auto& context = sequencerData[currentSequencer];
|
|
ImGuiWindow* window = GetCurrentWindow();
|
|
|
|
const bool closable = open != nullptr;
|
|
|
|
auto drawList = ImGui::GetWindowDrawList();
|
|
const float arrowWidth = drawList->_Data->FontSize;
|
|
const ImVec2 arrowSize = {arrowWidth, arrowWidth};
|
|
const ImRect arrowBB = {
|
|
context.ValuesCursor,
|
|
context.ValuesCursor + arrowSize
|
|
};
|
|
const ImVec2 groupBBMin = {context.ValuesCursor + ImVec2{arrowSize.x, 0.0f}};
|
|
const ImRect groupBB = {
|
|
groupBBMin,
|
|
groupBBMin + labelSize
|
|
};
|
|
const ImGuiID arrowID = window->GetID(generateID());
|
|
const auto addArrowRes = ItemAdd(arrowBB, arrowID);
|
|
if (addArrowRes)
|
|
{
|
|
if (IsItemClicked() && closable)
|
|
(*open) = !(*open);
|
|
}
|
|
|
|
const auto addGroupRes = ItemAdd(groupBB, id);
|
|
if (addGroupRes)
|
|
{
|
|
if (IsItemClicked())
|
|
{
|
|
context.LastSelectedTimeline = context.SelectedTimeline;
|
|
context.SelectedTimeline = context.SelectedTimeline == id ? 0 : id;
|
|
}
|
|
}
|
|
const float width = groupBB.Max.x - arrowBB.Min.x;
|
|
context.ValuesWidth = std::max(context.ValuesWidth, width); // Make left panel wide enough
|
|
return addGroupRes && addArrowRes;
|
|
}
|
|
|
|
static bool timelineBehaviour(const ImGuiID id, const ImVec2 labelSize)
|
|
{
|
|
auto& context = sequencerData[currentSequencer];
|
|
//ImGuiWindow *window = GetCurrentWindow();
|
|
|
|
const ImRect groupBB = {
|
|
context.ValuesCursor,
|
|
context.ValuesCursor + labelSize
|
|
};
|
|
|
|
const auto addGroupRes = ItemAdd(groupBB, id);
|
|
if (addGroupRes)
|
|
{
|
|
if (IsItemClicked())
|
|
{
|
|
context.LastSelectedTimeline = context.SelectedTimeline;
|
|
context.SelectedTimeline = context.SelectedTimeline == id ? 0 : id;
|
|
}
|
|
}
|
|
const float width = groupBB.Max.x - groupBB.Min.x;
|
|
context.ValuesWidth = std::max(context.ValuesWidth, width); // Make left panel wide enough
|
|
|
|
return addGroupRes;
|
|
}
|
|
|
|
////////////////////////////////////
|
|
|
|
const ImVec4& GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol idx)
|
|
{
|
|
return GetNeoSequencerStyle().Colors[idx];
|
|
}
|
|
|
|
ImGuiNeoSequencerStyle& GetNeoSequencerStyle()
|
|
{
|
|
return style;
|
|
}
|
|
|
|
bool
|
|
BeginNeoSequencer(const char* idin, FrameIndexType* frame, FrameIndexType* startFrame, FrameIndexType* endFrame,
|
|
const ImVec2& size,
|
|
ImGuiNeoSequencerFlags flags)
|
|
{
|
|
IM_ASSERT(!inSequencer && "Called when while in other NeoSequencer, that won't work, call End!");
|
|
IM_ASSERT(*startFrame < *endFrame && "Start frame must be smaller than end frame");
|
|
|
|
static char childNameStorage[64];
|
|
snprintf(childNameStorage, sizeof(childNameStorage), "##%s_child_wrapper", idin);
|
|
const bool openChild = BeginChild(childNameStorage);
|
|
|
|
if (!openChild)
|
|
{
|
|
EndChild();
|
|
return openChild;
|
|
}
|
|
|
|
//ImGuiContext &g = *GImGui;
|
|
ImGuiWindow* window = GetCurrentWindow();
|
|
const auto& imStyle = GetStyle();
|
|
//auto &neoStyle = GetNeoSequencerStyle();
|
|
|
|
if (inSequencer)
|
|
return false;
|
|
|
|
if (window->SkipItems)
|
|
return false;
|
|
|
|
const auto drawList = GetWindowDrawList();
|
|
|
|
const auto cursor = GetCursorScreenPos();
|
|
const auto area = ImGui::GetContentRegionAvail();
|
|
|
|
const auto cursorBasePos = GetCursorScreenPos() + window->Scroll;
|
|
|
|
PushID(idin);
|
|
const auto id = window->IDStack[window->IDStack.size() - 1];
|
|
|
|
inSequencer = true;
|
|
|
|
auto& context = sequencerData[id];
|
|
context.Id = id;
|
|
|
|
auto realSize = ImFloor(size);
|
|
if (realSize.x <= 0.0f)
|
|
realSize.x = ImMax(4.0f, area.x);
|
|
if (realSize.y <= 0.0f)
|
|
realSize.y = ImMax(4.0f, context.FilledHeight);
|
|
|
|
const bool showZoom = !(flags & ImGuiNeoSequencerFlags_HideZoom);
|
|
const bool headerAlwaysVisible = (flags & ImGuiNeoSequencerFlags_AlwaysShowHeader);
|
|
context.SelectionEnabled = (flags & ImGuiNeoSequencerFlags_EnableSelection);
|
|
context.DraggingEnabled = context.SelectionEnabled && (flags & ImGuiNeoSequencerFlags_Selection_EnableDragging);
|
|
context.DeleteEnabled = context.SelectionEnabled && (flags & ImGuiNeoSequencerFlags_Selection_EnableDeletion);
|
|
|
|
context.TopLeftCursor = headerAlwaysVisible ? cursorBasePos : cursor;
|
|
|
|
// If Zoom is shown, we offset it by height of Zoom bar + padding
|
|
context.TopBarStartCursor = showZoom ? context.TopLeftCursor +
|
|
ImVec2{0, calculateZoomBarHeight()}
|
|
: context.TopLeftCursor;
|
|
context.StartFrame = *startFrame;
|
|
context.EndFrame = *endFrame;
|
|
context.Size = realSize;
|
|
|
|
context.TopBarSize = ImVec2(context.Size.x, style.TopBarHeight);
|
|
|
|
if (context.TopBarSize.y <= 0.0f)
|
|
context.TopBarSize.y = CalcTextSize("100").y + imStyle.FramePadding.y * 2.0f;
|
|
|
|
currentSequencer = window->IDStack[window->IDStack.size() - 1];
|
|
|
|
auto backgroundSize = context.Size;
|
|
const float topCut = abs(context.TopLeftCursor.y - cursor.y);
|
|
backgroundSize.y = backgroundSize.y - (topCut);
|
|
|
|
RenderNeoSequencerBackground(GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_Bg), context.TopLeftCursor,
|
|
backgroundSize,
|
|
drawList, style.SequencerRounding);
|
|
|
|
|
|
RenderNeoSequencerTopBarBackground(GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_TopBarBg),
|
|
context.TopBarStartCursor, context.TopBarSize,
|
|
drawList, style.SequencerRounding);
|
|
|
|
|
|
RenderNeoSequencerTopBarOverlay(context.Zoom, context.ValuesWidth, context.StartFrame, context.EndFrame,
|
|
context.OffsetFrame,
|
|
context.TopBarStartCursor, context.TopBarSize, drawList,
|
|
style.TopBarShowFrameLines, style.TopBarShowFrameTexts, style.MaxSizePerTick);
|
|
|
|
if (showZoom)
|
|
processAndRenderZoom(context, context.TopLeftCursor, flags & ImGuiNeoSequencerFlags_AllowLengthChanging,
|
|
startFrame, endFrame);
|
|
|
|
if (context.Size.y < context.FilledHeight)
|
|
context.Size.y = context.FilledHeight;
|
|
|
|
context.FilledHeight = context.TopBarSize.y + style.TopBarSpacing +
|
|
(showZoom ? calculateZoomBarHeight() : 0.0f);
|
|
|
|
context.StartValuesCursor = cursor + ImVec2{0, context.TopBarSize.y + style.TopBarSpacing};
|
|
if (showZoom)
|
|
context.StartValuesCursor = context.StartValuesCursor + ImVec2{0, calculateZoomBarHeight()};
|
|
context.ValuesCursor = context.StartValuesCursor;
|
|
|
|
processCurrentFrame(frame, context);
|
|
|
|
//if (enableSelection)
|
|
//processSelection(context);
|
|
|
|
const auto clipMin = context.TopBarStartCursor + ImVec2(0, context.TopBarSize.y);
|
|
|
|
drawList->PushClipRect(clipMin,
|
|
clipMin + backgroundSize - ImVec2(0, context.TopBarSize.y) -
|
|
ImVec2{0, GetFontSize() * style.ZoomHeightScale}, true);
|
|
|
|
return true;
|
|
}
|
|
|
|
void EndNeoSequencer()
|
|
{
|
|
IM_ASSERT(inSequencer && "Called end sequencer when BeginSequencer didnt return true or wasn't called at all!");
|
|
IM_ASSERT(sequencerData.count(currentSequencer) != 0 && "Ended sequencer has no context!");
|
|
|
|
auto& context = sequencerData[currentSequencer];
|
|
IM_ASSERT(context.TimelineStack.empty() && "Missmatch in timeline Begin / End");
|
|
|
|
if (context.SelectionEnabled)
|
|
processSelection(context);
|
|
|
|
context.LastSelectedTimeline = context.SelectedTimeline;
|
|
context.IsSelectionRightClicked = false;
|
|
|
|
if (context.SelectionEnabled)
|
|
renderSelection(context);
|
|
|
|
renderCurrentFrame(context);
|
|
|
|
inSequencer = false;
|
|
|
|
const ImVec2 min = {0, 0};
|
|
context.Size.y = context.FilledHeight;
|
|
const auto max = context.Size;
|
|
|
|
ItemSize({min, max});
|
|
PopID();
|
|
resetID();
|
|
|
|
EndChild();
|
|
}
|
|
|
|
IMGUI_API bool BeginNeoGroup(const char* label, bool* open)
|
|
{
|
|
return BeginNeoTimeline(label, nullptr, 0, open, ImGuiNeoTimelineFlags_Group);
|
|
}
|
|
|
|
IMGUI_API void EndNeoGroup()
|
|
{
|
|
return EndNeoTimeLine();
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
|
|
bool
|
|
BeginNeoTimeline(const char* label, std::vector<int32_t>& keyframes, bool* open, ImGuiNeoTimelineFlags flags)
|
|
{
|
|
std::vector<int32_t*> c_keyframes{keyframes.size()};
|
|
for (uint32_t i = 0; i < keyframes.size(); i++)
|
|
c_keyframes[i] = &keyframes[i];
|
|
|
|
return BeginNeoTimeline(label, c_keyframes.data(), c_keyframes.size(), open, flags);
|
|
}
|
|
|
|
#endif
|
|
|
|
void PushNeoSequencerStyleColor(ImGuiNeoSequencerCol idx, ImU32 col)
|
|
{
|
|
ImGuiColorMod backup;
|
|
backup.Col = idx;
|
|
backup.BackupValue = style.Colors[idx];
|
|
sequencerColorStack.push_back(backup);
|
|
style.Colors[idx] = ColorConvertU32ToFloat4(col);
|
|
}
|
|
|
|
void PushNeoSequencerStyleColor(ImGuiNeoSequencerCol idx, const ImVec4& col)
|
|
{
|
|
ImGuiColorMod backup;
|
|
backup.Col = idx;
|
|
backup.BackupValue = style.Colors[idx];
|
|
sequencerColorStack.push_back(backup);
|
|
style.Colors[idx] = col;
|
|
}
|
|
|
|
void PopNeoSequencerStyleColor(int count)
|
|
{
|
|
while (count > 0)
|
|
{
|
|
ImGuiColorMod& backup = sequencerColorStack.back();
|
|
style.Colors[backup.Col] = backup.BackupValue;
|
|
sequencerColorStack.pop_back();
|
|
count--;
|
|
}
|
|
}
|
|
|
|
void SetSelectedTimeline(const char* timelineLabel)
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
ImGuiWindow* window = GetCurrentWindow();
|
|
|
|
ImGuiID timelineID = 0;
|
|
|
|
if (timelineLabel)
|
|
{
|
|
timelineID = window->GetID(timelineLabel);
|
|
}
|
|
context.LastSelectedTimeline = context.SelectedTimeline;
|
|
context.SelectedTimeline = timelineID;
|
|
}
|
|
|
|
bool IsNeoTimelineSelected(ImGuiNeoTimelineIsSelectedFlags flags)
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
IM_ASSERT(!context.TimelineStack.empty() && "No active timelines are present!");
|
|
|
|
const bool newly = flags & ImGuiNeoTimelineIsSelectedFlags_NewlySelected;
|
|
|
|
const auto openTimeline = context.TimelineStack[context.TimelineStack.size() - 1];
|
|
|
|
if (!newly)
|
|
{
|
|
return context.SelectedTimeline == openTimeline;
|
|
}
|
|
|
|
return (context.SelectedTimeline != context.LastSelectedTimeline) &&
|
|
context.SelectedTimeline == openTimeline;
|
|
}
|
|
|
|
bool BeginNeoTimelineEx(const char* label, bool* open, ImGuiNeoTimelineFlags flags)
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
|
|
const bool closable = open != nullptr;
|
|
|
|
auto& context = sequencerData[currentSequencer];
|
|
const auto& imStyle = GetStyle();
|
|
ImGuiWindow* window = GetCurrentWindow();
|
|
const ImGuiID id = window->GetID(label);
|
|
auto labelSize = CalcTextSize(label);
|
|
|
|
labelSize.y += imStyle.FramePadding.y * 2 + style.ItemSpacing.y * 2;
|
|
labelSize.x += imStyle.FramePadding.x * 2 + style.ItemSpacing.x * 2 +
|
|
(float) currentTimelineDepth * style.DepthItemSpacing;
|
|
|
|
|
|
bool isGroup = flags & ImGuiNeoTimelineFlags_Group && closable;
|
|
bool addRes = false;
|
|
if (isGroup)
|
|
{
|
|
labelSize.x += imStyle.ItemSpacing.x + GetFontSize();
|
|
addRes = groupBehaviour(id, open, labelSize);
|
|
} else
|
|
{
|
|
addRes = timelineBehaviour(id, labelSize);
|
|
}
|
|
|
|
if (currentTimelineDepth > 0)
|
|
{
|
|
context.ValuesCursor = {context.TopBarStartCursor.x, context.ValuesCursor.y};
|
|
}
|
|
|
|
currentTimelineHeight = labelSize.y;
|
|
context.FilledHeight += currentTimelineHeight;
|
|
const auto result = !closable || (*open);
|
|
context.LastTimelineOpenned = result;
|
|
|
|
if (addRes)
|
|
{
|
|
RenderNeoTimelane(id == context.SelectedTimeline,
|
|
context.ValuesCursor + ImVec2{context.ValuesWidth, 0},
|
|
ImVec2{context.Size.x - context.ValuesWidth, currentTimelineHeight},
|
|
GetStyleNeoSequencerColorVec4(ImGuiNeoSequencerCol_SelectedTimeline));
|
|
|
|
ImVec4 color = GetStyleColorVec4(ImGuiCol_Text);
|
|
if (IsItemHovered()) color.w *= 0.7f;
|
|
|
|
RenderNeoTimelineLabel(label,
|
|
context.ValuesCursor + imStyle.FramePadding +
|
|
ImVec2{(float) currentTimelineDepth * style.DepthItemSpacing, 0},
|
|
labelSize,
|
|
color,
|
|
isGroup,
|
|
isGroup && (*open));
|
|
|
|
}
|
|
|
|
if (result)
|
|
context.TimelineStack.push_back(id);
|
|
|
|
if (isGroup)
|
|
{ // Group requires special behaviour if its closed
|
|
context.ValuesCursor.y += currentTimelineHeight;
|
|
if (result)
|
|
{
|
|
currentTimelineDepth++;
|
|
context.GroupStack.push_back(id);
|
|
}
|
|
}
|
|
|
|
keyframeDuplicates.resize(0);
|
|
|
|
return result;
|
|
}
|
|
|
|
bool BeginNeoTimeline(const char* label, FrameIndexType** keyframes, uint32_t keyframeCount, bool* open,
|
|
ImGuiNeoTimelineFlags flags)
|
|
{
|
|
if (!BeginNeoTimelineEx(label, open, flags))
|
|
return false;
|
|
|
|
for (uint32_t i = 0; i < keyframeCount; i++)
|
|
{
|
|
NeoKeyframe(keyframes[i]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void EndNeoTimeLine()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
|
|
auto& context = sequencerData[currentSequencer];
|
|
const auto& imStyle = GetStyle();
|
|
|
|
IM_ASSERT(context.TimelineStack.size() > 0 && "Timeline stack push/pop missmatch!");
|
|
|
|
context.ValuesCursor.x += imStyle.FramePadding.x + (float) currentTimelineDepth * style.DepthItemSpacing;
|
|
context.ValuesCursor.y += currentTimelineHeight;
|
|
|
|
finishPreviousTimeline(context);
|
|
|
|
if (!context.TimelineStack.empty() && !context.GroupStack.empty() &&
|
|
context.TimelineStack.back() == context.GroupStack.back())
|
|
{
|
|
currentTimelineDepth--;
|
|
context.GroupStack.pop_back();
|
|
}
|
|
|
|
context.TimelineStack.pop_back();
|
|
}
|
|
|
|
void NeoKeyframe(int32_t* value)
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
IM_ASSERT(!context.TimelineStack.empty() && "Not in timeline!");
|
|
|
|
createKeyframe(value);
|
|
}
|
|
|
|
bool IsNeoKeyframeHovered()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return context.IsLastKeyframeHovered;
|
|
}
|
|
|
|
bool IsNeoKeyframeSelected()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return context.IsLastKeyframeSelected;
|
|
}
|
|
|
|
bool IsNeoKeyframeRightClicked()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return context.IsLastKeyframeRightClicked;
|
|
}
|
|
|
|
void NeoClearSelection()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
context.Selection.resize(0);
|
|
context.SelectionData.resize(0);
|
|
}
|
|
|
|
bool NeoIsSelecting()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return context.StateOfSelection == SelectionState::Selecting;
|
|
}
|
|
|
|
bool NeoHasSelection()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return !context.Selection.empty();
|
|
}
|
|
|
|
bool NeoIsDraggingSelection()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return context.StateOfSelection == SelectionState::Dragging;
|
|
}
|
|
|
|
uint32_t GetNeoKeyframeSelectionSize()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
if (!context.DeleteEnabled)
|
|
return 0;
|
|
|
|
IM_ASSERT(!context.TimelineStack.empty() && "Not in timeline!");
|
|
const ImGuiID timelineId = context.TimelineStack.back();
|
|
|
|
for (auto&& deleteSelection: context.SelectionData)
|
|
{
|
|
if (deleteSelection.TimelineID == timelineId)
|
|
return deleteSelection.KeyframesToDelete.size();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void GetNeoKeyframeSelection(FrameIndexType * selection)
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
if (!context.DeleteEnabled)
|
|
return;
|
|
|
|
IM_ASSERT(!context.TimelineStack.empty() && "Not in timeline!");
|
|
const ImGuiID timelineId = context.TimelineStack.back();
|
|
|
|
for (auto&& deleteSelection: context.SelectionData)
|
|
{
|
|
if (deleteSelection.TimelineID == timelineId)
|
|
{
|
|
for (int32_t i = 0; i < deleteSelection.KeyframesToDelete.size(); i++)
|
|
{
|
|
selection[i] = deleteSelection.KeyframesToDelete[i];
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool IsNeoKeyframeSelectionRightClicked()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return context.IsSelectionRightClicked;
|
|
}
|
|
|
|
bool NeoCanDeleteSelection()
|
|
{
|
|
IM_ASSERT(inSequencer && "Not in active sequencer!");
|
|
auto& context = sequencerData[currentSequencer];
|
|
|
|
return context.DeleteEnabled && NeoHasSelection() && !NeoIsSelecting() && !NeoIsDraggingSelection();
|
|
}
|
|
}
|
|
|
|
ImGuiNeoSequencerStyle::ImGuiNeoSequencerStyle()
|
|
{
|
|
Colors[ImGuiNeoSequencerCol_Bg] = ImVec4{0.31f, 0.31f, 0.31f, 1.00f};
|
|
Colors[ImGuiNeoSequencerCol_TopBarBg] = ImVec4{0.22f, 0.22f, 0.22f, 0.84f};
|
|
Colors[ImGuiNeoSequencerCol_SelectedTimeline] = ImVec4{0.98f, 0.706f, 0.322f, 0.88f};
|
|
Colors[ImGuiNeoSequencerCol_TimelinesBg] = Colors[ImGuiNeoSequencerCol_TopBarBg];
|
|
Colors[ImGuiNeoSequencerCol_TimelineBorder] = Colors[ImGuiNeoSequencerCol_Bg] * ImVec4{0.5f, 0.5f, 0.5f, 1.0f};
|
|
|
|
Colors[ImGuiNeoSequencerCol_FramePointer] = ImVec4{0.98f, 0.24f, 0.24f, 0.50f};
|
|
Colors[ImGuiNeoSequencerCol_FramePointerHovered] = ImVec4{0.98f, 0.15f, 0.15f, 1.00f};
|
|
Colors[ImGuiNeoSequencerCol_FramePointerPressed] = ImVec4{0.98f, 0.08f, 0.08f, 1.00f};
|
|
|
|
Colors[ImGuiNeoSequencerCol_Keyframe] = ImVec4{0.59f, 0.59f, 0.59f, 0.50f};
|
|
Colors[ImGuiNeoSequencerCol_KeyframeHovered] = ImVec4{0.98f, 0.39f, 0.36f, 1.00f};
|
|
Colors[ImGuiNeoSequencerCol_KeyframePressed] = ImVec4{0.98f, 0.39f, 0.36f, 1.00f};
|
|
Colors[ImGuiNeoSequencerCol_KeyframeSelected] = ImVec4{0.32f, 0.23f, 0.98f, 1.00f};
|
|
|
|
Colors[ImGuiNeoSequencerCol_FramePointerLine] = ImVec4{0.98f, 0.98f, 0.98f, 0.8f};
|
|
|
|
Colors[ImGuiNeoSequencerCol_ZoomBarBg] = ImVec4{0.59f, 0.59f, 0.59f, 0.90f};
|
|
Colors[ImGuiNeoSequencerCol_ZoomBarSlider] = ImVec4{0.8f, 0.8f, 0.8f, 0.60f};
|
|
Colors[ImGuiNeoSequencerCol_ZoomBarSliderHovered] = ImVec4{0.98f, 0.98f, 0.98f, 0.80f};
|
|
Colors[ImGuiNeoSequencerCol_ZoomBarSliderEnds] = ImVec4{0.59f, 0.59f, 0.59f, 0.90f};
|
|
Colors[ImGuiNeoSequencerCol_ZoomBarSliderEndsHovered] = ImVec4{0.93f, 0.93f, 0.93f, 0.93f};
|
|
|
|
Colors[ImGuiNeoSequencerCol_SelectionBorder] = ImVec4{0.98f, 0.706f, 0.322f, 0.61f};
|
|
Colors[ImGuiNeoSequencerCol_Selection] = ImVec4{0.98f, 0.706f, 0.322f, 0.33f};
|
|
|
|
}
|