Hat_Math Graph Previewer

/**
 * HUD whose sole purpose is to preview the output of some of the math functions on a graph.
 * To preview a function, simply enter its name in the Command property of the Open HUD node.
 *
 * Supported functions:
 *    - InterpolationOvershoot
 *    - InterpolationSpring
 *    - InterpolationBounce
 *    - BounceAnimation
 *    - InterpolationAnticipate
 *    - InterpolationAnticipateSub
 *    - InterpolationDecelerate
 *    - InterpolationEaseInEaseOut
 *
 * NOTE: This can be extended to support more functions, if needed.
 *
 * Controls:
 *    - Parameter 1 - W/S
 *    - Parameter 2 - A/D
 *    - Parameter 3 - 1/4/scroll (if not used, these also control Parameter 1)
 *    - Parameter 4 - 2/3        (if not used, these also control Parameter 2)
 *
 * NOTE: As of right now, none of the functions use more than 2 parameters.
 */
class Drew_HUDElement_HatMathGraphPreviewer extends Hat_HUDElement;
 
const GRAPH_SAMPLE_COUNT = 200;
const GRAPH_PADDING = 0.15f;
 
var string FunctionNameDisplay;
var string ParameterDisplay;
var Vector2D GraphRangeStart, GraphRangeEnd;
var int VerticalLineAmount, HorizontalLineAmount;
 
struct DebugGraphParameter
{
    var string Name;
    var float StepValue;
    var int StepCount;
    var bool IsBool;
    var transient float CurrentValue;
};
 
var DebugGraphParameter P1, P2, P3, P4;
 
delegate float MathFunctionOutput(float X)
{
    return 0.5f;
}
 
function OnOpenHUD(HUD H, optional string command)
{
    Super.OnOpenHUD(H, command);
 
    switch (Locs(command))
    {
        case "interpolationovershoot":
            FunctionNameDisplay = "InterpolationOvershoot(0, 1, X, Tension)";
            MathFunctionOutput = InterpolationOvershoot;
            GraphRangeStart.Y = 3.f;
            HorizontalLineAmount = 7;
            P1.Name = "Tension";
            P1.StepValue = 0.5f;
            P1.StepCount = 4;
            RefreshParameter(P1);
            break;
        case "interpolationspring":
            FunctionNameDisplay = "InterpolationSpring(0, 1, X, Factor, Bounce Rate)";
            MathFunctionOutput = InterpolationSpring;
            GraphRangeStart.Y = 2.f;
            HorizontalLineAmount = 5;
            P1.Name = "Factor";
            P1.StepValue = 0.05f;
            P1.StepCount = 8;
            RefreshParameter(P1);
            P2.Name = "Bounce Rate";
            P2.StepValue = 0.5f;
            P2.StepCount = 20;
            RefreshParameter(P2);
            break;
        case "interpolationbounce":
            FunctionNameDisplay = "InterpolationBounce(1, 0, X, Strength)";
            MathFunctionOutput = InterpolationBounce;
            GraphRangeEnd.X = 1.5f;
            VerticalLineAmount = 7;
            P1.Name = "Strength";
            P1.StepValue = 0.1f;
            P1.StepCount = 10;
            RefreshParameter(P1);
            break;
        case "bounceanimation":
            FunctionNameDisplay = "BounceAnimation(X, Scale, BounceCount)";
            MathFunctionOutput = BounceAnimation;
            GraphRangeStart.Y = 2.f;
            GraphRangeEnd.Y = 1.f;
            HorizontalLineAmount = 5;
            P1.Name = "Scale";
            P1.StepValue = 0.1f;
            P1.StepCount = 5;
            RefreshParameter(P1);
            P2.Name = "Bounce Count";
            P2.StepValue = 1.f;
            P2.StepCount = 4;
            RefreshParameter(P2);
            break;
        case "interpolationanticipate":
            FunctionNameDisplay = "InterpolationAnticipate(0, 1, X, Tension, Overshoot)";
            MathFunctionOutput = InterpolationAnticipate;
            GraphRangeStart.Y = 2.f;
            GraphRangeEnd.Y = -1.f;
            HorizontalLineAmount = 7;
            P1.Name = "Tension";
            P1.StepValue = 0.5f;
            P1.StepCount = 6;
            RefreshParameter(P1);
            P2.Name = "Overshoot";
            P2.StepValue = 1.f;
            P2.StepCount = 1;
            P2.IsBool = True;
            RefreshParameter(P2);
            break;
        case "interpolationanticipatesub":
            FunctionNameDisplay = "InterpolationAnticipateSub(X, S, Subtract)";
            MathFunctionOutput = InterpolationAnticipateSub;
            P1.Name = "S";
            P1.StepValue = 0.1f;
            P1.StepCount = 0;
            RefreshParameter(P1);
            P2.Name = "Subtract";
            P2.StepValue = 1.f;
            P2.StepCount = 1;
            P2.IsBool = True;
            RefreshParameter(P2);
            break;
        case "interpolationdecelerate":
            FunctionNameDisplay = "InterpolationDecelerate(0, 1, X, Factor)";
            MathFunctionOutput = InterpolationDecelerate;
            P1.Name = "Factor";
            P1.StepValue = 0.1f;
            P1.StepCount = 10;
            RefreshParameter(P1);
            break;
        case "interpolationeaseineaseout":
            FunctionNameDisplay = "InterpolationEaseInEaseOut(0, 1, X)";
            MathFunctionOutput = InterpolationEaseInEaseOut;
            break;
    }
    RefreshParameterDisplay();
}
 
