Implement bitmap scaling

include/bitmap.h

@@ -1,12 +1,20 @@
 #ifndef BITMAP_H
 #define BITMAP_H
 
+#include "rect.h"
+
 #include <stddef.h>
 
 struct bitmap {
   void *data;
   size_t width;
   size_t height;
+  struct blitmap *cache;
+};
+
+struct blitmap {
+  void *data;
+  int bpp;
 };
 
 struct bitmap bitmap_load_readable (const char *path);
@@ -23,4 +31,9 @@ void bitmap_write_bit (struct bitmap bitmap, size_t x, size_t y, char bit);
 
 void bitmap_discard (struct bitmap bitmap);
 
+void bitmap_load_blitmap (struct bitmap *bitmap, int bpp);
+void blitmap_discard (struct blitmap blitmap);
+
+struct rect bitmap_to_rect (const struct bitmap bitmap, float scale);
+
 #endif

include/charmap.h

@@ -24,6 +24,6 @@ void charmap_unload (struct charmap map);
 struct charmap_meta charmap_load_all (const char *root, const char *meta);
 void charmap_unload_all (struct charmap_meta meta);
 
-const struct charmap * charmap_find (struct charmap_meta meta, char mapping);
+struct charmap * charmap_find (struct charmap_meta meta, char mapping);
 
 #endif

include/gfx.h

@@ -6,9 +6,16 @@
 #include "bitmap.h"
 
 #include <stdbool.h>
+#include <stdint.h>
 
 #define BUFFER_SIZE(screen) (((screen).dims.width) * ((screen).dims.height) * ((screen).dims.bpp))
 
