imgui.cpp

#include "imgui.h"
#include "pixie.h"
#include "font.h"
#include <string.h>
#include <assert.h>
#include <algorithm>

using namespace Pixie;

struct State
{
    enum Flags
    {
        Flags_Started = 1 << 0,
    };

    bool HasStarted() { return (flags & Flags_Started) != 0; }
    int GetNextId() { return nextId++; }

    int flags;
    int nextId;
    int hoverId;
    int focusId;
    int keyboardCursorPosition;
    float keyRepeatTimer;
    float keyRepeatTime;
    float cursorBlinkTimer;
    uint32_t defaultTextColour;

    Window* window;
    Font* font;
};

static State s_state = { 0 };

void ImGui::Begin(Window* window, Font* font)
{
    assert(window);
    assert(font);

    s_state.flags = State::Flags_Started;
    s_state.nextId = 1;
    s_state.hoverId = 0;
    s_state.window = window;
    s_state.font = font;
    s_state.defaultTextColour = MAKE_RGB(200, 200, 200);
}

void ImGui::End()
{
    s_state.flags = 0;

    if (s_state.window->HasMouseGoneDown(Pixie::MouseButton_Left))
    {
        // If mouse has gone down over empty space, clear the current focus.
        if (s_state.hoverId == 0)
        {
            s_state.focusId = 0;
            s_state.keyboardCursorPosition = 0;
        }
    }

    s_state.window = 0;
}

void ImGui::Label(const char* text, int x, int y, uint32_t colour)
{
    assert(text);
    assert(s_state.HasStarted());
    s_state.font->DrawColour(text, x, y, colour, s_state.window);
}

bool ImGui::Button(const char* label, int x, int y, int width, int height)
{
    assert(s_state.HasStarted());

    Window* window = s_state.window;
    int id = s_state.GetNextId();

    const uint32_t NormalColour = MAKE_RGB(32, 50, 77);
    const uint32_t HoverColour = MAKE_RGB(39, 73, 114);
    const uint32_t PressedColour = MAKE_RGB(22, 40, 67);
    const uint32_t BorderColour = MAKE_RGB(68, 79, 103);
    const uint32_t FocusBorderColour = MAKE_RGB(200, 200, 229);

    int mouseX = window->GetMouseX();
    int mouseY = window->GetMouseY();

    bool hover = mouseX >= x && mouseX <= x + width && mouseY >= y && mouseY <= y + height;
    bool pressed = false;

    if (hover)
    {
        s_state.hoverId = id;

        // Mouse has just gone down over this element, so give it focus.
        if (window->HasMouseGoneDown(Pixie::MouseButton_Left))
            s_state.focusId = id;

        // If mouse is still down over this element and it has focus, then it is pressed.
        pressed = window->IsMouseDown(Pixie::MouseButton_Left) && s_state.focusId == id;
    }

    uint32_t buttonColour = pressed ? PressedColour : hover ? HoverColour : NormalColour;
    uint32_t borderColour = s_state.focusId == id ? FocusBorderColour : BorderColour;

    FilledRect(x, y, width, height, buttonColour, borderColour);

    if (label)
    {
        Font* font = s_state.font;
        int textX = x + ((width - font->GetStringWidth(label)) >> 1);
        int textY = y + ((height - font->GetCharacterHeight()) >> 1);

        Label(label, textX, textY, s_state.defaultTextColour);
    }

    return hover && s_state.focusId == id && window->HasMouseGoneUp(Pixie::MouseButton_Left);
}