function RefreshParameter(out DebugGraphParameter P)
{
    if (P.IsBool) P.StepCount = Clamp(P.StepCount, 0, 1);
    P.CurrentValue = P.StepValue * P.StepCount;
}
 
function RefreshParameterDisplay()
{
    ParameterDisplay = "";
    AppendParameterDisplayForParameter(P1);
    AppendParameterDisplayForParameter(P2);
    AppendParameterDisplayForParameter(P3);
    AppendParameterDisplayForParameter(P4);
}
 
function AppendParameterDisplayForParameter(out DebugGraphParameter P)
{
    if (P.StepValue == 0.f) return;
    if (ParameterDisplay != "") ParameterDisplay $= " , ";
    if (P.IsBool)
        ParameterDisplay $= (P.Name $ " = " $ Bool(P.CurrentValue));
    else
        ParameterDisplay $= (P.Name $ " = " $ PrettyNumberRounding(P.CurrentValue));
}
 
function bool OnPressUp(HUD H, bool menu, bool release)
{
    if (release) return false;
    if (menu && P3.StepValue != 0.f)
    {
        P3.StepCount++;
        RefreshParameter(P3);
    }
    else
    {
        P1.StepCount++;
        RefreshParameter(P1);
    }
    RefreshParameterDisplay();
    return true;
}
 
function bool OnPressDown(HUD H, bool menu, bool release)
{
    if (release) return false;
    if (menu && P3.StepValue != 0.f)
    {
        P3.StepCount--;
        RefreshParameter(P3);
    }
    else
    {
        P1.StepCount--;
        RefreshParameter(P1);
    }
    RefreshParameterDisplay();
    return true;
}
 
function bool OnPressLeft(HUD H, bool menu, bool release)
{
    if (release) return false;
    if (menu && P4.StepValue != 0.f)
    {
        P4.StepCount--;
        RefreshParameter(P4);
    }
    else
    {
        P2.StepCount--;
        RefreshParameter(P2);
    }
    RefreshParameterDisplay();
    return true;
}
 
function bool OnPressRight(HUD H, bool menu, bool release)
{
    if (release) return false;
    if (menu && P4.StepValue != 0.f)
    {
        P4.StepCount++;
        RefreshParameter(P4);
    }
    else
    {
        P2.StepCount++;
        RefreshParameter(P2);
    }
    RefreshParameterDisplay();
    return true;
}
 
