cleanup

7 files changed, 55 insertions, 398 deletions

diff --git a/frontends/gl/2 b/frontends/gl/2
deleted file mode 100644
index af23c35..0000000
--- a/frontends/gl/2
+++ /dev/null
@@ -1,349 +0,0 @@
-#include <glad/glad.h>
-#include <stdio.h>
-
-#include "ui.h"
-#include "drawable.h"
-
-#define RES_SCALE 1.2
-
-void reset_current(cetris_ui *ui) {
-  for (int i = 0; i < 4; i++) {
-    new_rectangle(&ui->board.current[i]);
-    new_rectangle(&ui->board.ghost[i]);
-  }
-}
-
-void refresh_current(cetris_ui *ui) {
-  for (int i = 0; i < 4; i++) {
-    ui->board.current[i].visable = false;
-    ui->board.ghost[i].visable = false;
-  }
-}
-
-void load_tetris_board(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
-  board->block_width = w / (GLfloat)board->game.config.board_x;
-  board->block_height = h / board->game.config.board_visible;
-
-  board->x_offset = x;
-  board->y_offset = y;
-  board->block_offset = (board->game.config.board_y - board->game.config.board_visible);
-  
-  board->board_count = 0;
-  board->board = malloc(sizeof(drawable_t) * 100);
-  memset(board->board, 0, sizeof(drawable_t) * 100);
-
-  board->update_current = false;
-  board->lock_current = false;
-  board->refresh_board_current = false;
-
-  memset(&ui->board.current, 0, sizeof(drawable_t) * 4);
-  memset(&ui->board.ghost, 0, sizeof(drawable_t) * 4);
-  
-  refresh_current(ui);
-  reset_current(ui);
-
-  update_rect(&board->skin.playboard, board->x_offset, board->y_offset - 10 * RES_SCALE,
-      board->game.config.board_x * board->block_width,
-      (board->game.config.board_visible * board->block_height) + 10 * RES_SCALE,
-      ui->window_width, ui->window_height);
-
-  update_rect(&board->skin.border, board->x_offset - (110 * RES_SCALE), 
-      board->y_offset - (45 * RES_SCALE), 380 * RES_SCALE, 600 * RES_SCALE,
-      ui->window_width, ui->window_height);
-}
-
-void load_held_piece(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
-  board->held.block_width = w / 4.0f;
-  board->held.block_height = h / 4.0f;
-
-  board->held.x_offset = x;
-  board->held.y_offset = y;
-}
-
-void load_piece_queue(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
-  board->queue.block_width = w / 4.0f;
-  board->queue.block_height = w / 4.0f;
-
-  board->queue.h = h;
-  board->queue.w = w;
- 
-  board->queue.x_offset = x;
-  board->queue.y_offset = y;
-}
-
-// TODO: make this better
-void update_current_drawable(cetris_ui *ui, drawable_t *current, drawable_t* ghost) {
-  refresh_current(ui);
-  int cur_piece = -1;
-  for (int s = 0; s < 4; s++) {
-    for (int j = 0; j < 4; j++) {
-      if ((ui->board.game.current.m[s]>>(3 - j))&1) {
-        cur_piece++;
-
-        GLfloat block_x = 
-          ui->board.x_offset + 
-          (j + ui->board.game.current.pos.x) * ui->board.block_width;
-
-        if (ghost) {
-          GLfloat ghost_y = 
-            ui->board.y_offset + 
-            (s + ui->board.game.current.ghost_y - ui->board.block_offset) 
-            * ui->board.block_height;
-
-          ghost[cur_piece].visable = true;
-          set_block_texture(&ghost[cur_piece], ui->board.game.current.t + 7);
-          update_rect(&ghost[cur_piece], block_x, ghost_y, 
-              ui->board.block_width, ui->board.block_height,
-              ui->window_width, ui->window_height);
-        }
-
-        if (s + ui->board.game.current.pos.y < ui->board.block_offset - 1) continue;
-
-        GLfloat block_y = 
-          ui->board.y_offset + 
-          (s + ui->board.game.current.pos.y - ui->board.block_offset)
-          * ui->board.block_height;
-
-        current[cur_piece].visable = true;
-        set_block_texture(&current[cur_piece], ui->board.game.current.t);
-        update_rect(&current[cur_piece], block_x, block_y, 
-            ui->board.block_width, ui->board.block_height,
-            ui->window_width, ui->window_height);
-
-      }
-    }
-  }
-}
-
-void lock_current_drawable(cetris_ui *ui) {
-  for (int i = 0; i < 4; i++) {
-    new_rectangle(&ui->board.board[ui->board.board_count + i]);
-  }
-
-  int current = 0;
-  for (int s = 0; s < 4; s++) {
-    for (int j = 0; j < 4; j++) {
-      if ((ui->board.game.lock_event.m[s]>>(3 - j))&1) {
-        GLfloat block_x = 
-          ui->board.x_offset + 
-          (j + ui->board.game.lock_event.pos.x) * ui->board.block_width;
-
-        GLfloat block_y = 
-          ui->board.y_offset + 
-          (s + ui->board.game.lock_event.pos.y - ui->board.block_offset)
-          * ui->board.block_height;
-
-        set_block_texture(&ui->board.board[ui->board.board_count + current], ui->board.game.lock_event.t);
-        update_rect(&ui->board.board[ui->board.board_count + current], block_x, block_y, 
-            ui->board.block_width, ui->board.block_height,
-            ui->window_width, ui->window_height);
-
-        // TODO: fix this
-        ui->board.board[ui->board.board_count + current].y = ui->board.game.lock_event.pos.y + s;
-
-        ui->board.board_count++;
-      }
-    }
-  }
-
-  ui->board.game.lock_event.processed = true;
-}
-
-void refresh_board(cetris_ui *ui) {
-  ui->board.board_count = 0;
-  for (int s = 0; s < ui->board.game.config.board_x; s++) {
-    for (int j = 0; j < ui->board.game.config.board_y; j++) {
-      if (ui->board.game.board[s][y] & SLOT_OCCUPIED) {
-        GLfloat block_x = 
-          ui->board.x_offset + 
-          (j + ui->board.game.lock_event.pos.x) * ui->board.block_width;
-
-        GLfloat block_y = 
-          ui->board.y_offset + 
-          (s + ui->board.game.lock_event.pos.y - ui->board.block_offset)
-          * ui->board.block_height;
-
-        set_block_texture(&ui->board.board[ui->board.board_count], ui->board.game.lock_event.t);
-        update_rect(&ui->board.board[ui->board.board_count++], block_x, block_y, 
-            ui->board.block_width, ui->board.block_height,
-            ui->window_width, ui->window_height);
-      }
-    }
-  }
-}
-
-void draw_tetris_board(cetris_ui *ui) {
-  if (ui->board.update_current) {
-    update_current_drawable(ui, &ui->board.current[0], &ui->board.ghost[0]);
-    ui->board.update_current = false;
-  }
-
-  if (ui->board.lock_current) {
-    lock_current_drawable(ui);
-    ui->board.lock_current = false;
-  }
-
-  if (ui->board.refresh_board) {
-    refresh_board(ui);
-    ui->board.refresh_board = false;
-  }
-
-  if (ui->board.game.line_event_count > 0) {
-    for (int i = 0; i < ui->board.board_count; i++) {
-      for (int j = 0; j < ui->board.game.line_event_count; j++) {
-        if (ui->board.board[i].y == ui->board.game.line_event[j].y) {
-          for (int s = i; s < ui->board.board_count; s++) {
-            ui->board.board[s] = ui->board.board[s + 1];
-          }
-        }
-      }
-    }
-    ui->board.game.line_event_count = 0;
-  }
-
-  glActiveTexture(GL_TEXTURE0);
-
-  glBindTexture(GL_TEXTURE_2D, ui->board.skin.background.texture);
-  glBindVertexArray(ui->board.skin.background.vao);
-  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-
-  glBindTexture(GL_TEXTURE_2D, 0); 
-
-  glBindTexture(GL_TEXTURE_2D, ui->board.skin.playboard.texture);
-  glBindVertexArray(ui->board.skin.playboard.vao);
-  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-
-  glBindTexture(GL_TEXTURE_2D, 0);
-
-  glBindTexture(GL_TEXTURE_2D, ui->board.skin.overlay.texture);
-  glBindVertexArray(ui->board.skin.overlay.vao);
-
-  for (int y = 0; y < ui->board.game.config.board_visible + 1; y++) {
-    GLfloat height = ui->board.block_height;
-    GLfloat y_pos = (ui->board.y_offset - ui->board.block_height) + (y * ui->board.block_height);
-    if (y == 0) {
-      ui->board.skin.overlay.vertices[4] = ui->board.skin.overlay.vertices[9] = 0.6f;
-      height = 10 * RES_SCALE;
-      y_pos += 15 * RES_SCALE;
-    }
-    set_shine(&ui->board.skin.overlay, ui->board.skin.overlay_shine);
-    update_rect(&ui->board.skin.overlay, ui->board.x_offset, 
-        y_pos, ui->board.block_width * ui->board.game.config.board_x,
-        height, ui->window_width,
-        ui->window_height);
-    if (ui->board.skin.overlay_shine > 0)
-      ui->board.skin.overlay_shine -= 0.00025f;
-    if (y == 0)
-      ui->board.skin.overlay.vertices[4] = ui->board.skin.overlay.vertices[9] = 0.0f;
-    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-  }
-
-  glBindTexture(GL_TEXTURE_2D, 0);
-
-  glBindTexture(GL_TEXTURE_2D, ui->board.skin.block.texture);
-  for (int i = 0; i < ui->board.board_count; i++) {
-    glBindVertexArray(ui->board.board[i].vao);
-    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-  }
-
-  for (int i = 0; i < 4; i++) {
-    if (ui->board.current[i].visable) {
-      glBindVertexArray(ui->board.current[i].vao);
-      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-    }
-    if (ui->board.ghost[i].visable) {
-      glBindVertexArray(ui->board.ghost[i].vao);
-      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-    }
-  }
-
-  glBindTexture(GL_TEXTURE_2D, 0);
-
-  glBindTexture(GL_TEXTURE_2D, ui->board.skin.border.texture);
-  glBindVertexArray(ui->board.skin.border.vao);
-  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-
-  glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-void draw_held_piece(cetris_ui *ui) {
-  if (!ui->board.game.piece_held) return;
-
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, 0);
-  glBindTexture(GL_TEXTURE_2D, ui->board.skin.block.texture);
-  glBindVertexArray(ui->board.skin.block.vao);
-
-  for (int s = 0; s < 4; s++) {
-    for (int j = 0; j < 4; j++) {
-      if ((ui->board.game.held.m[s]>>(3 - j))&1) {
-        GLfloat block_x = 
-          ui->board.held.x_offset + (j * ui->board.held.block_width);
-        GLfloat block_y = 
-          ui->board.held.y_offset + (s * ui->board.held.block_height);
-
-        if (ui->board.game.held.t == MINO_O) {
-          block_x -= ui->board.held.block_width / 1.5f;
-        }
-        if (ui->board.game.held.t == MINO_I) {
-          block_x -= ui->board.held.block_width / 1.5f;
-        }
-
-        set_block_texture(&ui->board.skin.block, ui->board.game.held.t);
-        update_rect(&ui->board.skin.block, block_x, block_y, 
-            ui->board.held.block_width, ui->board.held.block_height,
-            ui->window_width, ui->window_height);
-
-        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-      }
-    }
-  }
-  glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-
-void draw_piece_queue(cetris_ui *ui) {
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, 0);
-  glBindTexture(GL_TEXTURE_2D, ui->board.skin.block.texture);
-  glBindVertexArray(ui->board.skin.block.vao);
-  
-  for (int i = 0; i < 5; i++) {
-  int index = (ui->board.game.current_index + i);
-  int mino;
-
-  if (index <= 6) {
-    mino = ui->board.game.piece_queue[index];
-  } else {
-    index = index % 7;
-    mino = ui->board.game.next_queue[index];
-  }
-
-  for (int s = 0; s < 4; s++) {
-    for (int j = 0; j < 4; j++) {
-        
-      if ((default_matrices[mino][s]>>(3 - j))&1) {
-        GLfloat block_x = 
-          ui->board.queue.x_offset + (j * ui->board.queue.block_width);
-        GLfloat block_y = 
-          ui->board.queue.y_offset + (ui->board.queue.h * (i / 5.0)) + (s * ui->board.queue.block_height);
-
-        if (ui->board.game.held.t == MINO_O) {
-          block_x -= ui->board.queue.block_width / 1.5f;
-        }
-        if (ui->board.game.held.t == MINO_I) {
-          block_x -= ui->board.queue.block_width / 1.5f;
-        }
-
-        set_block_texture(&ui->board.skin.block, mino);
-        update_rect(&ui->board.skin.block, block_x, block_y, 
-            ui->board.queue.block_width, ui->board.queue.block_height,
-            ui->window_width, ui->window_height);
-
-        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
-      }
-      }
-    }
-  }
-  glBindTexture(GL_TEXTURE_2D, 0);
-}
diff --git a/frontends/gl/drawable.c b/frontends/gl/drawable.c
index e3d959c..28bb3d3 100644
--- a/frontends/gl/drawable.c
+++ b/frontends/gl/drawable.c
@@ -86,5 +86,4 @@ void new_rectangle(drawable_t* drawable) {
 
   glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
   glEnableVertexAttribArray(2);
-
 }
