586 lines
24 KiB
C++
586 lines
24 KiB
C++
|
// Fill out your copyright notice in the Description page of Project Settings.
|
||
|
|
|
||
|
|
#include "NpcScheduleTimeline.h"
|
||
|
|
|
||
|
|
#include "Editor.h"
|
||
|
|
#include "EngineUtils.h"
|
||
|
|
#include "Rendering/DrawElements.h"
|
||
|
|
#include "Styling/CoreStyle.h"
|
||
|
|
#include "Templates/TypeHash.h"
|
||
|
|
#include "Widgets/SNullWidget.h"
|
||
|
|
|
||
|
|
#include "ProjectEleri/Ai/NpcScheduleAsset.h"
|
||
|
|
#include "ProjectEleri/Public/Interface/ActorPersistentIdInterface.h"
|
||
|
|
|
||
|
|
#define LOCTEXT_NAMESPACE "NpcScheduleTimeline"
|
||
|
|
|
||
|
|
/*-----------------------------------------------------------------------------
|
||
|
|
How the strip is laid out
|
||
|
|
-----------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
namespace
|
||
|
|
{
|
||
|
|
/** One day, in the minutes of the day that every start in a schedule is measured in. */
|
||
|
|
constexpr int32 MinutesPerDay = 24 * 60;
|
||
|
|
|
||
|
|
/** Where the strip starts and ends inside the widget, so that a slot sitting at midnight is not
|
||
|
|
* drawn against the panel's own edge and its label has somewhere to start. */
|
||
|
|
constexpr float StripLeftPadding = 8.0f;
|
||
|
|
constexpr float StripRightPadding = 8.0f;
|
||
|
|
|
||
|
|
/** The ruler row, which holds the hour labels and nothing else. */
|
||
|
|
constexpr float HourLabelHeight = 12.0f;
|
||
|
|
|
||
|
|
/** One row of slots. High enough to read a label in, and no higher, since a day is mostly one row. */
|
||
|
|
constexpr float LaneHeight = 26.0f;
|
||
|
|
constexpr float LaneGap = 3.0f;
|
||
|
|
|
||
|
|
/** The legend below the day: one line per action, each with the swatch that matches its slot. */
|
||
|
|
constexpr float LegendTopGap = 8.0f;
|
||
|
|
constexpr float LegendRowHeight = 14.0f;
|
||
|
|
constexpr float LegendSwatchWidth = 8.0f;
|
||
|
|
constexpr float LegendSwatchGap = 6.0f;
|
||
|
|
|
||
|
|
/** Below that, and under the day when there is no legend to draw. */
|
||
|
|
constexpr float BottomPadding = 2.0f;
|
||
|
|
|
||
|
|
/** What the strip asks for in a panel that has not decided how wide it should be yet. The width it
|
||
|
|
* actually gets is whatever the panel gives it, so this is only ever a starting point. */
|
||
|
|
constexpr float PreferredWidth = 520.0f;
|
||
|
|
|
||
|
|
/** A slot narrower than this is drawn as a bare block: no label fits in it, and a label spilling out
|
||
|
|
* of its own slot would read as belonging to the slot beside it. */
|
||
|
|
constexpr float MinimumLabelledSlotWidth = 68.0f;
|
||
|
|
|
||
|
|
/** A slot's own label: how far it sits from the slot's edges, and how tall the line it is drawn on is,
|
||
|
|
* which is what centres it in a lane. */
|
||
|
|
constexpr float SlotLabelInset = 6.0f;
|
||
|
|
constexpr float SlotLabelHeight = 12.0f;
|
||
|
|
|
||
|
|
/** Every this many hours the ruler carries a label. Written out rather than derived so that the
|
||
|
|
* labels line up with the times an author thinks in. */
|
||
|
|
constexpr int32 LabelledHourInterval = 3;
|
||
|
|
|
||
|
|
/** How long an anchor's name is trusted for before it is read out of the level again. The names are
|
||
|
|
* the one thing being drawn that can go stale without the schedule changing - an anchor renamed or
|
||
|
|
* deleted while this tab sat open - and re-reading them is a walk of the level, so it is done on a
|
||
|
|
* timer rather than every frame. */
|
||
|
|
constexpr double AnchorLabelRefreshPeriod = 2.0;
|
||
|
|
|
||
|
|
/** Colour of the trough the lanes sit in, of the hour marks, and of the text that is not a label of
|
||
|
|
* anything: the same three the rest of the editor's dark panels read against. */
|
||
|
|
const FLinearColor TroughColor(0.0f, 0.0f, 0.0f, 0.55f);
|
||
|
|
const FLinearColor LaneColor(1.0f, 1.0f, 1.0f, 0.03f);
|
||
|
|
const FLinearColor HourMarkColor(1.0f, 1.0f, 1.0f, 0.07f);
|
||
|
|
const FLinearColor LabelledHourMarkColor(1.0f, 1.0f, 1.0f, 0.16f);
|
||
|
|
const FLinearColor HourLabelColor(0.62f, 0.62f, 0.62f);
|
||
|
|
const FLinearColor LegendTextColor(0.80f, 0.80f, 0.80f);
|
||
|
|
const FLinearColor QuietTextColor(0.55f, 0.55f, 0.55f);
|
||
|
|
|
||
|
|
/** A slot's label is drawn dark on the slot's own colour, which is the only way one label style stays
|
||
|
|
* legible on six different backgrounds without a second colour per activity to go with them. */
|
||
|
|
const FLinearColor SlotLabelColor(0.06f, 0.06f, 0.06f, 0.90f);
|
||
|
|
|
||
|
|
/** The marker where a slot that runs past midnight carries on at the other end of the strip. Drawn on
|
||
|
|
* both halves, so that either end says which window it belongs to. */
|
||
|
|
const FLinearColor WrapMarkerColor(1.0f, 1.0f, 1.0f, 0.85f);
|
||
|
|
constexpr float WrapMarkerWidth = 3.0f;
|
||
|
|
|
||
|
|
/*-----------------------------------------------------------------------------
|
||
|
|
Reading the schedule and the level
|
||
|
|
-----------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/** The id a schedule would name this actor by. Implementing the interface is the whole of the "can
|
||
|
|
* this actor be an anchor" rule, because the interface is what carries the id a schedule stores.
|
||
|
|
*
|
||
|
|
* Written out rather than shared with the two other copies of it, exactly as ScheduleAssetRecheck
|
||
|
|
* says of its own: it is one line of casting, and the smaller fault next to a details panel that
|
||
|
|
* answers about one action at a time having to grow a second responsibility for a view of a day. */
|
||
|
|
FGuid GetAnchorId(AActor* Actor)
|
||
|
|
{
|
||
|
|
if (Actor == nullptr)
|
||
|
|
{
|
||
|
|
return FGuid();
|
||
|
|
}
|
||
|
|
|
||
|
|
const IActorPersistentIdInterface* Identified = Cast<IActorPersistentIdInterface>(Actor);
|
||
|
|
return Identified != nullptr ? Identified->GetPersistentId() : FGuid();
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Every anchor the open level can answer for, by the id a schedule names it with.
|
||
|
|
*
|
||
|
|
* One walk for the whole strip rather than a walk per action, which is the rule the recheck sweep
|
||
|
|
* follows and for the same reason: the answer cannot change under the walk. The first actor to claim
|
||
|
|
* an id keeps it, which is also what a running game arrives at, both sides walking the level and
|
||
|
|
* taking what they meet first. */
|
||
|
|
void CollectAnchorNames(TMap<FGuid, FString>& OutAnchorNames)
|
||
|
|
{
|
||
|
|
UWorld* World = GEditor != nullptr ? GEditor->GetEditorWorldContext().World() : nullptr;
|
||
|
|
if (World == nullptr)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (TActorIterator<AActor> It(World); It; ++It)
|
||
|
|
{
|
||
|
|
AActor* Actor = *It;
|
||
|
|
const FGuid AnchorId = GetAnchorId(Actor);
|
||
|
|
if (!AnchorId.IsValid() || OutAnchorNames.Contains(AnchorId))
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
OutAnchorNames.Add(AnchorId, Actor->GetActorNameOrLabel());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** What an activity is called, which is the name the enum itself carries rather than a table here: a
|
||
|
|
* behaviour added as an enum value is then named in the strip without anyone remembering this file
|
||
|
|
* exists. */
|
||
|
|
FText GetActivityLabel(ENpcActivity Activity)
|
||
|
|
{
|
||
|
|
const UEnum* Enum = StaticEnum<ENpcActivity>();
|
||
|
|
return Enum != nullptr ? Enum->GetDisplayNameTextByValue(static_cast<int64>(Activity)) : FText::GetEmpty();
|
||
|
|
}
|
||
|
|
|
||
|
|
/** The colour that activity is drawn in. Handed out per activity rather than hashed, because these
|
||
|
|
* are the ones that exist and they are worth telling apart at a glance: sleep dark, work warm, and
|
||
|
|
* the two quiet ones grey. */
|
||
|
|
FLinearColor GetActivityColor(ENpcActivity Activity)
|
||
|
|
{
|
||
|
|
switch (Activity)
|
||
|
|
{
|
||
|
|
case ENpcActivity::Idle: return FLinearColor(0.42f, 0.44f, 0.48f);
|
||
|
|
case ENpcActivity::Sleep: return FLinearColor(0.29f, 0.36f, 0.72f);
|
||
|
|
case ENpcActivity::Sit: return FLinearColor(0.22f, 0.55f, 0.60f);
|
||
|
|
case ENpcActivity::Stand: return FLinearColor(0.34f, 0.62f, 0.35f);
|
||
|
|
case ENpcActivity::Work: return FLinearColor(0.78f, 0.55f, 0.20f);
|
||
|
|
case ENpcActivity::Roam: return FLinearColor(0.66f, 0.35f, 0.55f);
|
||
|
|
default: break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// A behaviour added later gets a colour of its own instead of the grey of an unknown: the value is
|
||
|
|
// spread over the colour wheel by the golden angle, which lands the next few far from each other
|
||
|
|
// and from the six above without anyone having to come back here to choose it.
|
||
|
|
return FLinearColor::MakeFromHSV8(static_cast<uint8>(static_cast<uint8>(Activity) * 137), 140, 190);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** "22:00" for a minute of the day. Culture invariant, because a clock is digits and not prose. */
|
||
|
|
FText MakeClockText(int32 MinutesOfDay)
|
||
|
|
{
|
||
|
|
const int32 Wrapped = ((MinutesOfDay % MinutesPerDay) + MinutesPerDay) % MinutesPerDay;
|
||
|
|
return FText::AsCultureInvariant(FString::Printf(TEXT("%02d:%02d"), Wrapped / 60, Wrapped % 60));
|
||
|
|
}
|
||
|
|
|
||
|
|
/** "22:00 - 06:00" for a window, which is the whole of what a slot has to say about when it is. */
|
||
|
|
FText MakeWindowText(int32 StartMinutes, int32 EndMinutes)
|
||
|
|
{
|
||
|
|
return FText::AsCultureInvariant(FString::Printf(
|
||
|
|
TEXT("%s - %s"), *MakeClockText(StartMinutes).ToString(), *MakeClockText(EndMinutes).ToString()));
|
||
|
|
}
|
||
|
|
|
||
|
|
/** What an action's anchor is called on the legend line: the name of the actor the id resolves to in
|
||
|
|
* this level, or what it means when it resolves to nothing. An id no actor claims is a real state -
|
||
|
|
* furniture that was deleted, or furniture in a cell that is not loaded - and not one to hide, so it
|
||
|
|
* is named with the id it is, which is also the only way to tell two unresolved anchors apart. */
|
||
|
|
FText MakeAnchorText(const FGuid& AnchorId, const TMap<FGuid, FString>& AnchorNames)
|
||
|
|
{
|
||
|
|
if (!AnchorId.IsValid())
|
||
|
|
{
|
||
|
|
return LOCTEXT("NoAnchor", "no anchor");
|
||
|
|
}
|
||
|
|
|
||
|
|
if (const FString* Name = AnchorNames.Find(AnchorId))
|
||
|
|
{
|
||
|
|
return FText::FromString(*Name);
|
||
|
|
}
|
||
|
|
|
||
|
|
return FText::Format(
|
||
|
|
LOCTEXT("AnchorNotInLevel", "an anchor no actor in this level claims ({0})"),
|
||
|
|
FText::AsCultureInvariant(AnchorId.ToString(EGuidFormats::Digits)));
|
||
|
|
}
|
||
|
|
|
||
|
|
/** "Sleep 22:00 - 06:00 Bed_01" for the legend, which is where an action is named in full. */
|
||
|
|
FText MakeLegendLine(const FText& ActivityText, const FText& WindowText, const FText& AnchorText)
|
||
|
|
{
|
||
|
|
return FText::Format(LOCTEXT("LegendLine", "{0} {1} {2}"), ActivityText, WindowText, AnchorText);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*-----------------------------------------------------------------------------
|
||
|
|
The widget
|
||
|
|
-----------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
void SNpcScheduleTimeline::Construct(const FArguments& InArgs)
|
||
|
|
{
|
||
|
|
Schedule = InArgs._Schedule;
|
||
|
|
Font = FCoreStyle::GetDefaultFontStyle(TEXT("Regular"), 8);
|
||
|
|
|
||
|
|
// The strip paints itself and holds no widget of its own, and it says so with an empty child slot
|
||
|
|
// rather than by leaving the slot unset: the slot is what a compound widget arranges, and this is
|
||
|
|
// the one child it has to be given to arrange.
|
||
|
|
ChildSlot
|
||
|
|
[
|
||
|
|
SNullWidget::NullWidget
|
||
|
|
];
|
||
|
|
|
||
|
|
// The ruler is the same eight labels whatever is being drawn, so it is made once here rather than
|
||
|
|
// rebuilt along with the schedules that share it.
|
||
|
|
for (int32 Hour = 0; Hour < 24; Hour += LabelledHourInterval)
|
||
|
|
{
|
||
|
|
HourLabels.Add(FText::AsCultureInvariant(FString::Printf(TEXT("%02d:00"), Hour)));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Built here rather than left to the first tick, so that the first paint has a day to draw rather
|
||
|
|
// than an empty one. The time it is built at is 0 because there is no clock here yet, which is
|
||
|
|
// earlier than any anchor's name is trusted for: the first tick reads the level once more and
|
||
|
|
// leaves Construct with nothing to decide about when a name goes stale.
|
||
|
|
Rebuild(ComputeSignature(), 0.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
void SNpcScheduleTimeline::Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
|
||
|
|
{
|
||
|
|
const uint32 Signature = ComputeSignature();
|
||
|
|
const bool bScheduleChanged = Signature != CachedSignature;
|
||
|
|
const bool bAnchorNamesStale = InCurrentTime - LastBuildTime >= AnchorLabelRefreshPeriod;
|
||
|
|
|
||
|
|
if (!bScheduleChanged && !bAnchorNamesStale)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
Rebuild(Signature, InCurrentTime);
|
||
|
|
|
||
|
|
// What has been painted was built from the schedule as it was, so the strip has to be painted
|
||
|
|
// again. An anchor renamed out from under an open tab is the only reason this happens without the
|
||
|
|
// asset changing, which is a repaint of one row every couple of seconds at worst: cheaper than
|
||
|
|
// keeping a subscription to every way an actor can be renamed, deleted or replaced by another.
|
||
|
|
Invalidate(EInvalidateWidgetReason::Paint);
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32 SNpcScheduleTimeline::ComputeSignature() const
|
||
|
|
{
|
||
|
|
const UNpcScheduleAsset* Asset = Schedule.Get();
|
||
|
|
if (Asset == nullptr)
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Every value the strip draws is in here, so that anything which would change the day, the
|
||
|
|
// windows or the names on them comes out as a different signature. The anchor's recorded transform
|
||
|
|
// is deliberately not: the strip never draws where an anchor stands, so a recheck that refreshed
|
||
|
|
// one has nothing here to say.
|
||
|
|
uint32 Signature = PointerHash(Asset);
|
||
|
|
for (const FScheduledAction& Action : Asset->ScheduledActions)
|
||
|
|
{
|
||
|
|
Signature = HashCombine(Signature,
|
||
|
|
GetTypeHash(Action.StartTime.GetMinutesOfDay()),
|
||
|
|
GetTypeHash(static_cast<int32>(Action.Activity)),
|
||
|
|
GetTypeHash(Action.UsableObjectGuid));
|
||
|
|
}
|
||
|
|
|
||
|
|
return Signature;
|
||
|
|
}
|
||
|
|
|
||
|
|
void SNpcScheduleTimeline::Rebuild(uint32 InSignature, double InCurrentTime)
|
||
|
|
{
|
||
|
|
CachedSignature = InSignature;
|
||
|
|
LastBuildTime = InCurrentTime;
|
||
|
|
|
||
|
|
Slots.Reset();
|
||
|
|
LaneCount = 0;
|
||
|
|
|
||
|
|
const UNpcScheduleAsset* Asset = Schedule.Get();
|
||
|
|
if (Asset == nullptr || Asset->ScheduledActions.Num() == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// The day is read out of the starts and out of nothing else, because a start is all an action
|
||
|
|
// holds: sorted, so that the next entry is the next start in the day, and kept in the schedule's
|
||
|
|
// own order where two starts are equal, so that the lanes a tied pair lands on do not swap places
|
||
|
|
// between one rebuild and the next.
|
||
|
|
struct FStart
|
||
|
|
{
|
||
|
|
int32 Minutes = 0;
|
||
|
|
int32 ActionIndex = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
TArray<FStart> Starts;
|
||
|
|
Starts.Reserve(Asset->ScheduledActions.Num());
|
||
|
|
for (int32 ActionIndex = 0; ActionIndex < Asset->ScheduledActions.Num(); ++ActionIndex)
|
||
|
|
{
|
||
|
|
Starts.Add(FStart{ Asset->ScheduledActions[ActionIndex].StartTime.GetMinutesOfDay(), ActionIndex });
|
||
|
|
}
|
||
|
|
|
||
|
|
Starts.Sort([](const FStart& A, const FStart& B)
|
||
|
|
{
|
||
|
|
return A.Minutes != B.Minutes ? A.Minutes < B.Minutes : A.ActionIndex < B.ActionIndex;
|
||
|
|
});
|
||
|
|
|
||
|
|
// The anchors are named with one walk of the open level rather than one per action, and the walk is
|
||
|
|
// skipped entirely - which is most of the time - when no action in this schedule names one.
|
||
|
|
TMap<FGuid, FString> AnchorNames;
|
||
|
|
const bool bAnchorNamed = Asset->ScheduledActions.ContainsByPredicate([](const FScheduledAction& Action)
|
||
|
|
{
|
||
|
|
return Action.UsableObjectGuid.IsValid();
|
||
|
|
});
|
||
|
|
if (bAnchorNamed)
|
||
|
|
{
|
||
|
|
CollectAnchorNames(AnchorNames);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int32 SortedIndex = 0; SortedIndex < Starts.Num(); ++SortedIndex)
|
||
|
|
{
|
||
|
|
const FStart Start = Starts[SortedIndex];
|
||
|
|
const FScheduledAction& Action = Asset->ScheduledActions[Start.ActionIndex];
|
||
|
|
|
||
|
|
// The next start that is a different one, looked for rather than read off the next entry,
|
||
|
|
// because two actions authored at the same minute claim one window between them and are told
|
||
|
|
// apart by their lane instead of by a window of their own.
|
||
|
|
int32 NextMinutes = INDEX_NONE;
|
||
|
|
for (int32 LaterIndex = SortedIndex + 1; LaterIndex < Starts.Num(); ++LaterIndex)
|
||
|
|
{
|
||
|
|
if (Starts[LaterIndex].Minutes != Start.Minutes)
|
||
|
|
{
|
||
|
|
NextMinutes = Starts[LaterIndex].Minutes;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// No later start at all means the day wraps round and the earliest start closes this window,
|
||
|
|
// which is the 06:00 that closes a 22:00-06:00 night. When that earliest start is this one's
|
||
|
|
// own minute then every action in the schedule was authored at one minute, and there is no
|
||
|
|
// window to be had between them: the whole day is theirs, which is how a schedule whose start
|
||
|
|
// and end are the same is read, see FScheduledAction.
|
||
|
|
bool bWholeDay = false;
|
||
|
|
if (NextMinutes == INDEX_NONE)
|
||
|
|
{
|
||
|
|
NextMinutes = Starts[0].Minutes;
|
||
|
|
bWholeDay = NextMinutes == Start.Minutes;
|
||
|
|
if (!bWholeDay)
|
||
|
|
{
|
||
|
|
NextMinutes += MinutesPerDay;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// The lane is however many actions before this one in the day claim the same window. Windows
|
||
|
|
// worked out this way never overlap unless they are the same window, so one lane per earlier
|
||
|
|
// claim is the whole of the separation there is to make.
|
||
|
|
int32 LaneIndex = 0;
|
||
|
|
for (int32 EarlierIndex = 0; EarlierIndex < SortedIndex; ++EarlierIndex)
|
||
|
|
{
|
||
|
|
if (Starts[EarlierIndex].Minutes == Start.Minutes)
|
||
|
|
{
|
||
|
|
++LaneIndex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
LaneCount = FMath::Max(LaneCount, LaneIndex + 1);
|
||
|
|
|
||
|
|
const FText ActivityText = GetActivityLabel(Action.Activity);
|
||
|
|
const FText WindowText = bWholeDay
|
||
|
|
? LOCTEXT("WholeDayWindow", "all day")
|
||
|
|
: MakeWindowText(Start.Minutes, NextMinutes);
|
||
|
|
const FText AnchorText = MakeAnchorText(Action.UsableObjectGuid, AnchorNames);
|
||
|
|
|
||
|
|
FSlotView& Slot = Slots.AddDefaulted_GetRef();
|
||
|
|
|
||
|
|
// A whole day is drawn from midnight rather than from the minute it was authored at: the strip
|
||
|
|
// is the day, and an action that covers it covers all of it.
|
||
|
|
Slot.StartMinutes = bWholeDay ? 0 : Start.Minutes;
|
||
|
|
Slot.EndMinutes = bWholeDay ? MinutesPerDay : NextMinutes;
|
||
|
|
Slot.LaneIndex = LaneIndex;
|
||
|
|
Slot.Color = GetActivityColor(Action.Activity);
|
||
|
|
Slot.BlockLabel = FText::Format(LOCTEXT("SlotLabel", "{0} {1}"), ActivityText, WindowText);
|
||
|
|
Slot.LegendLabel = MakeLegendLine(ActivityText, WindowText, AnchorText);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
FVector2D SNpcScheduleTimeline::ComputeDesiredSize(float LayoutScaleMultiplier) const
|
||
|
|
{
|
||
|
|
const int32 Lanes = FMath::Max(1, LaneCount);
|
||
|
|
const float DayHeight = Lanes * LaneHeight + (Lanes - 1) * LaneGap;
|
||
|
|
const float LegendHeight = Slots.Num() > 0 ? LegendTopGap + Slots.Num() * LegendRowHeight : 0.0f;
|
||
|
|
|
||
|
|
return FVector2D(PreferredWidth, HourLabelHeight + DayHeight + LegendHeight + BottomPadding);
|
||
|
|
}
|
||
|
|
|
||
|
|
int32 SNpcScheduleTimeline::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
|
||
|
|
{
|
||
|
|
// The width is read here and nowhere else. Everything below is placed against whatever the panel
|
||
|
|
// gave the row this frame, which is the whole of how the strip follows the panel being resized
|
||
|
|
// without anybody having to lay it out again.
|
||
|
|
const FVector2f LocalSize = AllottedGeometry.GetLocalSize();
|
||
|
|
const float StripLeft = StripLeftPadding;
|
||
|
|
const float StripWidth = FMath::Max(1.0f, LocalSize.X - StripLeftPadding - StripRightPadding);
|
||
|
|
|
||
|
|
const int32 Lanes = FMath::Max(1, LaneCount);
|
||
|
|
const float DayTop = HourLabelHeight;
|
||
|
|
const float DayBottom = DayTop + Lanes * LaneHeight + (Lanes - 1) * LaneGap;
|
||
|
|
const float LegendTop = DayBottom + LegendTopGap;
|
||
|
|
|
||
|
|
const FSlateBrush* const WhiteBrush = FCoreStyle::Get().GetBrush(TEXT("WhiteBrush"));
|
||
|
|
const ESlateDrawEffect DrawEffects = bParentEnabled
|
||
|
|
? ESlateDrawEffect::None
|
||
|
|
: ESlateDrawEffect::DisabledEffect;
|
||
|
|
|
||
|
|
/** A minute of the day as a place along the strip. */
|
||
|
|
const auto XOfMinute = [StripLeft, StripWidth](int32 MinutesOfDay)
|
||
|
|
{
|
||
|
|
return StripLeft + (StripWidth * static_cast<float>(MinutesOfDay)) / static_cast<float>(MinutesPerDay);
|
||
|
|
};
|
||
|
|
|
||
|
|
/** The top of a lane: the day's own rows, stacked under the ruler. */
|
||
|
|
const auto LaneTop = [DayTop](int32 LaneIndex)
|
||
|
|
{
|
||
|
|
return DayTop + LaneIndex * (LaneHeight + LaneGap);
|
||
|
|
};
|
||
|
|
|
||
|
|
const auto DrawRect = [&](float X, float Y, float RectWidth, float RectHeight, const FLinearColor& Color, int32 Layer)
|
||
|
|
{
|
||
|
|
if (RectWidth <= 0.0f || RectHeight <= 0.0f)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
FSlateDrawElement::MakeBox(OutDrawElements, Layer,
|
||
|
|
AllottedGeometry.ToPaintGeometry(FVector2f(RectWidth, RectHeight), FSlateLayoutTransform(FVector2f(X, Y))),
|
||
|
|
WhiteBrush, DrawEffects, Color);
|
||
|
|
};
|
||
|
|
|
||
|
|
const auto DrawText = [&](float X, float Y, float TextWidth, float TextHeight, const FText& Text, const FLinearColor& Color, int32 Layer)
|
||
|
|
{
|
||
|
|
if (TextWidth <= 0.0f)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
FSlateDrawElement::MakeText(OutDrawElements, Layer,
|
||
|
|
AllottedGeometry.ToPaintGeometry(FVector2f(TextWidth, TextHeight), FSlateLayoutTransform(FVector2f(X, Y))),
|
||
|
|
Text, Font, DrawEffects, Color);
|
||
|
|
};
|
||
|
|
|
||
|
|
/* The trough, the lanes in it, and the hour marks over both, so that an hour reads as a line
|
||
|
|
across a whole day rather than as a mark inside one lane. The marks are the ruler's and the slots
|
||
|
|
are drawn over them: an hour inside a slot is drawn dark on that slot's own colour, see below. */
|
||
|
|
DrawRect(StripLeft, DayTop, StripWidth, DayBottom - DayTop, TroughColor, LayerId);
|
||
|
|
|
||
|
|
for (int32 LaneIndex = 0; LaneIndex < Lanes; ++LaneIndex)
|
||
|
|
{
|
||
|
|
DrawRect(StripLeft, LaneTop(LaneIndex), StripWidth, LaneHeight, LaneColor, LayerId);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int32 Hour = 0; Hour <= 24; ++Hour)
|
||
|
|
{
|
||
|
|
const float HourX = XOfMinute(Hour * 60);
|
||
|
|
const bool bLabelled = Hour % LabelledHourInterval == 0;
|
||
|
|
|
||
|
|
DrawRect(HourX, DayTop, 1.0f, DayBottom - DayTop,
|
||
|
|
bLabelled ? LabelledHourMarkColor : HourMarkColor, LayerId + 1);
|
||
|
|
|
||
|
|
if (bLabelled && Hour < 24)
|
||
|
|
{
|
||
|
|
// Drawn to the right of its own mark rather than centred on it, so that none of the labels
|
||
|
|
// is ever cut in half by the edge of the strip.
|
||
|
|
DrawText(HourX + 3.0f, 0.0f, StripWidth - (HourX + 3.0f - StripLeft), HourLabelHeight,
|
||
|
|
HourLabels[Hour / LabelledHourInterval], HourLabelColor, LayerId + 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* One half of a slot. The day ends at midnight, so a window that runs past it is drawn as two
|
||
|
|
halves with a marker on the edges where they would meet, and either half names the window it is
|
||
|
|
part of: the half with room to say when the whole of it is says it, and is the same answer at
|
||
|
|
both ends of the strip. */
|
||
|
|
const auto DrawSlotHalf = [&](float X, float RectWidth, float Y, const FSlotView& Slot, float MarkerX)
|
||
|
|
{
|
||
|
|
DrawRect(X, Y, RectWidth, LaneHeight, Slot.Color, LayerId + 2);
|
||
|
|
|
||
|
|
// A brighter edge along the top, so that two slots of the same colour meeting at an hour are
|
||
|
|
// still two slots.
|
||
|
|
FLinearColor TopColor = Slot.Color * 1.35f;
|
||
|
|
TopColor.A = 1.0f;
|
||
|
|
DrawRect(X, Y, RectWidth, 2.0f, TopColor, LayerId + 3);
|
||
|
|
|
||
|
|
if (MarkerX >= 0.0f)
|
||
|
|
{
|
||
|
|
DrawRect(MarkerX, Y, WrapMarkerWidth, LaneHeight, WrapMarkerColor, LayerId + 3);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (RectWidth < MinimumLabelledSlotWidth)
|
||
|
|
{
|
||
|
|
// Nothing is legible in a slot this narrow, and a label spilling out of its own slot would
|
||
|
|
// read as belonging to the one beside it. The legend below names it in full instead.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Clipped to the slot it names, for the same reason: a slot that cannot hold its whole label
|
||
|
|
// shows as much of it as it can and not a letter of the next slot's.
|
||
|
|
const FGeometry HalfGeometry = AllottedGeometry.MakeChild(
|
||
|
|
FVector2f(RectWidth, LaneHeight), FSlateLayoutTransform(FVector2f(X, Y)));
|
||
|
|
const FGeometry LabelGeometry = HalfGeometry.MakeChild(
|
||
|
|
FVector2f(FMath::Max(0.0f, RectWidth - SlotLabelInset * 2.0f), SlotLabelHeight),
|
||
|
|
FSlateLayoutTransform(FVector2f(SlotLabelInset, (LaneHeight - SlotLabelHeight) * 0.5f)));
|
||
|
|
|
||
|
|
OutDrawElements.PushClip(FSlateClippingZone(HalfGeometry));
|
||
|
|
FSlateDrawElement::MakeText(OutDrawElements, LayerId + 4, LabelGeometry.ToPaintGeometry(),
|
||
|
|
Slot.BlockLabel, Font, DrawEffects, SlotLabelColor);
|
||
|
|
OutDrawElements.PopClip();
|
||
|
|
};
|
||
|
|
|
||
|
|
for (const FSlotView& Slot : Slots)
|
||
|
|
{
|
||
|
|
const float Y = LaneTop(Slot.LaneIndex);
|
||
|
|
|
||
|
|
// The part of the slot that fits inside the day, which is all of it unless the window wraps.
|
||
|
|
const int32 FirstEndMinutes = FMath::Min(Slot.EndMinutes, MinutesPerDay);
|
||
|
|
const float FirstX = XOfMinute(Slot.StartMinutes);
|
||
|
|
const float FirstWidth = XOfMinute(FirstEndMinutes) - FirstX;
|
||
|
|
const bool bWraps = Slot.EndMinutes > MinutesPerDay;
|
||
|
|
|
||
|
|
DrawSlotHalf(FirstX, FirstWidth, Y, Slot,
|
||
|
|
bWraps ? XOfMinute(MinutesPerDay) - WrapMarkerWidth : -1.0f);
|
||
|
|
|
||
|
|
if (bWraps)
|
||
|
|
{
|
||
|
|
// The rest of the window, at the start of the same day: a 22:00-06:00 night is a slot from
|
||
|
|
// 22:00 to midnight here, and from midnight to 06:00 at the left edge of the strip.
|
||
|
|
DrawSlotHalf(StripLeft, XOfMinute(Slot.EndMinutes - MinutesPerDay) - StripLeft, Y, Slot, StripLeft);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Slots.Num() == 0)
|
||
|
|
{
|
||
|
|
// Said in the trough rather than left blank, because a day with nothing in it is either a
|
||
|
|
// schedule nobody has written yet or an asset that is no longer there, and the two read the
|
||
|
|
// same from here without something to tell them apart.
|
||
|
|
DrawText(StripLeft + SlotLabelInset, DayTop + (LaneHeight - SlotLabelHeight) * 0.5f,
|
||
|
|
StripWidth - SlotLabelInset * 2.0f, SlotLabelHeight,
|
||
|
|
Schedule.IsValid()
|
||
|
|
? LOCTEXT("EmptySchedule", "No actions in this schedule, so the day is empty.")
|
||
|
|
: LOCTEXT("NoSchedule", "No schedule is being drawn."),
|
||
|
|
QuietTextColor, LayerId + 1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// The legend, in the order the day reads rather than the order the array holds, so that
|
||
|
|
// walking it left to right walks the slots left to right as well.
|
||
|
|
int32 RowIndex = 0;
|
||
|
|
for (const FSlotView& Slot : Slots)
|
||
|
|
{
|
||
|
|
const float RowY = LegendTop + RowIndex * LegendRowHeight;
|
||
|
|
|
||
|
|
DrawRect(StripLeft, RowY + (LegendRowHeight - LegendSwatchWidth) * 0.5f,
|
||
|
|
LegendSwatchWidth, LegendSwatchWidth, Slot.Color, LayerId + 5);
|
||
|
|
DrawText(StripLeft + LegendSwatchWidth + LegendSwatchGap, RowY,
|
||
|
|
FMath::Max(0.0f, StripWidth - LegendSwatchWidth - LegendSwatchGap), SlotLabelHeight,
|
||
|
|
Slot.LegendLabel, LegendTextColor, LayerId + 5);
|
||
|
|
|
||
|
|
++RowIndex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return LayerId + 6;
|
||
|
|
}
|
||
|
|
|
||
|
|
#undef LOCTEXT_NAMESPACE
|