alphatau 0.1.0

data/ext/alphatau/native/sdl/Xcode-iOS/Demos/src/happy.c

@@ -0,0 +1,180 @@
+/*
+ *  happy.c
+ *  written by Holmes Futrell
+ *  use however you want
+ */
+
+#include "SDL.h"
+#include "common.h"
+
+#define NUM_HAPPY_FACES 100     /* number of faces to draw */
+#define HAPPY_FACE_SIZE 32      /* width and height of happyface */
+
+static SDL_Texture *texture = 0;    /* reference to texture holding happyface */
+
+static struct
+{
+    float x, y;                 /* position of happyface */
+    float xvel, yvel;           /* velocity of happyface */
+} faces[NUM_HAPPY_FACES];
+
+/*
+    Sets initial positions and velocities of happyfaces
+    units of velocity are pixels per millesecond
+*/
+void
+initializeHappyFaces(SDL_Renderer *renderer)
+{
+    int i;
+    int w;
+    int h;
+    SDL_RenderGetLogicalSize(renderer, &w, &h);
+
+    for (i = 0; i < NUM_HAPPY_FACES; i++) {
+        faces[i].x = randomFloat(0.0f, w - HAPPY_FACE_SIZE);
+        faces[i].y = randomFloat(0.0f, h - HAPPY_FACE_SIZE);
+        faces[i].xvel = randomFloat(-60.0f, 60.0f);
+        faces[i].yvel = randomFloat(-60.0f, 60.0f);
+    }
+}
+
+void
+render(SDL_Renderer *renderer, double deltaTime)
+{
+    int i;
+    SDL_Rect srcRect;
+    SDL_Rect dstRect;
+    int w;
+    int h;
+
+    SDL_RenderGetLogicalSize(renderer, &w, &h);
+
+    /* setup boundaries for happyface bouncing */
+    int maxx = w - HAPPY_FACE_SIZE;
+    int maxy = h - HAPPY_FACE_SIZE;
+    int minx = 0;
+    int miny = 0;
+
+    /* setup rects for drawing */
+    srcRect.x = 0;
+    srcRect.y = 0;
+    srcRect.w = HAPPY_FACE_SIZE;
+    srcRect.h = HAPPY_FACE_SIZE;
+    dstRect.w = HAPPY_FACE_SIZE;
+    dstRect.h = HAPPY_FACE_SIZE;
+
+    /* fill background in with black */
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+    SDL_RenderClear(renderer);
+
+    /*
+       loop through all the happy faces:
+       - update position
+       - update velocity (if boundary is hit)
+       - draw
+     */
+    for (i = 0; i < NUM_HAPPY_FACES; i++) {
+        faces[i].x += faces[i].xvel * deltaTime;
+        faces[i].y += faces[i].yvel * deltaTime;
+        if (faces[i].x > maxx) {
+            faces[i].x = maxx;
+            faces[i].xvel = -faces[i].xvel;
+        } else if (faces[i].y > maxy) {
+            faces[i].y = maxy;
+            faces[i].yvel = -faces[i].yvel;
+        }
+        if (faces[i].x < minx) {
+            faces[i].x = minx;
+            faces[i].xvel = -faces[i].xvel;
+        } else if (faces[i].y < miny) {
+            faces[i].y = miny;
+            faces[i].yvel = -faces[i].yvel;
+        }
+        dstRect.x = faces[i].x;
+        dstRect.y = faces[i].y;
+        SDL_RenderCopy(renderer, texture, &srcRect, &dstRect);
+    }
+    /* update screen */
+    SDL_RenderPresent(renderer);
+
+}
+
+/*
+    loads the happyface graphic into a texture
+*/
+void
+initializeTexture(SDL_Renderer *renderer)
+{
+    SDL_Surface *bmp_surface;
+    /* load the bmp */
+    bmp_surface = SDL_LoadBMP("icon.bmp");
+    if (bmp_surface == NULL) {
+        fatalError("could not load bmp");
+    }
+    /* set white to transparent on the happyface */
+    SDL_SetColorKey(bmp_surface, 1,
+                    SDL_MapRGB(bmp_surface->format, 255, 255, 255));
+
+    /* convert RGBA surface to texture */
+    texture = SDL_CreateTextureFromSurface(renderer, bmp_surface);
+    if (texture == 0) {
+        fatalError("could not create texture");
+    }
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+
+    /* free up allocated memory */
+    SDL_FreeSurface(bmp_surface);
+}
+
+int
+main(int argc, char *argv[])
+{
+    SDL_Window *window;
+    SDL_Renderer *renderer;
+    int done;
+    int width;
+    int height;
+
+    /* initialize SDL */
+    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+        fatalError("Could not initialize SDL");
+    }
+
+    /* The specified window size doesn't matter - except for its aspect ratio,
+     * which determines whether the window is in portrait or landscape on iOS
+     * (if SDL_WINDOW_RESIZABLE isn't specified). */
+    window = SDL_CreateWindow(NULL, 0, 0, 320, 480, SDL_WINDOW_FULLSCREEN | SDL_WINDOW_ALLOW_HIGHDPI);
+
+    renderer = SDL_CreateRenderer(window, -1, 0);
+
+    SDL_GetWindowSize(window, &width, &height);
+    SDL_RenderSetLogicalSize(renderer, width, height);
+
+    initializeTexture(renderer);
+    initializeHappyFaces(renderer);
+
+
+    /* main loop */
+    done = 0;
+    while (!done) {
+        SDL_Event event;
+        double deltaTime = updateDeltaTime();
+
+        while (SDL_PollEvent(&event)) {
+            if (event.type == SDL_QUIT) {
+                done = 1;
+            }
+        }
+
+        render(renderer, deltaTime);
+        SDL_Delay(1);
+    }
+
+    /* cleanup */
+    SDL_DestroyTexture(texture);
+    /* shutdown SDL */
+    SDL_Quit();
+
+    return 0;
+
+}