diff --git a/frontends/gl/main.c b/frontends/gl/main.c
index 89fffdd..7490a90 100644
--- a/frontends/gl/main.c
+++ b/frontends/gl/main.c
@@ -20,9 +20,8 @@
 #include "events.h"
 
 #define SCREEN_FULLSCREEN 0
-#define RES_SCALE 1.2
-#define SCREEN_WIDTH 900 * RES_SCALE
-#define SCREEN_HEIGHT 720 * RES_SCALE
+#define SCREEN_WIDTH 900 
+#define SCREEN_HEIGHT 720
 
 static SDL_Window *window = NULL;
 static SDL_GLContext maincontext;
@@ -91,10 +90,19 @@ void load_config(cetris_ui *ui) {
       free(line_delay_clear);
     }
 
+    char *scale = get_ini_value(&p, "ui", "scale");
+    if (scale) {
+      ui->res_scale = atof(scale);
+      free(scale);
+    } else ui->res_scale = 1.0f;
+
+    ui->window_height = SCREEN_HEIGHT * ui->res_scale;
+    ui->window_width = SCREEN_WIDTH * ui->res_scale;
+
     char *skin = get_ini_value(&p, "ui", "skin");
     if (skin) {
-      load_skin(skin, &ui->board.skin);
-    } else load_skin("default", &ui->board.skin);
+      ui->skin_name = skin;
+    } else ui->skin_name = "default";
   }
 }
 
