bitmap_blit.c

Go to the documentation of this file.

 
#include <banjo/app.h>
#include <banjo/main.h>
#include <banjo/bitmap.h>
#include <banjo/event.h>
#include <banjo/log.h>
#include <banjo/memory.h>
#include <banjo/system.h>
#include <banjo/window.h>
 
#define WINDOW_W 800
#define WINDOW_H 600
 
bj_window*   window        = 0;
bj_bitmap*   bmp_rendering = 0;
 
// The composed image is static: we just copy it to the framebuffer each
// time banjo asks us to repaint. dirty is ignored because we always blit
// the whole composite: drawing a sub-rect of an already-finished image
// has no perf advantage here, and Cocoa / Win32 clip to the dirty region
// for us at the OS level.
static void on_draw(
    struct bj_window*        w,
    struct bj_render_target* target,
    const struct bj_rect*    dirty,
    void*                    user_data
) {
    (void)w; (void)dirty; (void)user_data;
    bj_blit(bmp_rendering, 0, bj_render_target_bitmap(target), 0, BJ_BLIT_OP_COPY);
}
 
static void* setup(struct bj_app* app, void* init_data) {
    (void)init_data;
 
    // Create an off-screen bitmap to compose our final image. This is where
    // we'll blit all the source images before displaying the result.
    bmp_rendering = bj_create_bitmap(WINDOW_W, WINDOW_H, BJ_PIXEL_MODE_BGR24, 0);
    bj_set_bitmap_color(bmp_rendering, bj_make_bitmap_pixel(bmp_rendering, 0xFF, 0x00, 0x00), BJ_BITMAP_CLEAR_COLOR);
    bj_clear_bitmap(bmp_rendering);
 
    // Load source images that we'll composite together.
    bj_bitmap* bmp_blackbuck_512_512 = bj_create_bitmap_from_file(BANJO_ASSETS_DIR"/bmp/blackbuck.bmp", 0);
    bj_bitmap* bmp_greenland_grid_velo_762_1309 = bj_create_bitmap_from_file(BANJO_ASSETS_DIR"/bmp/greenland_grid_velo.bmp", 0);
    bj_bitmap* bmp_lena_512_512 = bj_create_bitmap_from_file(BANJO_ASSETS_DIR"/bmp/lena.bmp", 0);
    bj_bitmap* bmp_snail_256_256 = bj_create_bitmap_from_file(BANJO_ASSETS_DIR"/bmp/snail.bmp", 0);
 
    // bj_blit() copies a rectangular region from source to destination.
    // Parameters: source bitmap, source rect, dest bitmap, dest rect, operation
    //
    // Source rect defines what region to copy (x, y, width, height).
    // Dest rect only needs x, y for position (width/height from source rect).
    // BJ_BLIT_OP_COPY is a direct pixel copy with no blending.
    //
    // This is efficient for sprite rendering - load one sprite sheet and blit
    // individual frames or tiles as needed.
    bj_blit(bmp_greenland_grid_velo_762_1309, &(bj_rect){.x = 0, .y = 0, .w = 762, .h = 1309}, bmp_rendering, & (bj_rect){.x = 20, .y = 0}, BJ_BLIT_OP_COPY);
    bj_blit(bmp_blackbuck_512_512, &(bj_rect){.x = 100, .y = 100, .w = 512, .h = 512}, bmp_rendering, & (bj_rect){.x = 100, .y = 200}, BJ_BLIT_OP_COPY);
    bj_blit(bmp_snail_256_256, &(bj_rect){.x = 0, .y = 0, .w = 256, .h = 256}, bmp_rendering, & (bj_rect){.x = 500, .y = 130}, BJ_BLIT_OP_COPY);
 
    // Destroy source bitmaps after blitting. The pixels are copied, so we
    // don't need to keep the sources in memory.
    bj_destroy_bitmap(bmp_snail_256_256);
    bj_destroy_bitmap(bmp_lena_512_512);
    bj_destroy_bitmap(bmp_greenland_grid_velo_762_1309);
    bj_destroy_bitmap(bmp_blackbuck_512_512);
 
    if (!bj_begin(BJ_VIDEO_SYSTEM, 0)) {
        bj_quit_app(app, 1);
        return 0;
    }
 
    window = bj_bind_window("Blitmap Blit", 0, 0, WINDOW_W, WINDOW_H, 0, 0);
 
    bj_set_key_callback(bj_close_on_escape, 0);
    bj_set_draw_callback(window, on_draw, 0);
 
    // Ask banjo to fire the first paint. After that, the backend re-fires
    // the callback on its natural cadence whenever something invalidates.
    bj_invalidate_window(window);
    return 0;
}
 
static void step(struct bj_app* app, struct bj_tick_info tick, void* user_data) {
    (void)tick;
    (void)user_data;
    bj_dispatch_events();
    if (bj_should_close_window(window)) {
        bj_quit_app(app, 0);
    }
}
 
static void teardown(struct bj_app* app, void* user_data) {
    (void)user_data;
    bj_destroy_bitmap(bmp_rendering);
    bj_unbind_window(window);
    bj_end();
}
 
int main(int argc, char* argv[]) {
    (void)argc; (void)argv;
    return bj_run_app(setup, step, 0, teardown, 0);
}