Tiler

#include <SDL.h>
#include <SDL_image.h>

enum Pattern{
    SQUARE,
    HEX1,
    HEX2
};

const int
    MIN_ZOOM = 1,
    MAX_ZOOM = 20;

int main(int argc, char* argv[]){
    int
        screenX = 800,
        screenY = 600;

    SDL_Init(SDL_INIT_VIDEO);
    IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG | IMG_INIT_TIF);
    SDL_Window *window = SDL_CreateWindow("Tiler: [1,2,3]: tile mode  [+,-]: zoom  [esc]: quit",
                                          50, 50, screenX, screenY, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

    Pattern pattern = SQUARE;
    int zoom = 3;

    bool loop = true;
    while (loop){
        //handle input
        SDL_Event e;
        while(SDL_PollEvent(&e)){
            switch(e.type){
            case SDL_QUIT:
                loop = false;
                break;

            case SDL_KEYDOWN:
                switch(e.key.keysym.sym){
                case SDLK_ESCAPE:
                    loop = false;
                    break;
                case SDLK_1:
                case SDLK_KP_1:
                    pattern = SQUARE;
                    break;
                case SDLK_2:
                case SDLK_KP_2:
                    pattern = HEX1;
                    break;
                case SDLK_3:
                case SDLK_KP_3:
                    pattern = HEX2;
                    break;
                case SDLK_PLUS:
                case SDLK_KP_PLUS:
                    ++zoom;
                    if (zoom > MAX_ZOOM)
                        zoom = MAX_ZOOM;
                    break;
                case SDLK_MINUS:
                case SDLK_KP_MINUS:
                    --zoom;
                    if (zoom < MIN_ZOOM)
                        zoom = MIN_ZOOM;
                    break;
                }
                break;

            case SDL_WINDOWEVENT:
                switch(e.window.event) {
                case SDL_WINDOWEVENT_SIZE_CHANGED:
                case SDL_WINDOWEVENT_RESIZED:
                case SDL_WINDOWEVENT_MAXIMIZED:
                case SDL_WINDOWEVENT_RESTORED:
                    SDL_GetRendererOutputSize(renderer, &screenX, &screenY);
                    break;
                }
            }
        }

        // load image
        SDL_Surface *tileSurface = IMG_Load(argc > 1 ? argv[1] : "tile.bmp");
        SDL_Texture *tile = SDL_CreateTextureFromSurface(renderer, tileSurface);
        SDL_FreeSurface(tileSurface);

        SDL_SetRenderDrawColor(renderer, 24, 82, 161, 255);

        int w, h;
        SDL_QueryTexture(tile, 0, 0, &w, &h);
        w *= zoom;
        h *= zoom;

        if (tile){

            switch(pattern){
            case SQUARE:
                for (int y = 0; y < screenY; y += h)
                    for (int x = 0; x < screenX; x += w){
                        SDL_Rect r = {x, y, w, h};
                        SDL_RenderCopy(renderer, tile, 0, &r);
                    }
                break;
            case HEX1:{
                int rows = screenY / h + 1;
                for (int y = 0; y < rows; ++y)
                    for (int x = (y % 2 == 0 ? 0 : -w/2); x < screenX; x += w){
                        SDL_Rect r = {x, y*h, w, h};
                        SDL_RenderCopy(renderer, tile, 0, &r);
                    }
                break;
            }
            case HEX2: {
                int cols = screenX / w + 1;
                for (int x = 0; x < cols; ++x)
                    for (int y = (x % 2 == 0 ? 0 : -h/2); y < screenY; y += h){
                        SDL_Rect r = {x*w, y, w, h};
                        SDL_RenderCopy(renderer, tile, 0, &r);
                    }
                break;
            }
            }
        }

        SDL_RenderPresent(renderer);

        // clean up
        SDL_DestroyTexture(tile);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}