linux_breakout.c

#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <unistd.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>

#include <sys/sysinfo.h>

#include "breakout_platform.h"

#include "breakout.c"

#define CHECK(x) if(!(x)) { fprintf(stderr, "Fatal error at %s:%d: expression '%s' failed\n", __FILE__, __LINE__, #x); exit(1); }
#define LINUX_CHECK(x) if((x)) { fprintf(stderr, "Fatal error at %s:%d: expression '%s' failed, errno = %d (%s)\n", __FILE__, __LINE__, #x, errno, strerror(errno)); exit(1); }

int main(int Argc, char** Argv)
{
    persistent char xScreenBuffer[4096 * 4096 * 4];
    persistent u8 ScreenBuffer[4096 * 4096 * 4];
    int ScreenMargin = 256;

    game_screen Screen;
    Screen.Width = 1024;
    Screen.Height = 768;
    Screen.Pitch = (Screen.Width + 2*ScreenMargin) * 4;
    Screen.At = ScreenBuffer + ScreenMargin*Screen.Pitch + ScreenMargin*4;

    Display* xDisplay = XOpenDisplay(0);
    CHECK(xDisplay);

    int xRootWindow = DefaultRootWindow(xDisplay);
    int xDefaultScreen = DefaultScreen(xDisplay);
    int xScreenBitDepth = 24;

    XVisualInfo xVisualInfo = {0};
    CHECK(XMatchVisualInfo(xDisplay, xDefaultScreen, xScreenBitDepth, TrueColor, &xVisualInfo))

    XSetWindowAttributes xWindowAttributes = {0};
    xWindowAttributes.background_pixel = 0;
    xWindowAttributes.colormap = XCreateColormap(xDisplay, xRootWindow, xVisualInfo.visual, AllocNone);
    xWindowAttributes.event_mask = StructureNotifyMask | KeyPressMask;
    unsigned long xAttributeMask = CWBackPixel | CWColormap | CWEventMask;

    Window xWindow = XCreateWindow(xDisplay, xRootWindow, 0, 0,
                                   Screen.Width, Screen.Height, 0, xVisualInfo.depth,
                                   InputOutput, xVisualInfo.visual, xAttributeMask,
                                   &xWindowAttributes);
    CHECK(xWindow);

    XStoreName(xDisplay, xWindow, "Breakout");
    XMapWindow(xDisplay, xWindow);
    XFlush(xDisplay);

    Atom WM_DELETE_WINDOW = XInternAtom(xDisplay, "WM_DELETE_WINDOW", False);
    CHECK(XSetWMProtocols(xDisplay, xWindow, &WM_DELETE_WINDOW, 1));

    XImage* xWindowBuffer = XCreateImage(xDisplay, xVisualInfo.visual, xVisualInfo.depth,
                                         ZPixmap, 0, xScreenBuffer, Screen.Width, Screen.Height,
                                         32, 0);
    CHECK(xWindowBuffer);

    GC xDefaultGC = DefaultGC(xDisplay, xDefaultScreen);

    persistent game_memory Memory;
    GameInit(&Memory, Screen.Width, Screen.Height);

    KeyCode xKeyReturn = XKeysymToKeycode(xDisplay, XK_Return);
    KeyCode xKeySpace = XKeysymToKeycode(xDisplay, XK_space);
    KeyCode xKeyLeft = XKeysymToKeycode(xDisplay, XK_Left);
    KeyCode xKeyRight = XKeysymToKeycode(xDisplay, XK_Right);
    KeyCode xKeyUp = XKeysymToKeycode(xDisplay, XK_Up);
    KeyCode xKeyDown = XKeysymToKeycode(xDisplay, XK_Down);
    KeyCode xKeyEscape = XKeysymToKeycode(xDisplay, XK_Escape);

    struct timespec Time;
    LINUX_CHECK(clock_gettime(CLOCK_MONOTONIC, &Time));

    int xWindowOpen = 1;
    while(xWindowOpen)
    {
        XEvent xEvent = {0};
        while(XPending(xDisplay) > 0)
        {
            XNextEvent(xDisplay, &xEvent);
            switch(xEvent.type)
            {
                case DestroyNotify:
                {
                    XDestroyWindowEvent* xE = (XDestroyWindowEvent*) &xEvent;
                    if(xE->window == xWindow)
                    {
                        xWindowOpen = 0;
                    }
                } break;

                case ClientMessage:
                {
                    XClientMessageEvent* xE = (XClientMessageEvent*) &xEvent;
                    if((Atom)xE->data.l[0] == WM_DELETE_WINDOW)
                    {
                        XDestroyWindow(xDisplay, xWindow);
                        xWindowOpen = 0;
                    }
                } break;
            }
        }

        char xKeymap[32];
        XQueryKeymap(xDisplay, xKeymap);

        u32 Keys = 0;
        if(xKeymap[xKeyLeft>>3] & (1 << (xKeyLeft&7)))     Keys |= GAME_KEYS_LEFT_Msk;
        if(xKeymap[xKeyRight>>3] & (1 << (xKeyRight&7)))   Keys |= GAME_KEYS_RIGHT_Msk;
        if(xKeymap[xKeyUp>>3] & (1 << (xKeyUp&7)))         Keys |= GAME_KEYS_UP_Msk;
        if(xKeymap[xKeyDown>>3] & (1 << (xKeyDown&7)))     Keys |= GAME_KEYS_DOWN_Msk;
        if(xKeymap[xKeyReturn>>3] & (1 << (xKeyReturn&7))) Keys |= GAME_KEYS_RETURN_Msk;
        if(xKeymap[xKeySpace>>3] & (1 << (xKeySpace&7)))   Keys |= GAME_KEYS_SPACE_Msk;
        if(xKeymap[xKeyEscape>>3] & (1 << (xKeyEscape&7))) Keys |= GAME_KEYS_ESCAPE_Msk;

        struct sysinfo SysInfo;
        LINUX_CHECK(sysinfo(&SysInfo));

        GameUpdate(&Memory, &Screen, Keys, SysInfo.uptime);

        int DstPitch = Screen.Width*4;
        char* DstRow = xScreenBuffer + (Screen.Height-1)*DstPitch;
        u8* SrcRow = Screen.At;
        for(int Y = 0;
            Y < Screen.Height;
            Y++)
        {
            char* DstCol = DstRow;
            u8* SrcCol = SrcRow;

            for(int X = 0;
                X < Screen.Width;
                X++)
            {
                *(u32*)(DstCol) = *(u32*)(SrcCol);

                DstCol += 4;
                SrcCol += 4;
            }

            DstRow -= DstPitch;
            SrcRow += Screen.Pitch;
        }

        XPutImage(xDisplay, xWindow, xDefaultGC, xWindowBuffer, 0, 0, 0, 0, Screen.Width, Screen.Height);

        Time.tv_nsec += (1*1000*1000*1000) / 30;
        if(Time.tv_nsec >= 1*1000*1000*1000)
        {
            Time.tv_nsec -= 1*1000*1000*1000;
            Time.tv_sec++;
        }

        LINUX_CHECK(clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &Time, 0));
    }
}