Built basic UI Grid.

src/game/poker/ui/pokerplayerui.c

@@ -9,11 +9,9 @@
 
 void pokerPlayerUiInit(pokerplayerui_t *ui) {
   labelInit(&ui->label);
-  
   frameBufferInit(&ui->frame,
     POKER_PLAYER_UI_IMAGE_RESOLUTION, POKER_PLAYER_UI_IMAGE_RESOLUTION
   );
-
   quadInit(&ui->quad, 0,
     0, 0, 0, 1,
     POKER_PLAYER_UI_IMAGE_SIZE, POKER_PLAYER_UI_IMAGE_SIZE, 1, 0
@@ -24,11 +22,13 @@ void pokerPlayerUiUpdate(
   pokerplayerui_t *ui, pokergame_t *game, shader_t *shader, int32_t playerIndex,
   engine_t *engine
 ) {
-  
   camera_t camera;
   uint8_t seat;
+  pokerplayer_t *player;
   float x, y, z;
 
+  player = game->poker.players + playerIndex;
+
   // Bind the frame buffer
   frameBufferUse(&ui->frame, true);
 

src/game/poker/ui/pokerui.c

@@ -8,42 +8,53 @@
 #include "pokerui.h"
 
 void pokerUiInit(pokergame_t *pokerGame) {
-  uint8_t i;
+  uint8_t i, j;
 
+  j = 0;
   for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-    pokerPlayerUiInit(pokerGame->ui.player + i);
+    if(i == POKER_PLAYER_HUMAN_INDEX) continue;
+    pokerPlayerUiInit(pokerGame->ui.player + j);
+    j++;
   }
 }
 
 void pokerUiUpdate(pokergame_t *pokerGame, engine_t *engine) {
-  uint8_t i;
+  uint8_t i, j;
   pokerplayerui_t *ui;
 
+  j = 0;
   for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-    ui = pokerGame->ui.player + i;
-
+    if(i == POKER_PLAYER_HUMAN_INDEX) continue;
+    ui = pokerGame->ui.player + j;
     pokerPlayerUiUpdate(ui, pokerGame, &pokerGame->assets.shader, i, engine);
+    j++;
   }
 }
 
 void pokerUiRender(pokergame_t *pokerGame, engine_t *engine) {
-  uint8_t i;
+  uint8_t i, j;
   pokerplayerui_t *ui;
 
+  j = 0;
   for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-    ui = pokerGame->ui.player + i;
+    if(i == POKER_PLAYER_HUMAN_INDEX) continue;
+    ui = pokerGame->ui.player + j;
 
     pokerPlayerUiRender(ui, pokerGame,
       &pokerGame->assets.shader, &pokerGame->assets.font, i,
-      engine->render.width, i * 75.0f
+      engine->render.width, j * 75.0f
     );
+    j++;
   }
 }
 
 void pokerUiDispose(pokergame_t *pokerGame) {
-  uint8_t i;
+  uint8_t i, j;
 
+  j = 0;
   for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-    pokerPlayerUiDispose(pokerGame->ui.player + i);
+    if(i == POKER_PLAYER_HUMAN_INDEX) continue;
+    pokerPlayerUiDispose(pokerGame->ui.player + j);
+    j++;
   }
 }

src/game/sandbox/sandboxscene.c

@@ -7,50 +7,75 @@
 
 #include "sandboxscene.h"
 
-void renderTest(renderlist_t *list, renderpass_t *pass, engine_t *engine, int32_t i) {
-  sandboxscene_t *scene;
-  scene = (sandboxscene_t *)list->user;
+grid_t grid;
 
-  shaderUsePosition(pass->shader, 0, 0, 0, engine->time.current, engine->time.current, 0);
-  shaderUseTexture(pass->shader, &scene->texture);
-  primitiveDraw(&scene->cube, 0, -1);
+void gridTest(
+  void *user, int32_t i,
+  float screenWidth, float screenHeight,
+  float x, float y,
+  float width, float height
+) {
+  sandboxscene_t *game = (sandboxscene_t *)user;
+  game->items[i].x = x;
+  game->items[i].y = y;
+  game->items[i].width = width;
+  game->items[i].height = height;
 }
 
 bool sandboxSceneInit(sandboxscene_t *game) {
-  int32_t passIndex;
-  renderpass_t *pass;
+  gridInit(&grid);
+  grid.user = (void *)game;
+
+  gridAddBreakpoint(&grid, 800, 2, 2, 8.0f, 8.0f);
+  gridAddBreakpoint(&grid, -1, 6, 6, 16.0f, 16.0f);
+
+  gridchild_t *child = gridAddChild(&grid);
+  child->onResize = &gridTest;
 
-  // Load assets
   assetTextureLoad(&game->texture, "test_texture.png");
-  assetShaderLoad(&game->shader, "shaders/textured.vert", "shaders/textured.frag");
-  cubeInit(&game->cube, 1.0f, 1.0f, 1.0f);
-
-  // Initialize list
-  renderListInit(&game->list, 1, 400, 400);
-  game->list.user = game;
-
-  // Set up the pass
-  passIndex = renderPassAdd(&game->list);
-  pass = renderListGetPass(&game->list, passIndex);
-  pass->shader = &game->shader;
+  assetShaderLoad(&game->shader, 
+    "shaders/textured.vert", "shaders/textured.frag"
+  );
+  quadInit(&game->primitive, 0,
+    0,0,0,0,
+    1,1,1,1
+  );
 
   return true;
 }
 
 void sandboxSceneUpdate(sandboxscene_t *game, engine_t *engine) {
-  dynarray_t items;
-  renderitem_t *item;
-  dynArrayInit(&items, sizeof(renderitem_t), 1);
-  item = (renderitem_t *)dynArrayGet(&items, dynArrayAdd(&items));
-  item->onRender=  &renderTest;
+  cameraLookAt(&game->camera,
+    0, 0, 10,
+    0, 0, 0
+  );
 
-  cameraLookAt(&game->camera, 3,3,3, 0,0,0);
-  cameraPerspective(&game->camera, 75, 16.0f/9.0f, 0.3f, 100.0f);
+  cameraOrtho(&game->camera,
+    0, engine->render.width,
+    engine->render.height, 0,
+    0.01f, 1000.0f
+  );
+
+  shaderUse(&game->shader);
+  shaderUseCamera(&game->shader, &game->camera);
+  shaderUseTexture(&game->shader, &game->texture);
+
+  gridSetSize(&grid,
+    engine->render.width, engine->render.height,
+    engine->render.width, engine->render.height,
+    0, 0
+  );
   
-  renderListRenderPass(&game->list, engine, &game->camera, 0, &items);
-  renderListRender(&game->list, engine, &game->shader);
 
-  dynArrayDispose(&items);
+  for(uint8_t i = 0; i < GRID_BRUH_COUNT; i++) {
+    gridbruh_t *b = game->items + i;
+    shaderUsePositionAndScale(&game->shader, 
+      b->x, b->y, 0,
+      0, 0, 0,
+      b->width, b->height, 1
+    );
+    primitiveDraw(&game->primitive, 0, -1);
+  }
 }
 
 void sandboxSceneDispose(sandboxscene_t *game) {

src/game/sandbox/sandboxscene.h

@@ -14,7 +14,9 @@
 #include "../../display/primitives/quad.h"
 #include "../../display/primitives/cube.h"
 #include "../../display/renderlist.h"
+#include "../../display/texture.h"
 #include "../../file/asset.h"
+#include "../../ui/grid.h"
 
 /**
  * Initialize the sandbox scene test game.