function bool Render(HUD H)
{
    local Vector2D GraphStart, GraphEnd;
    local float MinClip, Length, Ratio, PosX, PosY, NextPosX, ValueX, TextSize;
    local int i;
    local TextAlign TA;
    local bool InBatched;
 
    if (!Super.Render(H)) return false;
 
    H.Canvas.SetDrawColor(0, 0, 0, 255);
    H.Canvas.SetPos(0.f, 0.f);
    H.Canvas.DrawRect(H.Canvas.ClipX, H.Canvas.ClipY);
 
    MinClip = FMin(H.Canvas.ClipX, H.Canvas.ClipY);
    TextSize = MinClip * 0.0007f;
 
    GraphStart.X = MinClip * GRAPH_PADDING;
    GraphStart.Y = GraphStart.X;
    GraphEnd.X = H.Canvas.ClipX - GraphStart.X;
    GraphEnd.Y = H.Canvas.ClipY - GraphStart.Y;
 
    H.Canvas.SetDrawColor(100, 100, 100, 255);
    H.Canvas.Font = class'Hat_FontInfo'.static.GetDefaultFont("0123456789.");
 
    // Vertical lines
    if (VerticalLineAmount >= 2)
    {
        PosY = (GraphStart.Y + GraphEnd.Y) * 0.5f;
        Length = GraphEnd.Y - GraphStart.Y;
        for (i = 0; i < VerticalLineAmount; i++)
        {
            Ratio = Float(i) / (VerticalLineAmount - 1.f);
            PosX = Lerp(GraphStart.X, GraphEnd.X, Ratio);
            DrawCenter(H, PosX, PosY, 2.f, Length, H.Canvas.DefaultTexture);
            if (i == 0)
                TA = TextAlign_Left;
            else
                TA = TextAlign_Center;
            DrawText(H.Canvas, PrettyNumberRounding(Lerp(GraphRangeStart.X, GraphRangeEnd.X, Ratio)), PosX, GraphEnd.Y + TextSize * 30.f, TextSize, TextSize, TA);
        }
    }
 
    // Horizontal lines
    if (HorizontalLineAmount >= 2)
    {
        PosX = (GraphStart.X + GraphEnd.X) * 0.5f;
        Length = GraphEnd.X - GraphStart.X;
        for (i = 0; i < HorizontalLineAmount; i++)
        {
            Ratio = Float(i) / (HorizontalLineAmount - 1.f);
            PosY = Lerp(GraphStart.Y, GraphEnd.Y, Ratio);
            DrawCenter(H, PosX, PosY, Length, 2.f, H.Canvas.DefaultTexture);
            if (i == HorizontalLineAmount - 1)
                TA = TextAlign_BottomRight;
            else
                TA = TextAlign_Right;
            DrawText(H.Canvas, PrettyNumberRounding(Lerp(GraphRangeStart.Y, GraphRangeEnd.Y, Ratio)), GraphStart.X - TextSize * 10.f, PosY, TextSize, TextSize, TA);
        }
    }
 
    H.Canvas.SetDrawColor(255, 255, 255, 255);
    NextPosX = GraphStart.X;
    InBatched = H.Canvas.StartBatchedRendering();
    for (i = 0; i < GRAPH_SAMPLE_COUNT; i++)
    {
        PosX = NextPosX;
        NextPosX = Lerp(GraphStart.X, GraphEnd.X, Float(i + 1) / GRAPH_SAMPLE_COUNT);
        ValueX = Lerp(GraphRangeStart.X, GraphRangeEnd.X, Float(i) / (GRAPH_SAMPLE_COUNT - 1.f));
        PosY = Lerp(GraphStart.Y, GraphEnd.Y, (MathFunctionOutput(ValueX) - GraphRangeStart.Y) / (GraphRangeEnd.Y - GraphRangeStart.Y));
        DrawCenterLeft(H, PosX, PosY, NextPosX - PosX, 2.f, H.Canvas.DefaultTexture);
    }
    if (InBatched) H.Canvas.EndBatchedRendering();
 
    if (FunctionNameDisplay != "")
    {
        H.Canvas.SetDrawColor(255, 255, 200, 255);
        H.Canvas.Font = class'Hat_FontInfo'.static.GetDefaultFont(FunctionNameDisplay);
        DrawText(H.Canvas, FunctionNameDisplay, H.Canvas.ClipX * 0.5f, TextSize * 1.5f * 55.f, TextSize * 1.5f, TextSize * 1.5f, TextAlign_Center);
    }
 
    if (ParameterDisplay != "")
    {
        H.Canvas.SetDrawColor(255, 255, 255, 255);
        H.Canvas.Font = class'Hat_FontInfo'.static.GetDefaultFont(ParameterDisplay);
        DrawText(H.Canvas, ParameterDisplay, H.Canvas.ClipX * 0.5f, H.Canvas.ClipY - TextSize * 55.f, TextSize, TextSize, TextAlign_Center);
    }
 
    return true;
}
 
function string PrettyNumberRounding(float InFloat)
{
    local int Number, Decimal;
    Number = Round(InFloat * 1000.f);
    Decimal = Number % 1000;
    Number /= 1000;
    while (Decimal != 0 && Decimal % 10 == 0)
        Decimal /= 10;
    if (Decimal == 0)
        return String(Number);
    else
        return (Decimal < 0 ? "-" : "") $ Int(Abs(Number)) $ "." $ Int(Abs(Decimal));
}
 
// Math functions.
 
function float InterpolationOvershoot(float X)
{
    return class'Hat_Math'.static.InterpolationOvershoot(0.f, 1.f, X, P1.CurrentValue);
}
 
function float InterpolationSpring(float X)
{
    return class'Hat_Math'.static.InterpolationSpring(0.f, 1.f, X, P1.CurrentValue, P2.CurrentValue);
}
 
function float InterpolationBounce(float X)
{
    return class'Hat_Math'.static.InterpolationBounce(1.f, 0.f, X, P1.CurrentValue);
}
 
function float BounceAnimation(float X)
{
    return class'Hat_Math'.static.BounceAnimation(X, P1.CurrentValue, Round(P2.CurrentValue));
}
 
function float InterpolationAnticipate(float X)
{
    return class'Hat_Math'.static.InterpolationAnticipate(0.f, 1.f, X, P1.CurrentValue, Bool(P2.CurrentValue));
}
 
function float InterpolationAnticipateSub(float X)
{
    return class'Hat_Math'.static.InterpolationAnticipateSub(X, P1.CurrentValue, Bool(P2.CurrentValue));
}
 
function float InterpolationDecelerate(float X)
{
    return class'Hat_Math'.static.InterpolationDecelerate(0.f, 1.f, X, P1.CurrentValue);
}
 
function float InterpolationEaseInEaseOut(float X)
{
    return class'Hat_Math'.static.InterpolationEaseInEaseOut(0.f, 1.f, X);
}
 
defaultproperties
{
    FunctionNameDisplay = "Missing command! (read script header)"
 
    GraphRangeStart = (X = 0.f, Y = 1.f)
    GraphRangeEnd   = (X = 1.f, Y = 0.f)
 
    VerticalLineAmount = 5
    HorizontalLineAmount = 5
}