+#define BLIT_F_DECL(type) void fblit_ ## type (type *pixelBuf, size_t width, struct point start, struct bitmap *content, type color, float scale);
+#define BLIT_N_DECL(type) void iblit_ ## type (type *pixelBuf, size_t width, struct point start, struct bitmap *content, type color);
+#define BLIT_DECL(type) \
+  BLIT_F_DECL(type)\
+  BLIT_N_DECL(type)
+
 struct screen_dims {
   int width;
   int height;
@@ -29,6 +36,12 @@ struct triangle {
   struct point p3;
 };
 
+
+BLIT_DECL(uint8_t)
+BLIT_DECL(uint16_t)
+BLIT_DECL(uint32_t)
+BLIT_DECL(uint64_t)
+
 void draw_pixel (void *pixelBuf, int pixel, int bpp);
 
 void draw_rect (struct screen screen, struct rect rect, int color);

include/rect.h

@@ -33,7 +33,8 @@
 //  int _h = RECT_HEIGHT((r));\
 //  RECT_ALIGN_TL((r), (_x) - (_w / 2), (_y) - (_h / 2));\
 //}
-#define RECT_CENTER(r, _x, _y) RECT_ALIGN_TL((r), (_x) - (RECT_WIDTH((r)) / 2), (_y) - (RECT_HEIGHT((r)) / 2))
+#define RECT_CENTER(r, _x, _y, scl) RECT_ALIGN_TL((r), (_x) - (int)(RECT_WIDTH(r) * scl / 2.0f), (_y) - (int)(RECT_HEIGHT(r) * scl / 2.0f))
+//#define RECT_CENTER(r, _x, _y) RECT_ALIGN_TL((r), (_x) - (RECT_WIDTH((r)) / 2), (_y) - (RECT_HEIGHT((r)) / 2))
 #define RECT_STRETCH(r, _x, _y) {\
   (r).br.x += (_x);\
   (r).tl.x -= (_x);\

src/bitmap.c

@@ -18,7 +18,8 @@ struct bitmap bitmap_load_readable (const char *path) {
   struct bitmap result = {
     NULL,
     0,
-    0
+    0,
+    NULL
   };
   int fd = open (path, O_RDONLY);
 
@@ -59,7 +60,8 @@ struct bitmap bitmap_load_raw (const char *path) {
   struct bitmap result = {
     NULL,
     0,
-    0
+    0,
+    NULL
   };
   int fd = open (path, O_RDONLY);
 
@@ -102,7 +104,8 @@ struct bitmap bitmap_parse_readable (const char *data, int width, int height) {
   struct bitmap result = {
     NULL,
     0,
-    0
+    0,
+    NULL
   };
 
   int len = (width + 1) * height;
@@ -199,4 +202,44 @@ void bitmap_write_bit (struct bitmap bitmap, size_t x, size_t y, char bit) {
 
 void bitmap_discard (struct bitmap bitmap) {
   free (bitmap.data);
+  bitmap.data = NULL;
+
+  if (bitmap.cache) {
+    blitmap_discard (*bitmap.cache);
+    free (bitmap.cache);
+    bitmap.cache = NULL;
+  }
+}
+
+void bitmap_load_blitmap (struct bitmap *bitmap, int bpp) {
+  // Check if an existing blit-map can be reused
+  if (bitmap->cache) {
+    if (bitmap->cache->bpp == bpp)
+      return;
+
+    // Discard old cached blit map an generate a new one
+    blitmap_discard (*bitmap->cache);
+  }
+
+  bitmap->cache = malloc (sizeof (struct blitmap));
+  bitmap->cache->data = malloc (bitmap->width * bitmap->height * bpp);
+  bitmap->cache->bpp = bpp;
+
+  for (int y = 0; y < bitmap->height; ++y)
+    for (int x = 0; x < bitmap->width; ++x)
+      memset (
+          bitmap->cache->data + (x + y * bitmap->width) * bpp,
+          bitmap_read_bit(*bitmap, x, y) ? 0x00 : 0xFF,
+          bpp
+      );
+}
+
+void blitmap_discard (struct blitmap blitmap) {
+  free (blitmap.data);
+  blitmap.data = NULL;
+}
+
+struct rect bitmap_to_rect (const struct bitmap bitmap, float scale) {
+  struct rect result = RECT((int)(bitmap.width * scale), (int)(bitmap.height * scale));
+  return result;
 }

src/charmap.c

@@ -121,7 +121,7 @@ struct charmap_meta charmap_load_all (const char *root, const char *meta_file) {
   return meta;
 }
 
-const struct charmap * charmap_find (struct charmap_meta meta, char mapping) {
+struct charmap * charmap_find (struct charmap_meta meta, char mapping) {
   if ((meta.mapped[mapping >> 3] >> (mapping & 7)) & 1) {
     for (int i = 0; i < meta.map_count; ++i)
       if (meta.maps[i].c == mapping)

src/draw.c

@@ -9,33 +9,6 @@
 #include <unistd.h>
 
 
-//void hide_tty0_cursor() {
-//  FILE *file = fopen ("/dev/tty0", "w");
-//  if (file != NULL) {
-//    fputs ("\e[?25l", file);
-//
-//    fclose (file);
-//  }
-//}
-//
-//void show_tty0_cursor() {
-//  FILE *file = fopen ("/dev/tty0", "w");
-//  if (file != NULL) {
-//    fputs ("\e[?25h", file);
-//
-//    fclose (file);
-//  }
-//}
-
-struct rect center_offset (struct rect to_center, struct point center_on) {
-  struct rect result = {
-    { center_on.x - ((to_center.br.x - to_center.tl.x) / 2), center_on.y - ((to_center.br.y - to_center.tl.y) / 2) },
-    { center_on.x + ((to_center.br.x - to_center.tl.y) / 2), center_on.y + ((to_center.br.y - to_center.tl.y) / 2) }
-  };
-
-  return result;
-}
-
 int main()
 {
   struct screen screen = open_screen ();
@@ -45,17 +18,20 @@ int main()
 
 
   struct charmap_meta meta = charmap_load_all ("res/", "maps.meta");
-  const struct charmap *map_0 = charmap_find (meta, '0');
+  struct charmap *map_0 = charmap_find (meta, '0');
-  const struct charmap *map_1 = charmap_find (meta, '1');
+  struct charmap *map_1 = charmap_find (meta, '1');
 
   // Virtual rectangle representing character
   struct rect rect_0_virt = RECT(map_0->bitmap.width, map_0->bitmap.height);
-  RECT_CENTER(rect_0_virt, screen.dims.width / 2, screen.dims.height / 2);
+  RECT_CENTER(rect_0_virt, screen.dims.width / 2, screen.dims.height / 2, 2);
+
+  struct rect rect_1_virt = RECT(map_1->bitmap.width, map_1->bitmap.height);
+  RECT_CENTER(rect_1_virt, screen.dims.width / 2, screen.dims.height / 2, 2);
 
 
   // Make a 100x100 rectangle and center it in on the screen
   struct rect window = RECT(100, 100);
-  RECT_CENTER(window, screen.dims.width / 2, screen.dims.height / 2);
+  RECT_CENTER(window, screen.dims.width / 2, screen.dims.height / 2, 1);
   
 
   // Clear screen
@@ -68,18 +44,28 @@ int main()
       draw_rect_b (screen, window, 0x00);
       RECT_STRETCH (window, stretch, stretch);
       draw_rect_b (screen, window, 0xFF);
-      draw_bitmap (screen, (stretch - 1 ? map_0 : map_1)->bitmap, rect_0_virt.tl, 0x0000, true);
+
+      fblit_uint16_t (screen.buffer, screen.dims.width, (stretch - 1 ? rect_0_virt : rect_1_virt).tl, &(stretch - 1 ? map_0 : map_1)->bitmap, 0x0000, 2.0f);
+      //draw_bitmap (screen, (stretch - 1 ? map_0 : map_1)->bitmap, rect_0_virt.tl, 0x0000, true);
 
       screen_commit (screen);
-      usleep (5000);
+      //usleep (5000);
     }
   }
 
-  struct point tl = {100, 100};
+  float scale = 1.0f;
+  struct point previous_end = {100, 100};
 
   for (int i = 0; i < 10; ++i) {
-    draw_bitmap (screen, map_0->bitmap, tl, 0xFFFF, true);
+    struct rect bounds = bitmap_to_rect (map_0->bitmap, scale);
-    tl.x += (int)(map_0->bitmap.width * 1.5f);
+
+    bounds.tl.x += 100 + previous_end.x;
+    bounds.tl.y += 100 - (int)(map_0->bitmap.height * scale / 2.0f);
+
+    previous_end.x += map_0->bitmap.width * scale + 5;
+
+    fblit_uint16_t (screen.buffer, screen.dims.width, bounds.tl, &map_0->bitmap, 0xFFFF, scale);
+    scale += 0.5f;
   }
 
   screen_commit (screen);

src/gfx.c

@@ -1,3 +1,5 @@
+// TODO: Implement dirty regions and selective buffer-to-buffer transfers
+
 #include "gfx.h"
 
 #include <string.h>
@@ -14,6 +16,49 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+// Fixed byte-per-pixel blit template implementations
+#define BLIT_F(type) \
+  void fblit_ ## type (type *pixelBuf, size_t width, struct point start, struct bitmap *content, type color, float scale) { \
+    bitmap_load_blitmap (content, sizeof (type));\
+    \
+    struct point end = {\
+      (int)(content->width * scale),\
+      (int)(content->height * scale)\
+    };\
+    \
+    type *cache = content->cache->data;\
+    float inc = 1.0f / scale;\
+    for (int y = 0; y < end.y; ++y)\
+      for (int x = 0; x < end.x; ++x) {\
+        type value = cache[(int)(x * inc) + ((int)(y * inc) * content->width)];\
+        pixelBuf[(start.x + x) + (start.y + y) * width] &= value;\
+        pixelBuf[(start.x + x) + (start.y + y) * width] |= color & ~value;\
+      }\
+  }
+
+#define BLIT_N(type) \
+  void iblit_ ## type (type *pixelBuf, size_t width, struct point start, struct bitmap *content, type color) { \
+    bitmap_load_blitmap (content, sizeof (type));\
+    \
+    struct point end = {\
+      start.x + content->width,\
+      start.y + content->height\
+    };\
+    \
+    type *cache = content->cache->data;\
+    for (int y = start.y; y < end.y; ++y)\
+      for (int x = start.x; x < end.x; ++x) {\
+        pixelBuf[x + y * width] &= *cache;\
+        pixelBuf[x + y * width] |= color & ~*cache;\
+        ++cache;\
+      }\
+  }
+
+#define BLIT(type) \
+  BLIT_F(type)\
+  BLIT_N(type)
+
+
 int to_index (int x, int y, struct screen_dims dims) {
   return (x * dims.bpp) + (y * dims.width * dims.bpp);
 }
@@ -22,6 +67,13 @@ void draw_pixel (void *pixelBuf, int pixel, int bpp) {
   memcpy (pixelBuf, &pixel, bpp);
 }
 
+
+// Quick blit implementations
+BLIT(uint8_t)
+BLIT(uint16_t)
+BLIT(uint32_t)
+BLIT(uint64_t)
+
 void draw_rect (struct screen screen, struct rect rect, int color) {
   for (int y = rect.tl.y; y < rect.br.y; ++y)
     for (int x = rect.tl.x; x < rect.br.x; ++x)
@@ -34,7 +86,6 @@ void draw_rect_b (struct screen screen, struct rect rect, int color) {
 }
 
 void draw_bitmap (struct screen screen, struct bitmap bitmap, struct point tl, int color, bool transparent_bg) {
-
   for (int y = 0; y < bitmap.height; ++y)
     for (int x = 0; x < bitmap.width; ++x) {
       char bit = bitmap_read_bit (bitmap, x, y);