main.cpp

#include <SDL.h>
#include <iostream>
#include <random>
#include <vector>
#include <cmath>

// Glow configuration
const int BORDER_THICKNESS = 20;
const Uint32 FADE_DURATION = 1500;

struct Glow
{
    Uint8 r, g, b;
    Uint32 startTime;
    float alpha;
};

std::vector<Glow> activeGlows;

// Random number generator
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> hueDist(0, 360);
std::uniform_real_distribution<> satDist(0.8, 1.0);
std::uniform_real_distribution<> valDist(0.8, 1.0);

void logSDLError(const std::string &msg)
{
    std::cerr << msg << " Error: " << SDL_GetError() << std::endl;
}

// Convert HSV to RGB for vibrant colors
void hsvToRgb(float h, float s, float v, Uint8 &r, Uint8 &g, Uint8 &b)
{
    float c = v * s;
    float x = c * (1.0f - std::abs(std::fmod(h / 60.0f, 2.0f) - 1.0f));
    float m = v - c;

    float r_prime, g_prime, b_prime;

    if (h < 60)
    {
        r_prime = c;
        g_prime = x;
        b_prime = 0;
    }
    else if (h < 120)
    {
        r_prime = x;
        g_prime = c;
        b_prime = 0;
    }
    else if (h < 180)
    {
        r_prime = 0;
        g_prime = c;
        b_prime = x;
    }
    else if (h < 240)
    {
        r_prime = 0;
        g_prime = x;
        b_prime = c;
    }
    else if (h < 300)
    {
        r_prime = x;
        g_prime = 0;
        b_prime = c;
    }
    else
    {
        r_prime = c;
        g_prime = 0;
        b_prime = x;
    }

    r = static_cast<Uint8>((r_prime + m) * 255);
    g = static_cast<Uint8>((g_prime + m) * 255);
    b = static_cast<Uint8>((b_prime + m) * 255);
}

int main(int argc, char *argv[])
{
    if (SDL_Init(SDL_INIT_VIDEO) != 0)
    {
        logSDLError("SDL_Init Error");
        return 1;
    }

    // Get usable display bounds (excludes menu bar and dock)
    SDL_Rect usableBounds;
    if (SDL_GetDisplayUsableBounds(0, &usableBounds) != 0)
    {
        logSDLError("SDL_GetDisplayUsableBounds Error");
        SDL_Quit();
        return 1;
    }

    const int SCREEN_WIDTH = usableBounds.w;
    const int SCREEN_HEIGHT = usableBounds.h;

    // Fullscreen borderless window (positioned below menu bar)
    SDL_Window *window = SDL_CreateWindow(
        "Keyboard Glow",
        usableBounds.x, usableBounds.y,
        SCREEN_WIDTH, SCREEN_HEIGHT,
        SDL_WINDOW_BORDERLESS);

    if (window == nullptr)
    {
        logSDLError("SDL_CreateWindow Error");
        SDL_Quit();
        return 1;
    }

    // Make window semi-transparent so you can see through the center
    SDL_SetWindowOpacity(window, 0.3f);

    SDL_Renderer *renderer = SDL_CreateRenderer(
        window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);

    if (renderer == nullptr)
    {
        logSDLError("SDL_CreateRenderer Error");
        SDL_DestroyWindow(window);
        SDL_Quit();
        return 1;
    }

    std::cout << "Keyboard Glow Visualizer running!\n";
    std::cout << "Type while this window is focused to see colors.\n";
    std::cout << "Press ESC to quit.\n";

    SDL_Event e;
    bool quit = false;

    while (!quit)
    {
        while (SDL_PollEvent(&e))
        {
            if (e.type == SDL_QUIT)
            {
                quit = true;
            }
            else if (e.type == SDL_KEYDOWN)
            {
                if (e.key.keysym.sym == SDLK_ESCAPE)
                {
                    quit = true;
                }
                else
                {
                    // Generate random vibrant color
                    float hue = hueDist(gen);
                    float sat = satDist(gen);
                    float val = valDist(gen);

                    Glow newGlow;
                    hsvToRgb(hue, sat, val, newGlow.r, newGlow.g, newGlow.b);
                    newGlow.startTime = SDL_GetTicks();
                    newGlow.alpha = 1.0f;

                    activeGlows.push_back(newGlow);
                }
            }
        }

        // Update glows
        Uint32 currentTime = SDL_GetTicks();
        for (auto it = activeGlows.begin(); it != activeGlows.end();)
        {
            Uint32 elapsed = currentTime - it->startTime;
            if (elapsed < FADE_DURATION)
            {
                it->alpha = 1.0f - (float)elapsed / FADE_DURATION;
                ++it;
            }
            else
            {
                it = activeGlows.erase(it);
            }
        }

        // Render
        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
        SDL_RenderClear(renderer);

        // Border rectangles (connected at corners)
        SDL_Rect topBorder = {0, 0, SCREEN_WIDTH, BORDER_THICKNESS};
        SDL_Rect bottomBorder = {0, SCREEN_HEIGHT - BORDER_THICKNESS, SCREEN_WIDTH, BORDER_THICKNESS};
        SDL_Rect leftBorder = {0, BORDER_THICKNESS, BORDER_THICKNESS, SCREEN_HEIGHT - 2 * BORDER_THICKNESS};
        SDL_Rect rightBorder = {SCREEN_WIDTH - BORDER_THICKNESS, BORDER_THICKNESS, BORDER_THICKNESS, SCREEN_HEIGHT - 2 * BORDER_THICKNESS};

        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD);
        for (const auto &glow : activeGlows)
        {
            Uint8 alphaValue = static_cast<Uint8>(glow.alpha * 255);
            SDL_SetRenderDrawColor(renderer, glow.r, glow.g, glow.b, alphaValue);
            SDL_RenderFillRect(renderer, &topBorder);
            SDL_RenderFillRect(renderer, &bottomBorder);
            SDL_RenderFillRect(renderer, &leftBorder);
            SDL_RenderFillRect(renderer, &rightBorder);
        }

        SDL_RenderPresent(renderer);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}