void ImGui::Input(char* text, int textBufferLength, int x, int y, int width, int height)
{
    assert(text);
    assert(s_state.HasStarted());

    Window* window = s_state.window;
    int id = s_state.GetNextId();

    const int LeftMargin = 8;
    const uint32_t NormalColour = MAKE_RGB(64, 68, 71);
    const uint32_t HoverColour = MAKE_RGB(74, 78, 81);
    const uint32_t BorderColour = MAKE_RGB(104, 108, 111);
    const uint32_t FocusBorderColour = MAKE_RGB(200, 200, 200);
    const uint32_t CursorColour = MAKE_RGB(220, 220, 220);
    const int CursorWidth = 8;
    const float KeyRepeatTimeInit = 0.2f;
    const float KeyRepeatTimeRepeat = 0.05f;
    const float CursorBlinkTime = 1.0f;

    int mouseX = window->GetMouseX();
    int mouseY = window->GetMouseY();

    bool hover = mouseX >= x && mouseX <= x + width && mouseY >= y && mouseY <= y + height;
    bool pressed = false;
    int textLength = (int)strlen(text);

    int textX = x + LeftMargin;

    if (hover)
    {
        s_state.hoverId = id;

        // Mouse has just gone down over this element, so give it focus.
        if (window->HasMouseGoneDown(Pixie::MouseButton_Left))
        {
            if (s_state.focusId != id)
            {
                s_state.keyRepeatTimer = 0.0f;
                s_state.cursorBlinkTimer = 0.0f;
                s_state.focusId = id;
            }

            // Move the cursor to whereever the user clicked.
            s_state.keyboardCursorPosition = std::min((mouseX - textX) / s_state.font->GetCharacterWidth(), textLength);

            // Also force the cursor to be visible.
            s_state.cursorBlinkTimer = CursorBlinkTime;
        }

        // If mouse is still down over this element and it has focus, then it is pressed.
        pressed = window->IsMouseDown(Pixie::MouseButton_Left) && s_state.focusId == id;
    }

    uint32_t boxColour = pressed || hover || s_state.focusId == id ? HoverColour : NormalColour;
    uint32_t borderColour = s_state.focusId == id ? FocusBorderColour : BorderColour;

    // Draw the input field.
    FilledRect(x, y, width, height, boxColour, borderColour);

    int textY = y + ((height - s_state.font->GetCharacterHeight()) >> 1);
    Label(text, textX, textY, s_state.defaultTextColour);

    if (s_state.focusId == id)
    {
        float delta = window->GetDelta();

        // Input field has focus, draw the keyboard cursor and process input.
        s_state.cursorBlinkTimer -= delta;
        if (s_state.cursorBlinkTimer >= CursorBlinkTime * 0.5f)
            FilledRect(textX + (s_state.keyboardCursorPosition * s_state.font->GetCharacterWidth()), textY + s_state.font->GetCharacterHeight() - 2, CursorWidth, 2, CursorColour, CursorColour);
        if (s_state.cursorBlinkTimer <= 0.0f || window->IsAnyKeyDown())
            s_state.cursorBlinkTimer = CursorBlinkTime;

        // TODO: Not sure if this is the right way to do this. The timer should probably be per-key.
        if (window->HasAnyKeyGoneDown())
        {
            s_state.keyRepeatTimer = 0.0f;
            s_state.keyRepeatTime = KeyRepeatTimeInit;
        }

        s_state.keyRepeatTimer -= delta;
        if (s_state.keyRepeatTimer <= 0.0f)
        {
            s_state.keyRepeatTimer = s_state.keyRepeatTime;
            s_state.keyRepeatTime = KeyRepeatTimeRepeat;

            if (window->IsKeyDown(Pixie::Key_Left))
            {
                s_state.keyboardCursorPosition = std::max(s_state.keyboardCursorPosition - 1, 0);
            }
            else if (window->IsKeyDown(Pixie::Key_Right))
            {
                s_state.keyboardCursorPosition = std::min(s_state.keyboardCursorPosition + 1, textLength);
            }
            else if (window->IsKeyDown(Pixie::Key_Backspace))
            {
                // Move cursor back.
                s_state.keyboardCursorPosition--;

                if (s_state.keyboardCursorPosition >= 0)
                {
                    // Copy everything after the current position to the current position.
                    int position = s_state.keyboardCursorPosition;
                    int copyAmount = (int)strlen(text + position + 1) + 1;
                    memcpy(text + position, text + position + 1, copyAmount);
                }
                else
                {
                    s_state.keyboardCursorPosition = 0;
                }
            }
            else if (window->IsKeyDown(Pixie::Key_Delete))
            {
                // Delete the current character.
                int position = s_state.keyboardCursorPosition;
                if (position < textLength)
                {
                    // Copy everything after the current position to the current position.
                    int copyAmount = (int)strlen(text + position + 1) + 1;
                    memcpy(text + position, text + position + 1, copyAmount);
                }
            }
            else if (window->IsKeyDown(Pixie::Key_Home))
            {
                s_state.keyboardCursorPosition = 0;
            }
            else if (window->IsKeyDown(Pixie::Key_End))
            {
                s_state.keyboardCursorPosition = textLength;
            }
        }

        // Process remaining ASCII input.
        const char* inputCharacters = window->GetInputCharacters();
        if (*inputCharacters)
        {
            for ( ; *inputCharacters; inputCharacters++)
            {
                if (s_state.keyboardCursorPosition == textBufferLength - 1)
                    break;

                // Overwrite the character at the current position.
                int position = s_state.keyboardCursorPosition;
                assert(position >= 0 && position < textBufferLength - 1);
                text[position] = *inputCharacters;

                // If at the end of the string, add a null because we've just extended the string.
                if (position == textLength)
                {
                    position++;
                    assert(position >= 0 && position < textBufferLength);
                    text[position] = 0;
                }

                // Move the cursor.
                s_state.keyboardCursorPosition = std::min(s_state.keyboardCursorPosition + 1, textBufferLength);
            }

            // We have consumed the input so remove it from the buffer.
            window->ClearInputCharacters();
        }
    }
}

