|
| 1 | +/* affine-textures.c ... */ |
| 2 | + |
| 3 | +/* |
| 4 | +* This example creates an SDL window and renderer, and then draws a cube |
| 5 | +* using affine-transformed textures every frame. |
| 6 | +* |
| 7 | +* This code is public domain. Feel free to use it for any purpose! |
| 8 | +*/ |
| 9 | + |
| 10 | +#define SDL_MAIN_USE_CALLBACKS 1 /* use the callbacks instead of main() */ |
| 11 | +#include <SDL3/SDL.h> |
| 12 | +#include <SDL3/SDL_main.h> |
| 13 | + |
| 14 | +/* We will use this renderer to draw into this window every frame. */ |
| 15 | +static SDL_Window *window = NULL; |
| 16 | +static SDL_Renderer *renderer = NULL; |
| 17 | +static SDL_Texture *texture = NULL; |
| 18 | +static int texture_width = 0; |
| 19 | +static int texture_height = 0; |
| 20 | + |
| 21 | +#define WINDOW_WIDTH 640 |
| 22 | +#define WINDOW_HEIGHT 480 |
| 23 | + |
| 24 | +/* This function runs once at startup. */ |
| 25 | +SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) |
| 26 | +{ |
| 27 | + SDL_Surface *surface = NULL; |
| 28 | + char *bmp_path = NULL; |
| 29 | + |
| 30 | + SDL_SetAppMetadata("Example Renderer Affine Textures", "1.0", "com.example.renderer-affine-textures"); |
| 31 | + |
| 32 | + if (!SDL_Init(SDL_INIT_VIDEO)) { |
| 33 | + SDL_Log("Couldn't initialize SDL: %s", SDL_GetError()); |
| 34 | + return SDL_APP_FAILURE; |
| 35 | + } |
| 36 | + |
| 37 | + if (!SDL_CreateWindowAndRenderer("examples/renderer/affine-textures", WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer)) { |
| 38 | + SDL_Log("Couldn't create window/renderer: %s", SDL_GetError()); |
| 39 | + return SDL_APP_FAILURE; |
| 40 | + } |
| 41 | + |
| 42 | + /* Textures are pixel data that we upload to the video hardware for fast drawing. Lots of 2D |
| 43 | + engines refer to these as "sprites." We'll do a static texture (upload once, draw many |
| 44 | + times) with data from a bitmap file. */ |
| 45 | + |
| 46 | + /* SDL_Surface is pixel data the CPU can access. SDL_Texture is pixel data the GPU can access. |
| 47 | + Load a .bmp into a surface, move it to a texture from there. */ |
| 48 | + SDL_asprintf(&bmp_path, "%ssample.bmp", SDL_GetBasePath()); /* allocate a string of the full file path */ |
| 49 | + surface = SDL_LoadBMP(bmp_path); |
| 50 | + if (!surface) { |
| 51 | + SDL_Log("Couldn't load bitmap: %s", SDL_GetError()); |
| 52 | + return SDL_APP_FAILURE; |
| 53 | + } |
| 54 | + |
| 55 | + SDL_free(bmp_path); /* done with this, the file is loaded. */ |
| 56 | + |
| 57 | + texture_width = surface->w; |
| 58 | + texture_height = surface->h; |
| 59 | + |
| 60 | + texture = SDL_CreateTextureFromSurface(renderer, surface); |
| 61 | + if (!texture) { |
| 62 | + SDL_Log("Couldn't create static texture: %s", SDL_GetError()); |
| 63 | + return SDL_APP_FAILURE; |
| 64 | + } |
| 65 | + |
| 66 | + SDL_DestroySurface(surface); /* done with this, the texture has a copy of the pixels now. */ |
| 67 | + |
| 68 | + return SDL_APP_CONTINUE; /* carry on with the program! */ |
| 69 | +} |
| 70 | + |
| 71 | +/* This function runs when a new event (mouse input, keypresses, etc) occurs. */ |
| 72 | +SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) |
| 73 | +{ |
| 74 | + if (event->type == SDL_EVENT_QUIT) { |
| 75 | + return SDL_APP_SUCCESS; /* end the program, reporting success to the OS. */ |
| 76 | + } |
| 77 | + return SDL_APP_CONTINUE; /* carry on with the program! */ |
| 78 | +} |
| 79 | + |
| 80 | +/* This function runs once per frame, and is the heart of the program. */ |
| 81 | +SDL_AppResult SDL_AppIterate(void *appstate) |
| 82 | +{ |
| 83 | + const float x0 = 0.5f * WINDOW_WIDTH; |
| 84 | + const float y0 = 0.5f * WINDOW_HEIGHT; |
| 85 | + const float px = SDL_min(WINDOW_WIDTH, WINDOW_HEIGHT) / SDL_sqrtf(3.0f); |
| 86 | + |
| 87 | + const Uint64 now = SDL_GetTicks(); |
| 88 | + const float rad = (((float) ((int) (now % 2000))) / 2000.0f) * SDL_PI_F * 2; |
| 89 | + const float cos = SDL_cosf(rad); |
| 90 | + const float sin = SDL_sinf(rad); |
| 91 | + const float k[3] = { 3.0f / SDL_sqrtf(50.0f), 4.0f / SDL_sqrtf(50.0f), 5.0f / SDL_sqrtf(50.0f)}; |
| 92 | + float mat[9] = { |
| 93 | + cos + (1.0f-cos)*k[0]*k[0], -sin*k[2] + (1.0f-cos)*k[0]*k[1], sin*k[1] + (1.0f-cos)*k[0]*k[2], |
| 94 | + sin*k[2] + (1.0f-cos)*k[0]*k[1], cos + (1.0f-cos)*k[1]*k[1], -sin*k[0] + (1.0f-cos)*k[1]*k[2], |
| 95 | + -sin*k[1] + (1.0f-cos)*k[0]*k[2], sin*k[0] + (1.0f-cos)*k[1]*k[2], cos + (1.0f-cos)*k[2]*k[2], |
| 96 | + }; |
| 97 | + |
| 98 | + float corners[16]; |
| 99 | + int i; |
| 100 | + |
| 101 | + for (i = 0; i < 8; i++) { |
| 102 | + const float x = (i & 1) ? -0.5f : 0.5f; |
| 103 | + const float y = (i & 2) ? -0.5f : 0.5f; |
| 104 | + const float z = (i & 4) ? -0.5f : 0.5f; |
| 105 | + corners[0 + 2*i] = mat[0]*x + mat[1]*y + mat[2]*z; |
| 106 | + corners[1 + 2*i] = mat[3]*x + mat[4]*y + mat[5]*z; |
| 107 | + } |
| 108 | + |
| 109 | + SDL_SetRenderDrawColor(renderer, 0x42, 0x87, 0xf5, SDL_ALPHA_OPAQUE); // light blue background. |
| 110 | + SDL_RenderClear(renderer); |
| 111 | + |
| 112 | + for (i = 1; i < 7; i++) { |
| 113 | + const int dir = 3 & ((i & 4) ? ~i : i); |
| 114 | + const int odd = (i & 1) ^ ((i & 2) >> 1) ^ ((i & 4) >> 2); |
| 115 | + if (0 < (odd ? 1.0f : -1.0f) * mat[5 + dir]) continue; |
| 116 | + int origin_index = (1 << ((dir - 1) % 3)); |
| 117 | + int right_index = (1 << ((dir + odd) % 3)) | origin_index; |
| 118 | + int down_index = (1 << ((dir + (odd^1)) % 3)) | origin_index; |
| 119 | + if (!odd) { |
| 120 | + origin_index ^= 7; |
| 121 | + right_index ^= 7; |
| 122 | + down_index ^= 7; |
| 123 | + } |
| 124 | + SDL_FPoint origin, right, down; |
| 125 | + origin.x = x0 + px*corners[0 + 2*origin_index]; |
| 126 | + origin.y = y0 + px*corners[1 + 2*origin_index]; |
| 127 | + right.x = x0 + px*corners[0 + 2*right_index]; |
| 128 | + right.y = y0 + px*corners[1 + 2*right_index]; |
| 129 | + down.x = x0 + px*corners[0 + 2*down_index]; |
| 130 | + down.y = y0 + px*corners[1 + 2*down_index]; |
| 131 | + SDL_RenderTextureAffine(renderer, texture, NULL, &origin, &right, &down); |
| 132 | + } |
| 133 | + |
| 134 | + SDL_RenderPresent(renderer); |
| 135 | + |
| 136 | + return SDL_APP_CONTINUE; |
| 137 | +} |
| 138 | + |
| 139 | +/* This function runs once at shutdown. */ |
| 140 | +void SDL_AppQuit(void *appstate, SDL_AppResult result) |
| 141 | +{ |
| 142 | + SDL_DestroyTexture(texture); |
| 143 | + /* SDL will clean up the window/renderer for us. */ |
| 144 | +} |
| 145 | + |
0 commit comments