Support scaling

deshipu · deshipu · commit de380072c0e9 · 2019-08-01T15:16:26.000+02:00
diff --git a/modules/stage/mod_stage.c b/modules/stage/mod_stage.c
@@ -302,7 +302,7 @@ inline
 void render_stage(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
         mp_obj_t *layers, size_t layers_size,
         uint16_t *buffer, size_t buffer_size,
-        mp_obj_t spi) {
+        mp_obj_t spi, uint8_t scale) {
 
     // TODO(deshipu): Do a collision check of each layer with the
     // rectangle, and only process the layers that overlap with it.
@@ -312,27 +312,31 @@ void render_stage(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
 
     size_t index = 0;
     for (uint16_t y = y0; y < y1; ++y) {
-        for (uint16_t x = x0; x < x1; ++x) {
-            for (size_t layer = 0; layer < layers_size; ++layer) {
+        for (uint8_t yscale = 0; yscale < scale; ++yscale) {
+            for (uint16_t x = x0; x < x1; ++x) {
                 uint16_t c = TRANSPARENT;
-                layer_obj_t *obj = MP_OBJ_TO_PTR(layers[layer]);
-                if (obj->base.type == &mp_type_layer) {
-                    c = get_layer_pixel(obj, x, y);
-                } else if (obj->base.type == &mp_type_text) {
-                    c = get_text_pixel((text_obj_t *)obj, x, y);
+                for (size_t layer = 0; layer < layers_size; ++layer) {
+                    layer_obj_t *obj = MP_OBJ_TO_PTR(layers[layer]);
+                    if (obj->base.type == &mp_type_layer) {
+                        c = get_layer_pixel(obj, x, y);
+                    } else if (obj->base.type == &mp_type_text) {
+                        c = get_text_pixel((text_obj_t *)obj, x, y);
+                    }
+                    if (c != TRANSPARENT) {
+                        break;
+                    }
                 }
-                if (c != TRANSPARENT) {
+                for (uint8_t xscale = 0; xscale < scale; ++xscale) {
                     buffer[index] = c;
-                    break;
+                    index += 1;
+                    // The buffer is full, send it.
+                    if (index >= buffer_size) {
+                        spi_p->transfer(s, buffer_size * 2,
+                                        (const uint8_t*)buffer, NULL);
+                        index = 0;
+                    }
                 }
             }
-            index += 1;
-            // The buffer is full, send it.
-            if (index >= buffer_size) {
-                spi_p->transfer(s, buffer_size * 2,
-                                (const uint8_t*)buffer, NULL);
-                index = 0;
-            }
         }
     }
     // Send the remaining data.
@@ -363,12 +367,17 @@ STATIC mp_obj_t stage_render(size_t n_args, const mp_obj_t *args) {
     if (type->protocol == NULL) {
          mp_raise_ValueError("SPI protocol required");
     }
+    uint8_t scale = 1;
+    if (n_args >= 8) {
+        scale = mp_obj_get_int(args[7]);
+    }
 
-    render_stage(x0, y0, x1, y1, layers, layers_size, buffer, buffer_size, spi);
+    render_stage(x0, y0, x1, y1, layers, layers_size,
+                 buffer, buffer_size, spi, scale);
 
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(stage_render_obj, 7, 7, stage_render);
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(stage_render_obj, 7, 8, stage_render);
 
 
 STATIC const mp_rom_map_elem_t stage_module_globals_table[] = {
diff --git a/stage.py b/stage.py
@@ -348,11 +348,12 @@ def clear(self):
 class Stage:
     buffer = bytearray(512)
 
-    def __init__(self, display, fps=6):
+    def __init__(self, display, fps=6, scale=1):
+        self.scale = scale
         self.layers = []
         self.display = display
-        self.width = display.width
-        self.height = display.height
+        self.width = display.width // scale
+        self.height = display.height // scale
         self.last_tick = utime.ticks_ms()
         self.tick_delay = 1000 // fps
 
@@ -371,8 +372,10 @@ def render_block(self, x0=0, y0=0, x1=None, y1=None):
             y1 = self.height
         layers = [l.layer for l in self.layers]
         with self.display as display:
-            display.block(x0, y0, x1 - 1, y1 - 1)
-            _stage.render(x0, y0, x1, y1, layers, self.buffer, display.spi)
+            display.block(x0 * self.scale, y0 * self.scale,
+                          x1 * self.scale - 1, y1 * self.scale - 1)
+            _stage.render(x0, y0, x1, y1, layers, self.buffer,
+                          display.spi, self.scale)
 
     def render_sprites(self, sprites):
         layers = [l.layer for l in self.layers]
@@ -388,6 +391,8 @@ def render_sprites(self, sprites):
                                 max(sprite.py, int(sprite.y)) + 16))
                 if x0 == x1 or y0 == y1:
                     continue
-                display.block(x0, y0, x1 - 1, y1 - 1)
-                _stage.render(x0, y0, x1, y1, layers, self.buffer, display.spi)
+                display.block(x0 * self.scale, y0 * self.scale,
+                              x1 * self.scale - 1, y1 * self.scale - 1)
+                _stage.render(x0, y0, x1, y1, layers, self.buffer,
+                              display.spi, self.scale)
                 sprite._updated()