bool ImGui::Checkbox(const char* label, bool checked, int x, int y)
{
    assert(label);
    assert(s_state.HasStarted());

    const int TextLeftMargin = 8;
    const int BoxSize = 18;
    const int CheckSize = 8;

    Font* font = s_state.font;
    int charHeight = font->GetCharacterHeight();

    int textY = y + ((BoxSize - charHeight) >> 1) + 1;
    Label(label, x + BoxSize + TextLeftMargin, textY, s_state.defaultTextColour);
    bool wasChecked = checked;
    if (Button(0, x, y, BoxSize, BoxSize))
        checked = !checked;

    if (wasChecked)
    {
        // Draw check mark.
        int checkX = x + ((BoxSize - CheckSize) >> 1);
        int checkY = y + ((BoxSize - CheckSize) >> 1);
        Window* window = s_state.window;
        int windowWidth = window->GetWidth();
        uint32_t* pixels = window->GetPixels();
        y = checkY;
        for (int yy = y*windowWidth, x = 0; y < checkY + CheckSize; y++, x++, yy += windowWidth)
        {
            pixels[checkX + x + yy] = MAKE_RGB(255, 255, 255);
            pixels[checkX + CheckSize - x - 1 + yy] = MAKE_RGB(255, 255, 255);
        }
    }

    return checked;
}

bool ImGui::RadioButton(const char* label, bool checked, int x, int y)
{
    assert(label);
    assert(s_state.HasStarted());

    const int TextLeftMargin = 8;
    const int BoxSize = 18;
    const int CheckSize = 8;
    const uint32_t FontColour = s_state.defaultTextColour;

    Font* font = s_state.font;
    int charHeight = font->GetCharacterHeight();

    int textY = y + ((BoxSize - charHeight) >> 1) + 1;
    Label(label, x + BoxSize + TextLeftMargin, textY, FontColour);
    bool wasChecked = checked;
    if (Button(0, x, y, BoxSize, BoxSize))
        checked = !checked;

    if (wasChecked)
    {
        // Draw radio button mark.
        int checkX = x + ((BoxSize - CheckSize) >> 1);
        int checkY = y + ((BoxSize - CheckSize) >> 1);
        FilledRect(checkX, checkY, CheckSize, CheckSize, FontColour, FontColour);
    }

    return checked;
}

void ImGui::Rect(int x, int y, int width, int height, uint32_t borderColour)
{
    assert(s_state.HasStarted());
    Window* window = s_state.window;
    uint32_t* pixels = window->GetPixels();
    int windowWidth = window->GetWidth();
    int windowHeight = window->GetHeight();

    pixels += x + (y*windowWidth);

    for (int j = 0, ypos = y; j < height && ypos < windowHeight; j++, ypos++)
    {
        int left = x;
        if (left >= 0 && left < windowWidth)
            *pixels = borderColour;

        int right = x + width - 1;
        if (right >= 0 && right < windowWidth)
            *(pixels + width - 1) = borderColour;

        pixels += windowWidth;
    }

    pixels = window->GetPixels() + x + (y*windowWidth);
    for (int i = 0, xpos = x; i < width; i++, xpos++)
    {
        int top = y;
        if (top >= 0 && top < windowHeight)
            *pixels = borderColour;

        int bottom = y + height - 1;
        if (bottom >= 0 && bottom < windowHeight)
            *(pixels + ((height-1)*windowWidth)) = borderColour;

        pixels++;
    }
}

void ImGui::FilledRect(int x, int y, int width, int height, uint32_t colour, uint32_t borderColour)
{
    assert(s_state.HasStarted());
    Window* window = s_state.window;
    uint32_t* pixels = window->GetPixels();
    int windowWidth = window->GetWidth();
    int windowHeight = window->GetHeight();

    pixels += x + (y*windowWidth);

    for (int j = 0, ypos = y; j < height && ypos < windowHeight; j++, ypos++)
    {
        for (int i = 0, xpos = x; i < width; i++, xpos++)
        {
            if (xpos < 0 || xpos >= windowWidth || ypos < 0 || ypos >= windowHeight)
                continue;
            *pixels = (i == 0 || i == width - 1 || j == 0 || j == height - 1) ? borderColour : colour;
            pixels++;
        }

        pixels += windowWidth - width;
    }
}