/* color-mods.c ... */ /* * This example creates an SDL window and renderer, and then draws some * textures to it every frame, adjusting their color. * * This code is public domain. Feel free to use it for any purpose! */ #define SDL_MAIN_USE_CALLBACKS 1 /* use the callbacks instead of main() */ #include <SDL3/SDL.h> #include <SDL3/SDL_main.h> /* We will use this renderer to draw into this window every frame. */ static SDL_Window *window = NULL; static SDL_Renderer *renderer = NULL; static SDL_Texture *texture = NULL; static int texture_width = 0; static int texture_height = 0; #define WINDOW_WIDTH 640 #define WINDOW_HEIGHT 480 /* This function runs once at startup. */ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) { SDL_Surface *surface = NULL; char *bmp_path = NULL; SDL_SetAppMetadata("Example Renderer Color Mods", "1.0", "com.example.renderer-color-mods"); if (!SDL_Init(SDL_INIT_VIDEO)) { SDL_Log("Couldn't initialize SDL: %s", SDL_GetError()); return SDL_APP_FAILURE; } if (!SDL_CreateWindowAndRenderer("examples/renderer/color-mods", WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer)) { SDL_Log("Couldn't create window/renderer: %s", SDL_GetError()); return SDL_APP_FAILURE; } /* Textures are pixel data that we upload to the video hardware for fast drawing. Lots of 2D engines refer to these as "sprites." We'll do a static texture (upload once, draw many times) with data from a bitmap file. */ /* SDL_Surface is pixel data the CPU can access. SDL_Texture is pixel data the GPU can access. Load a .bmp into a surface, move it to a texture from there. */ SDL_asprintf(&bmp_path, "%ssample.bmp", SDL_GetBasePath()); /* allocate a string of the full file path */ surface = SDL_LoadBMP(bmp_path); if (!surface) { SDL_Log("Couldn't load bitmap: %s", SDL_GetError()); return SDL_APP_FAILURE; } SDL_free(bmp_path); /* done with this, the file is loaded. */ texture_width = surface->w; texture_height = surface->h; texture = SDL_CreateTextureFromSurface(renderer, surface); if (!texture) { SDL_Log("Couldn't create static texture: %s", SDL_GetError()); return SDL_APP_FAILURE; } SDL_DestroySurface(surface); /* done with this, the texture has a copy of the pixels now. */ return SDL_APP_CONTINUE; /* carry on with the program! */ } /* This function runs when a new event (mouse input, keypresses, etc) occurs. */ SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) { if (event->type == SDL_EVENT_QUIT) { return SDL_APP_SUCCESS; /* end the program, reporting success to the OS. */ } return SDL_APP_CONTINUE; /* carry on with the program! */ } /* This function runs once per frame, and is the heart of the program. */ SDL_AppResult SDL_AppIterate(void *appstate) { SDL_FRect dst_rect; const double now = ((double)SDL_GetTicks()) / 1000.0; /* convert from milliseconds to seconds. */ /* choose the modulation values for the center texture. The sine wave trick makes it fade between colors smoothly. */ const float red = (float) (0.5 + 0.5 * SDL_sin(now)); const float green = (float) (0.5 + 0.5 * SDL_sin(now + SDL_PI_D * 2 / 3)); const float blue = (float) (0.5 + 0.5 * SDL_sin(now + SDL_PI_D * 4 / 3)); /* as you can see from this, rendering draws over whatever was drawn before it. */ SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE); /* black, full alpha */ SDL_RenderClear(renderer); /* start with a blank canvas. */ /* Just draw the static texture a few times. You can think of it like a stamp, there isn't a limit to the number of times you can draw with it. */ /* Color modulation multiplies each pixel's red, green, and blue intensities by the mod values, so multiplying by 1.0f will leave a color intensity alone, 0.0f will shut off that color completely, etc. */ /* top left; let's make this one blue! */ dst_rect.x = 0.0f; dst_rect.y = 0.0f; dst_rect.w = (float) texture_width; dst_rect.h = (float) texture_height; SDL_SetTextureColorModFloat(texture, 0.0f, 0.0f, 1.0f); /* kill all red and green. */ SDL_RenderTexture(renderer, texture, NULL, &dst_rect); /* center this one, and have it cycle through red/green/blue modulations. */ dst_rect.x = ((float) (WINDOW_WIDTH - texture_width)) / 2.0f; dst_rect.y = ((float) (WINDOW_HEIGHT - texture_height)) / 2.0f; dst_rect.w = (float) texture_width; dst_rect.h = (float) texture_height; SDL_SetTextureColorModFloat(texture, red, green, blue); SDL_RenderTexture(renderer, texture, NULL, &dst_rect); /* bottom right; let's make this one red! */ dst_rect.x = (float) (WINDOW_WIDTH - texture_width); dst_rect.y = (float) (WINDOW_HEIGHT - texture_height); dst_rect.w = (float) texture_width; dst_rect.h = (float) texture_height; SDL_SetTextureColorModFloat(texture, 1.0f, 0.0f, 0.0f); /* kill all green and blue. */ SDL_RenderTexture(renderer, texture, NULL, &dst_rect); SDL_RenderPresent(renderer); /* put it all on the screen! */ return SDL_APP_CONTINUE; /* carry on with the program! */ } /* This function runs once at shutdown. */ void SDL_AppQuit(void *appstate, SDL_AppResult result) { SDL_DestroyTexture(texture); /* SDL will clean up the window/renderer for us. */ }