data/ext/alphatau/native/sdl/Xcode-iOS/Demos/src/keyboard.c

@@ -0,0 +1,301 @@
+/*
+ *  keyboard.c
+ *  written by Holmes Futrell
+ *  use however you want
+ */
+
+#include "SDL.h"
+#include "common.h"
+
+#define TEST_INPUT_RECT
+
+#define GLYPH_SIZE_IMAGE 16     /* size of glyphs (characters) in the bitmap font file */
+#define GLYPH_SIZE_SCREEN 32    /* size of glyphs (characters) as shown on the screen */
+
+#define MAX_CHARS 1024
+
+static SDL_Texture *texture; /* texture where we'll hold our font */
+
+static SDL_Renderer *renderer;
+static int numChars = 0;        /* number of characters we've typed so far */
+static SDL_Color bg_color = { 50, 50, 100, 255 };       /* color of background */
+
+static int glyphs[MAX_CHARS];
+
+/* this structure maps a scancode to an index in our bitmap font.
+   it also contains data about under which modifiers the mapping is valid
+   (for example, we don't want shift + 1 to produce the character '1',
+   but rather the character '!')
+*/
+typedef struct
+{
+    SDL_Scancode scancode;      /* scancode of the key we want to map */
+    int allow_no_mod;           /* is the map valid if the key has no modifiers? */
+    SDL_Keymod mod;             /* what modifiers are allowed for the mapping */
+    int index;                  /* what index in the font does the scancode map to */
+} fontMapping;
+
+#define TABLE_SIZE 51           /* size of our table which maps keys and modifiers to font indices */
+
+/* Below is the table that defines the mapping between scancodes and modifiers to indices in the
+   bitmap font.  As an example, then line '{ SDL_SCANCODE_A, 1, KMOD_SHIFT, 33 }' means, map
+   the key A (which has scancode SDL_SCANCODE_A) to index 33 in the font (which is a picture of an A),
+   The '1' means that the mapping is valid even if there are no modifiers, and KMOD_SHIFT means the
+   mapping is also valid if the user is holding shift.
+*/
+fontMapping map[TABLE_SIZE] = {
+
+    {SDL_SCANCODE_A, 1, KMOD_SHIFT, 33},        /* A */
+    {SDL_SCANCODE_B, 1, KMOD_SHIFT, 34},        /* B */
+    {SDL_SCANCODE_C, 1, KMOD_SHIFT, 35},        /* C */
+    {SDL_SCANCODE_D, 1, KMOD_SHIFT, 36},        /* D */
+    {SDL_SCANCODE_E, 1, KMOD_SHIFT, 37},        /* E */
+    {SDL_SCANCODE_F, 1, KMOD_SHIFT, 38},        /* F */
+    {SDL_SCANCODE_G, 1, KMOD_SHIFT, 39},        /* G */
+    {SDL_SCANCODE_H, 1, KMOD_SHIFT, 40},        /* H */
+    {SDL_SCANCODE_I, 1, KMOD_SHIFT, 41},        /* I */
+    {SDL_SCANCODE_J, 1, KMOD_SHIFT, 42},        /* J */
+    {SDL_SCANCODE_K, 1, KMOD_SHIFT, 43},        /* K */
+    {SDL_SCANCODE_L, 1, KMOD_SHIFT, 44},        /* L */
+    {SDL_SCANCODE_M, 1, KMOD_SHIFT, 45},        /* M */
+    {SDL_SCANCODE_N, 1, KMOD_SHIFT, 46},        /* N */
+    {SDL_SCANCODE_O, 1, KMOD_SHIFT, 47},        /* O */
+    {SDL_SCANCODE_P, 1, KMOD_SHIFT, 48},        /* P */
+    {SDL_SCANCODE_Q, 1, KMOD_SHIFT, 49},        /* Q */
+    {SDL_SCANCODE_R, 1, KMOD_SHIFT, 50},        /* R */
+    {SDL_SCANCODE_S, 1, KMOD_SHIFT, 51},        /* S */
+    {SDL_SCANCODE_T, 1, KMOD_SHIFT, 52},        /* T */
+    {SDL_SCANCODE_U, 1, KMOD_SHIFT, 53},        /* U */
+    {SDL_SCANCODE_V, 1, KMOD_SHIFT, 54},        /* V */
+    {SDL_SCANCODE_W, 1, KMOD_SHIFT, 55},        /* W */
+    {SDL_SCANCODE_X, 1, KMOD_SHIFT, 56},        /* X */
+    {SDL_SCANCODE_Y, 1, KMOD_SHIFT, 57},        /* Y */
+    {SDL_SCANCODE_Z, 1, KMOD_SHIFT, 58},        /* Z */
+    {SDL_SCANCODE_0, 1, 0, 16}, /* 0 */
+    {SDL_SCANCODE_1, 1, 0, 17}, /* 1 */
+    {SDL_SCANCODE_2, 1, 0, 18}, /* 2 */
+    {SDL_SCANCODE_3, 1, 0, 19}, /* 3 */
+    {SDL_SCANCODE_4, 1, 0, 20}, /* 4 */
+    {SDL_SCANCODE_5, 1, 0, 21}, /* 5 */
+    {SDL_SCANCODE_6, 1, 0, 22}, /* 6 */
+    {SDL_SCANCODE_7, 1, 0, 23}, /* 7 */
+    {SDL_SCANCODE_8, 1, 0, 24}, /* 8 */
+    {SDL_SCANCODE_9, 1, 0, 25}, /* 9 */
+    {SDL_SCANCODE_SPACE, 1, 0, 0},      /* ' ' */
+    {SDL_SCANCODE_1, 0, KMOD_SHIFT, 1}, /* ! */
+    {SDL_SCANCODE_SLASH, 0, KMOD_SHIFT, 31},    /* ? */
+    {SDL_SCANCODE_SLASH, 1, 0, 15},     /* / */
+    {SDL_SCANCODE_COMMA, 1, 0, 12},     /* , */
+    {SDL_SCANCODE_SEMICOLON, 1, 0, 27}, /* ; */
+    {SDL_SCANCODE_SEMICOLON, 0, KMOD_SHIFT, 26},        /* : */
+    {SDL_SCANCODE_PERIOD, 1, 0, 14},    /* . */
+    {SDL_SCANCODE_MINUS, 1, 0, 13},     /* - */
+    {SDL_SCANCODE_EQUALS, 0, KMOD_SHIFT, 11},   /* = */
+    {SDL_SCANCODE_APOSTROPHE, 1, 0, 7}, /* ' */
+    {SDL_SCANCODE_APOSTROPHE, 0, KMOD_SHIFT, 2},        /* " */
+    {SDL_SCANCODE_5, 0, KMOD_SHIFT, 5}, /* % */
+
+};
+
+/*
+    This function maps an SDL_KeySym to an index in the bitmap font.
+    It does so by scanning through the font mapping table one entry
+    at a time.
+
+    If a match is found (scancode and allowed modifiers), the proper
+    index is returned.
+
+    If there is no entry for the key, -1 is returned
+*/
+int
+keyToGlyphIndex(SDL_Keysym key)
+{
+    int i, index = -1;
+    for (i = 0; i < TABLE_SIZE; i++) {
+        fontMapping compare = map[i];
+        if (key.scancode == compare.scancode) {
+            /* if this entry is valid with no key mod and we have no keymod, or if
+               the key's modifiers are allowed modifiers for that mapping */
+            if ((compare.allow_no_mod && key.mod == 0)
+                || (key.mod & compare.mod)) {
+                index = compare.index;
+                break;
+            }
+        }
+    }
+    return index;
+}
+
+/*
+    This function returns and x,y position for a given character number.
+    It is used for positioning each character of text
+*/
+void
+getPositionForCharNumber(int n, int *x, int *y)
+{
+    int renderW, renderH;
+    SDL_RenderGetLogicalSize(renderer, &renderW, &renderH);
+
+    int x_padding = 16;         /* padding space on left and right side of screen */
+    int y_padding = 32;         /* padding space at top of screen */
+    /* figure out the number of characters that can fit horizontally across the screen */
+    int max_x_chars = (renderW - 2 * x_padding) / GLYPH_SIZE_SCREEN;
+    int line_separation = 5;    /* pixels between each line */
+    *x = (n % max_x_chars) * GLYPH_SIZE_SCREEN + x_padding;
+#ifdef TEST_INPUT_RECT
+    *y = renderH - GLYPH_SIZE_SCREEN;
+#else
+    *y = (n / max_x_chars) * (GLYPH_SIZE_SCREEN + line_separation) + y_padding;
+#endif
+}
+
+void
+drawGlyph(int glyph, int positionIndex)
+{
+    int x, y;
+    getPositionForCharNumber(positionIndex, &x, &y);
+    SDL_Rect srcRect = { GLYPH_SIZE_IMAGE * glyph, 0, GLYPH_SIZE_IMAGE, GLYPH_SIZE_IMAGE };
+    SDL_Rect dstRect = { x, y, GLYPH_SIZE_SCREEN, GLYPH_SIZE_SCREEN };
+    SDL_RenderCopy(renderer, texture, &srcRect, &dstRect);
+}
+
+/* this function loads our font into an SDL_Texture and returns the SDL_Texture  */
+SDL_Texture*
+loadFont(void)
+{
+    SDL_Surface *surface = SDL_LoadBMP("kromasky_16x16.bmp");
+
+    if (!surface) {
+        printf("Error loading bitmap: %s\n", SDL_GetError());
+        return 0;
+    } else {
+        /* set the transparent color for the bitmap font (hot pink) */
+        SDL_SetColorKey(surface, 1, SDL_MapRGB(surface->format, 238, 0, 252));
+        /* now we convert the surface to our desired pixel format */
+        int format = SDL_PIXELFORMAT_ABGR8888;  /* desired texture format */
+        Uint32 Rmask, Gmask, Bmask, Amask;      /* masks for desired format */
+        int bpp;                /* bits per pixel for desired format */
+        SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask,
+                                   &Amask);
+        SDL_Surface *converted =
+            SDL_CreateRGBSurface(0, surface->w, surface->h, bpp, Rmask, Gmask,
+                                 Bmask, Amask);
+        SDL_BlitSurface(surface, NULL, converted, NULL);
+        /* create our texture */
+        texture = SDL_CreateTextureFromSurface(renderer, converted);
+        if (texture == 0) {
+            printf("texture creation failed: %s\n", SDL_GetError());
+        } else {
+            /* set blend mode for our texture */
+            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+        }
+        SDL_FreeSurface(surface);
+        SDL_FreeSurface(converted);
+        return texture;
+    }
+}
+
+void
+draw()
+{
+    SDL_SetRenderDrawColor(renderer, bg_color.r, bg_color.g, bg_color.b, bg_color.a);
+    SDL_RenderClear(renderer);
+
+    for (int i = 0; i < numChars; i++) {
+        drawGlyph(glyphs[i], i);
+    }
+
+    drawGlyph(29, numChars); /* cursor is at index 29 in the bitmap font */
+
+    SDL_RenderPresent(renderer);
+}
+
+int
+main(int argc, char *argv[])
+{
+    SDL_Window *window;
+    SDL_Event event;            /* last event received */
+    SDL_Scancode scancode;      /* scancode of last key we pushed */
+    int width;
+    int height;
+    int done;
+    SDL_Rect textrect;
+
+    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+        printf("Error initializing SDL: %s", SDL_GetError());
+    }
+    /* create window */
+    window = SDL_CreateWindow("iOS keyboard test", 0, 0, 0, 0, SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+    /* create renderer */
+    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_PRESENTVSYNC);
+
+    SDL_GetWindowSize(window, &width, &height);
+    SDL_RenderSetLogicalSize(renderer, width, height);
+
+    /* load up our font */
+    loadFont();
+    
+    /* Show onscreen keyboard */
+#ifdef TEST_INPUT_RECT
+    textrect.x = 0;
+    textrect.y = height - GLYPH_SIZE_IMAGE;
+    textrect.w = width;
+    textrect.h = GLYPH_SIZE_IMAGE;
+    SDL_SetTextInputRect(&textrect);
+#endif
+    SDL_StartTextInput();
+
+    done = 0;
+    while (!done) {
+        while (SDL_PollEvent(&event)) {
+            switch (event.type) {
+            case SDL_QUIT:
+                done = 1;
+                break;
+            case SDL_WINDOWEVENT:
+                if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
+					width = event.window.data1;
+					height = event.window.data2;
+                    SDL_RenderSetLogicalSize(renderer, width, height);
+#ifdef TEST_INPUT_RECT
+                    textrect.x = 0;
+                    textrect.y = height - GLYPH_SIZE_IMAGE;
+                    textrect.w = width;
+                    textrect.h = GLYPH_SIZE_IMAGE;
+                    SDL_SetTextInputRect(&textrect);
+#endif
+                }
+                break;
+            case SDL_KEYDOWN:
+                if (event.key.keysym.scancode == SDL_SCANCODE_BACKSPACE) {
+                    if (numChars > 0) {
+                        numChars--;
+                    }
+                } else if (numChars + 1 < MAX_CHARS) {
+                    int index = keyToGlyphIndex(event.key.keysym);
+                    if (index >= 0) {
+                        glyphs[numChars++] = index;
+                    }
+                }
+                break;
+            case SDL_MOUSEBUTTONUP:
+                /* mouse up toggles onscreen keyboard visibility */
+                if (SDL_IsTextInputActive()) {
+                    SDL_StopTextInput();
+                } else {
+                    SDL_StartTextInput();
+                }
+                break;
+            }
+        }
+
+        draw();
+        SDL_Delay(15);
+    }
+
+    SDL_DestroyTexture(texture);
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+    return 0;
+}