@@ -157,6 +165,11 @@ int main(void) {
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 5 );
   SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
 
+  cetris_ui ui;
+  ui.keys = default_keys; 
+
+  load_config(&ui); 
+
   if (SCREEN_FULLSCREEN) {
     window = SDL_CreateWindow(
       "cetris", 
@@ -167,7 +180,7 @@ int main(void) {
     window = SDL_CreateWindow(
       "cetris", 
       SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 
-      SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL
+      SCREEN_WIDTH * ui.res_scale, SCREEN_HEIGHT * ui.res_scale, SDL_WINDOW_OPENGL
     );
   }
 
@@ -181,13 +194,7 @@ int main(void) {
 
   SDL_GL_SetSwapInterval(1);
 
-  cetris_ui ui;
-  ui.window_height = SCREEN_HEIGHT;
-  ui.window_width = SCREEN_WIDTH;
-
-  ui.keys = default_keys; 
-
-  glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+  glViewport(0, 0, SCREEN_WIDTH * ui.res_scale, SCREEN_HEIGHT * ui.res_scale);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
@@ -201,16 +208,17 @@ int main(void) {
   glUseProgram(shaderProgram);
   ui.shader_program = shaderProgram;
 
-  load_config(&ui);
   init_game(&ui.board.game);
   cetris_start_game(&ui.board.game);
-  
-  load_tetris_board(&ui, &ui.board, 325.0f * RES_SCALE, 
-      110.0f * RES_SCALE, 250.0f * RES_SCALE, 500.0f * RES_SCALE);
-  load_piece_queue(&ui, &ui.board, 610.0f * RES_SCALE, 
-      100.0f * RES_SCALE, 100.0f * RES_SCALE, 400.0f * RES_SCALE);
-  load_held_piece(&ui, &ui.board, 242.0f * RES_SCALE, 
-      110.0f * RES_SCALE, 88.0f * RES_SCALE, 88.0f * RES_SCALE);  
+ 
+  load_skin(ui.skin_name, &ui.board.skin);
+
+  load_tetris_board(&ui, &ui.board, 325.0f * ui.res_scale, 
+      110.0f * ui.res_scale, 250.0f * ui.res_scale, 500.0f * ui.res_scale);
+  load_piece_queue(&ui.board, 610.0f * ui.res_scale, 
+      100.0f * ui.res_scale, 100.0f * ui.res_scale, 400.0f * ui.res_scale);
+  load_held_piece( &ui.board, 242.0f * ui.res_scale, 
+      110.0f * ui.res_scale, 88.0f * ui.res_scale, 88.0f * ui.res_scale);  
 
   start_event_thread(&ui);
 
diff --git a/frontends/gl/ui.c b/frontends/gl/ui.c
index 470ad4a..398cb15 100644
--- a/frontends/gl/ui.c
+++ b/frontends/gl/ui.c
@@ -1,11 +1,10 @@
 #include <glad/glad.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #include "ui.h"
 #include "drawable.h"
 
-#define RES_SCALE 1.2
-
 void refresh_current(cetris_ui *ui) {
   for (int i = 0; i < 4; i++) {
     ui->board.ghost[i].visable = false;
@@ -39,17 +38,17 @@ void load_tetris_board(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat
 
   refresh_current(ui);
 
-  update_rect(&board->skin.playboard, board->x_offset, board->y_offset - 10 * RES_SCALE,
+  update_rect(&board->skin.playboard, board->x_offset, board->y_offset - 10 * ui->res_scale,
       board->game.config.board_x * board->block_width,
-      (board->game.config.board_visible * board->block_height) + 10 * RES_SCALE,
+      (board->game.config.board_visible * board->block_height) + 10 * ui->res_scale,
       ui->window_width, ui->window_height);
 
-  update_rect(&board->skin.border, board->x_offset - (110 * RES_SCALE), 
-      board->y_offset - (45 * RES_SCALE), 380 * RES_SCALE, 600 * RES_SCALE,
+  update_rect(&board->skin.border, board->x_offset - (110 * ui->res_scale), 
+      board->y_offset - (45 * ui->res_scale), 380 * ui->res_scale, 600 * ui->res_scale,
       ui->window_width, ui->window_height);
 }
 
-void load_held_piece(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
+void load_held_piece(tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
   board->held.block_width = w / 4.0f;
   board->held.block_height = h / 4.0f;
 
@@ -57,7 +56,7 @@ void load_held_piece(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y,
   board->held.y_offset = y;
 }
 
-void load_piece_queue(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
+void load_piece_queue(tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
   board->queue.block_width = w / 4.0f;
   board->queue.block_height = w / 4.0f;
 
@@ -77,13 +76,11 @@ void update_current_drawable(cetris_ui *ui, drawable_t *current, drawable_t* gho
       if ((ui->board.game.current.m[s]>>(3 - j))&1) {
         cur_piece++;
 
-        GLfloat block_x = 
-          ui->board.x_offset + 
+        GLfloat block_x = ui->board.x_offset + 
           (j + ui->board.game.current.pos.x) * ui->board.block_width;
 
         if (ghost) {
-          GLfloat ghost_y = 
-            ui->board.y_offset + 
+          GLfloat ghost_y = ui->board.y_offset + 
             (s + ui->board.game.current.ghost_y - ui->board.block_offset) 
             * ui->board.block_height;
 
@@ -96,8 +93,7 @@ void update_current_drawable(cetris_ui *ui, drawable_t *current, drawable_t* gho
 
         if (s + ui->board.game.current.pos.y < ui->board.block_offset - 1) continue;
 
-        GLfloat block_y = 
-          ui->board.y_offset + 
+        GLfloat block_y = ui->board.y_offset + 
           (s + ui->board.game.current.pos.y - ui->board.block_offset)
           * ui->board.block_height;
 
@@ -113,20 +109,16 @@ void update_current_drawable(cetris_ui *ui, drawable_t *current, drawable_t* gho
 }
 
 void lock_current_drawable(cetris_ui *ui) {
-  for (int i = 0; i < 4; i++) {
-    new_rectangle(&ui->board.board[ui->board.board_count + i]);
-  }
-
   int current = 0;
   for (int s = 0; s < 4; s++) {
     for (int j = 0; j < 4; j++) {
       if ((ui->board.game.lock_event.m[s]>>(3 - j))&1) {
-        GLfloat block_x = 
-          ui->board.x_offset + 
+        new_rectangle(&ui->board.board[ui->board.board_count + current]);
+
+        GLfloat block_x = ui->board.x_offset + 
           (j + ui->board.game.lock_event.pos.x) * ui->board.block_width;
 
-        GLfloat block_y = 
-          ui->board.y_offset + 
+        GLfloat block_y = ui->board.y_offset + 
           (s + ui->board.game.lock_event.pos.y - ui->board.block_offset)
           * ui->board.block_height;
 
@@ -195,8 +187,8 @@ void draw_tetris_board(cetris_ui *ui) {
     GLfloat y_pos = (ui->board.y_offset - ui->board.block_height) + (y * ui->board.block_height);
     if (y == 0) {
       ui->board.skin.overlay.vertices[4] = ui->board.skin.overlay.vertices[9] = 0.6f;
-      height = 10 * RES_SCALE;
-      y_pos += 15 * RES_SCALE;
+      height = 10 * ui->res_scale;
+      y_pos += 15 * ui->res_scale;
     }
     set_shine(&ui->board.skin.overlay, ui->board.skin.overlay_shine);
     update_rect(&ui->board.skin.overlay, ui->board.x_offset, 
diff --git a/frontends/gl/ui.h b/frontends/gl/ui.h
index 4606c4d..1bb70fa 100644
--- a/frontends/gl/ui.h
+++ b/frontends/gl/ui.h
@@ -69,6 +69,8 @@ typedef struct {
 
   char* skin_name;
 
+  float res_scale;
+
   tetris_board_t board;
 
   GLuint shader_program;
@@ -80,5 +82,5 @@ void draw_piece_queue(cetris_ui *ui);
 void draw_current(cetris_ui *ui);
 void update_board_drawables(cetris_ui *ui);
 void load_tetris_board(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-void load_held_piece(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-void load_piece_queue(cetris_ui *ui, tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
+void load_held_piece(tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
+void load_piece_queue(tetris_board_t *board, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
diff --git a/notes.txt b/notes.txt
index 1c51ce6..21baa76 100644
--- a/notes.txt
+++ b/notes.txt
@@ -55,3 +55,8 @@ gl optimization notes:
   the board array on a lock event which leaves time to
   edit the vertex buffer before copying it if it needs an
   animation 
+
+TODO:
+- more structured event system in the core lib 
+- add more sounds/skin elements and match them up to the new events
+- new minimal skin
diff --git a/test/memory_test.c b/test/memory_test.c
index 8966a4f..7fc19e0 100644
--- a/test/memory_test.c
+++ b/test/memory_test.c
@@ -5,7 +5,7 @@
 int main(void) {
   cetris_game game;
 
-  init_game(&game, NULL);
+  init_game(&game);
 
   printf("memory usage of game instance: %li\n", sizeof(game));