Restored some of the rendering

include/dawn/display/render.h

@@ -11,6 +11,6 @@
  * how the renderer is currently set up.
  */
 typedef struct {
-  /** Resolution (in pixels) */
+  /** Resolution (in pixels). Floats to allow subpixels in future. */
-  int32_t width, height;
+  float width, height;
 } render_t;

include/dawn/poker/player.h

@@ -8,26 +8,21 @@
 #pragma once
 #include "../libs.h"
 #include "card.h"
+#include "../display/texture.h"
+#include "../display/primitive.h"
+#include "../display/tileset.h"
 
 /** How many cards a player can hold in their hand */
 #define POKER_PLAYER_HAND 2
 
-/** How many players in a poker game (excludes dealer) */
-#define POKER_PLAYER_COUNT 5
-
 /** State for whether or not a player has folded */
 #define POKER_PLAYER_STATE_FOLDED 0x01
 
 /** State for whether or not a player is showing their hand */
 #define POKER_PLAYER_STATE_SHOWING 0x02
 
-/** Various seats at the table that people can sit */
+/** State for whether or not the player is out */
-#define HOLDEM_GAME_SEAT_DEALER 0x00
+#define POKER_PLAYER_STATE_OUT 0x04
-#define HOLDEM_GAME_SEAT_PLAYER0 0x04
-#define HOLDEM_GAME_SEAT_PLAYER1 0x06
-#define HOLDEM_GAME_SEAT_PLAYER2 0x05
-#define HOLDEM_GAME_SEAT_PLAYER3 0x03
-#define HOLDEM_GAME_SEAT_PLAYER4 0x02
 
 /** Poker Player State */
 typedef struct {
@@ -43,4 +38,10 @@ typedef struct {
   
   /** Current bet in current round player has placed */
   uint32_t currentBet;
+
+  // Rendering assets
+  texture_t bodyTexture;
+  primitive_t bodyPrimitive;
+  texture_t faceTexture;
+  primitive_t facePrimitive;
 } pokerplayer_t;

include/dawn/poker/poker.h

@@ -9,13 +9,12 @@
 #include "../libs.h"
 #include "player.h"
 #include "card.h"
+#include "render.h"
 
-#include "../display/tileset.h"
-#include "../display/primitive.h"
-#include "../display/texture.h"
-#include "../display/shader.h"
 #include "../display/camera.h"
-#include "../display/spritebatch.h"
+#include "../display/shader.h"
+#include "../display/texture.h"
+#include "../display/tileset.h"
 
 /** Rounds that the game can be in */
 #define POKER_ROUND_DEAL 0x00
@@ -32,14 +31,30 @@
 /** How many cards the dealer can hold in their hand */
 #define POKER_DEALER_HAND 5
 
+/** How many cards the grave can hold */
+#define POKER_GRAVE_SIZE CARD_DECK_SIZE
+
+/** How many players in a poker game (excludes dealer) */
+#define POKER_PLAYER_COUNT 5
+
+/** How many chips each player has by defautl */
+#define POKER_PLAYER_CHIPS_DEFAULT 10000
+
+/** The default blind cost for the big blind. Small Blind is half this */
+#define POKER_BLIND_BIG_DEFAULT 600
+#define POKER_BLIND_SMALL_DEFAULT (POKER_BLIND_BIG_DEFAULT/2)
+
 typedef struct {
   /** Current Card Deck */
   card_t deck[CARD_DECK_SIZE];
   uint8_t deckSize;
 
-  /** Dealer Money */
+  /** Card grave (where spent cards go when burned */
-  uint32_t blindSmall;
+  card_t grave[POKER_GRAVE_SIZE];
-  uint32_t blindBig;
+  uint8_t graveSize;
+
+  /** Blinds */
+  uint32_t blindSmall, blindBig;
 
   /** Dealer Hand */
   card_t cards[POKER_DEALER_HAND];
@@ -48,37 +63,33 @@ typedef struct {
   /** Player States */
   pokerplayer_t players[POKER_PLAYER_COUNT];
 
-  /** Game State */
+  /** The current round the game is on */
   uint8_t round;
-  uint8_t roundPlayer;
+
+  /** The current player that is the dealer */
   uint8_t roundDealer;
+
+  /** Current pot of chips */
   uint32_t pot;
+
+  /** The current buy-in bet size. */
   uint32_t roundBet;
 
   /** Rendering Assets */
-  texture_t *kagamiTexture;
+  texture_t dealerTexture;
-  tileset_t *kagamiTileset;
+  tileset_t dealerTileset;
-  primitive_t *kagamiQuad;
+  primitive_t dealerPrimitive;
 
-  primitive_t *chipPrimitive;
+  texture_t chipTexture;
-  texture_t *chipTexture;
+  primitive_t chipPrimitive;
-  primitive_t *tablePrimitive;
+  
-  texture_t *tableTexture;
+  texture_t tableTexture;
+  primitive_t tablePrimitive;
 
-  texture_t *cardTexture;
+  texture_t cardTexture;
-  tileset_t *cardTileset;
+  tileset_t cardTileset;
-  primitive_t *cardPrimitive;
+  primitive_t cardPrimitive;
 
-  texture_t *fontTexture;
+  shader_t shader;
-  tileset_t *fontTileset;
+  camera_t camera;
-  spritebatch_t *fontBatch;
-
-  shader_t *shaderWorld;
-  framebuffer_t *frameLeft;
-  framebuffer_t *frameRight;
-  primitive_t *quadLeft;
-  primitive_t *quadRight;
-  camera_t cameraMain;
-  camera_t cameraLeft;
-  camera_t cameraRight;
 } poker_t;

include/dawn/poker/render.h

@@ -8,34 +8,45 @@
 #pragma once
 #include "../libs.h"
 
-/** Size of the rendered card */
+#include "../display/tileset.h"
-#define HOLDEM_GAME_CARD_WIDTH 0.04
+#include "../display/primitive.h"
-#define HOLDEM_GAME_CARD_HEIGHT HOLDEM_GAME_CARD_WIDTH/2.5*3.5
+#include "../display/texture.h"
-#define HOLDEM_GAME_CARD_DEPTH 0.0005
+#include "../display/shader.h"
-#define HOLDEM_GAME_CARD_PADDING 0.0125
+#include "../display/camera.h"
+#include "../display/spritebatch.h"
 
 /** Size of the Render frames */
-#define HOLDEM_GAME_FRAME_HEIGHT RENDER_STATE.height
+#define POKER_FRAME_HEIGHT RENDER_STATE.height
-#define HOLDEM_GAME_FRAME_LEFT_WIDTH RENDER_STATE.width*0.65
+#define POKER_FRAME_LEFT_WIDTH RENDER_STATE.width*0.65
-#define HOLDEM_GAME_FRAME_RIGHT_WIDTH (\
+#define POKER_FRAME_RIGHT_WIDTH (\
-  RENDER_STATE.width - HOLDEM_GAME_FRAME_LEFT_WIDTH - 1\
+  RENDER_STATE.width - POKER_FRAME_LEFT_WIDTH - 1\
 )
 
+/** Size of the rendered card */
+#define POKER_CARD_WIDTH 0.04
+#define POKER_CARD_HEIGHT POKER_CARD_WIDTH/2.5*3.5
+#define POKER_CARD_DEPTH 0.0005
+#define POKER_CARD_PADDING 0.0125
+
 /** Macro for the angle (Yaw) that the seat has */
-#define HOLDEM_GAME_SEAT_ANGLE(seat) mathDeg2Rad(-45 * seat)
+#define POKER_SEAT_ANGLE(seat) mathDeg2Rad(-45 * seat)
 
-#define HOLDEM_GAME_CARD_SLOT_HAND0 0x00
+/** Slots where cards can render */
-#define HOLDEM_GAME_CARD_SLOT_HAND1 0x01
+#define POKER_CARD_SLOT_HAND0 0x00
-#define HOLDEM_GAME_CARD_SLOT_FLOP0 0x02
+#define POKER_CARD_SLOT_HAND1 0x01
-#define HOLDEM_GAME_CARD_SLOT_FLOP1 0x03
+#define POKER_CARD_SLOT_FLOP0 0x02
-#define HOLDEM_GAME_CARD_SLOT_FLOP2 0x04
+#define POKER_CARD_SLOT_FLOP1 0x03
-#define HOLDEM_GAME_CARD_SLOT_FLOP3 0x05
+#define POKER_CARD_SLOT_FLOP2 0x04
-#define HOLDEM_GAME_CARD_SLOT_FLOP4 0x06
+#define POKER_CARD_SLOT_FLOP3 0x05
+#define POKER_CARD_SLOT_FLOP4 0x06
 
-#define HOLDEM_GAME_CHIP_STACK0 0x00
+/** Various seats at the table that people can sit */
-#define HOLDEM_GAME_CHIP_STACK1 0x01
+#define POKER_SEAT_DEALER 0x00  
-#define HOLDEM_GAME_CHIP_STACK2 0x03
+#define POKER_SEAT_PLAYER0 0x04
-#define HOLDEM_GAME_CHIP_STACK3 0x04
+#define POKER_SEAT_PLAYER1 0x06
+#define POKER_SEAT_PLAYER2 0x05
+#define POKER_SEAT_PLAYER3 0x03
+#define POKER_SEAT_PLAYER4 0x02
 
 typedef struct {
   float x, z;

src/assets/models/pokertable.c

@@ -7,7 +7,7 @@
 
 #include "pokertable.h"
 
-void pokerTableCreate(primitive_t *primitive) {
+void pokerTableInit(primitive_t *primitive) {
   vertice_t vertices[POKER_TABLE_VERTICE_COUNT] = {
     { .x = 0.12437210000000001, .y = 0, .z = -0.30026090000000005, .u = 0.836914, .v = 0.265625 },
     { .x = 0.29349590000000003, .y = 0.0176777, .z = -0.12157000000000001, .u = 0.853516, .v = 0.06445299999999998 },

src/game/game.c

@@ -10,72 +10,28 @@
 bool gameInit(game_t *game) {
   // Init the game
   game->name = GAME_NAME;
-  
+
+  // Init the engine and the rendering pipeline
   engineInit(&game->engine, game);
 
-  // assetShaderLoad(&game->shader,"shaders/textured.vert","shaders/textured.frag");
+  // Hand off to the poker logic.
-  // assetTextureLoad(&game->texture, "cards_normal.png");
+  pokerInit(&game->poker);
-  // cubeInit(&game->primitive, 1, 1, 1);
 
-  // // Load the world shader.
-  // GAME_STATE.shaderWorld = assetShaderLoad(
-  //   "shaders/textured.vert", "shaders/textured.frag"
-  // );
-
-  // // Font
-  // GAME_STATE.fontTexture = assetTextureLoad("font.png");
-  // GAME_STATE.fontTileset = tilesetCreate(20, 20,
-  //   GAME_STATE.fontTexture->width,
-  //   GAME_STATE.fontTexture->height,
-  //   1, 1, 1, 1
-  // );
-  // GAME_STATE.fontBatch = spriteBatchCreate(1024);
-
-  // // Prepare the renderer.
-  // pokerInit(&GAME_STATE.poker);
-  // holdemRenderFrameInit();
-  // holdemRenderWorldInit();
-  // holdemRenderPlayerInit();
-  // holdemRenderCardInit();
-  // holdemRenderChipInit();
-
-  // Init the input manger.
   return true;
 }
 
 bool gameUpdate(game_t *game, float platformDelta) {
+  // Let the engine do its thing.
   engineUpdateStart(&game->engine, game, platformDelta);
-  
-  cameraPerspective(&game->camera, 75,
-    ((float)game->engine.render.width)/((float)game->engine.render.height),
-    0.01, 1000
-  );
-  cameraLookAt(&game->camera, 3, 3, 3, 0, 0, 0);
-  shaderUse(&game->shader);
-  shaderUseTexture(&game->shader, &game->texture);
-  shaderUseCamera(&game->shader, &game->camera);
-  shaderUsePosition(&game->shader, 0, 0, 0, 0, game->engine.time.current, 0);
-  primitiveDraw(&game->primitive, 0, -1);
 
+  // Hand off to the poker logic
+  pokerUpdate(&game->poker, &game->engine.render);
 
-  // shaderUse(GAME_STATE.shaderWorld);// TODO: remove
+  // Hand back to the engine.
-  
-  // // Update the frame buffers and action queue
-  // holdemRenderFrameUpdate();
-  // pokerActionUpdate();
-
-  // // Render things on each frame, then render those frames.
-  // holdemRenderFrameUseLeft();
-  // holdemRenderWorld();
-  // holdemRenderFrameUseRight();
-  // holdemRenderWorld();
-  // holdemRenderFrameBack();
-
   return engineUpdateEnd(&game->engine, game);
 }
 
 void gameDispose(game_t *game) {
+  pokerDispose(&game->poker);
   engineDispose(&game->engine, game);
-  // pokerActionDispose();
-  // shaderDispose(GAME_STATE.shaderWorld);
 }

src/game/game.h

@@ -6,14 +6,7 @@
 #pragma once
 #include <dawn/dawn.h>
 #include "../engine/engine.h"
-
+#include "../poker/poker.h"
-#include "../file/asset.h"
-#include "../display/render.h"
-#include "../display/primitive.h"
-#include "../display/primitives/cube.h"
-#include "../display/texture.h"
-#include "../display/shader.h"
-#include "../display/camera.h"
 
 /**
  * Initialize the game context.

src/poker/card.c

@@ -1,34 +0,0 @@
-/**
- * Copyright (c) 2021 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "card.h"
-
-void cardDeckFill(card_t *deck) {
-  uint8_t i;
-  for(i = 0; i < CARD_DECK_SIZE; i++) {
-    deck[i] = i;
-  }
-}
-
-void cardShuffle(card_t *hand, uint8_t cardCount) {
-  uint8_t i, j;
-  card_t temporary;
-  for(i = 0; i < cardCount - 1; i++) {
-    // Select random element from remaining elements.
-    j = u8randRange(i, cardCount);
-    temporary = hand[j];// Take out other card
-    hand[j] = hand[i];// Move my card there
-    hand[i] = temporary;// Put other card here.
-  }
-}
-
-void cardDeal(card_t *deck, card_t *hand, uint8_t deckSize, uint8_t handSize) {
-  card_t card;
-  card = deck[deckSize-1];
-  deck[deckSize-1] = 0x00;
-  hand[handSize] = card;
-}

src/poker/poker.c

@@ -10,33 +10,49 @@
 void pokerInit(poker_t *poker) {
   uint8_t x;
 
-  // Prepare the initial game state
+  // Load the main shader
-  poker->round = POKER_ROUND_DEAL;
+  assetShaderLoad(&poker->shader,
-  poker->roundPlayer = 0x00;
+    "shaders/textured.vert", "shaders/textured.frag"
+  );
+
+  // Initialize the render stuffs.
+  pokerWorldInit(poker);
+  pokerCardInit(poker);
+  pokerPlayerInit(poker);
+
+  // Reset the main game state. This does not init the round.
+  poker->blindBig = POKER_BLIND_BIG_DEFAULT;
+  poker->blindSmall = POKER_BLIND_SMALL_DEFAULT;
   poker->roundDealer = 0x00;
-  poker->blindSmall = 0;
-  poker->blindBig = 0;
 
   for(x = 0; x < POKER_PLAYER_COUNT; x++) {
     poker->players[x].state = 0x00;
-    poker->players[x].chips = 0;
+    poker->players[x].chips = POKER_PLAYER_CHIPS_DEFAULT;
-    poker->players[x].cardCount = 0;
-    poker->players[x].currentBet = 0;
   }
 
-  pokerRoundInit(poker);
+  // Hand over to the deal for the first time.
+  pokerDealInit(poker);
 }
 
-void pokerRoundInit(poker_t *poker) {
+void pokerUpdate(poker_t *poker, render_t *render) {
-  uint8_t x;
+  // Game Logic
 
-  // Refill the deck
+  // TEMP
-  cardDeckFill(poker->deck);
+  cameraPerspective(&poker->camera, 20,render->width/render->height,0.001,1000);
-  poker->deckSize = CARD_DECK_SIZE;
+  pokerLookAtPlayer(&poker->camera, pokerPlayerGetSeatForPlayer(0x00));
 
-  // Reset the players
+  // Render Logic
-  for(x = 0; x < POKER_PLAYER_COUNT; x++) {
+  shaderUse(&poker->shader);
-    poker->players[x].cardCount = 0;
+  shaderUseCamera(&poker->shader, &poker->camera);
-    poker->players[x].currentBet = 0;
+
+  pokerWorldRender(poker);
+  for(uint8_t pi = 0; pi < POKER_PLAYER_COUNT; pi++) {
+    uint8_t seat = pokerPlayerGetSeatForPlayer(pi);
+    pokerPlayerRender(poker, poker->players + pi, seat);
   }
+}
+
+void pokerDispose(poker_t * poker) {
+  pokerWorldDispose(poker);
+  shaderDispose(&poker->shader);
 }

src/poker/poker.h

@@ -7,19 +7,31 @@
 
 #pragma once
 #include <dawn/dawn.h>
-#include "card.h"
+#include "round/deal.h"
+#include "render/world.h"
+#include "render/card.h"
+#include "render/player.h"
+#include "render/look.h"
+#include "../file/asset.h"
+#include "../display/shader.h"
+
+#include "../display/camera.h"
 
 /**
- * Initializes the poker match for the first time.
+ * Initializes the poker context for the first time.
- * 
+ * @param poker Poker context to initialize.
- * @param poker Poker game to init.
  */
 void pokerInit(poker_t *poker);
 
+/**
+ * Updates the poker context.
+ * @param poker Poker game to update.
+ * @param render Render manager to use.
+ */
+void pokerUpdate(poker_t *poker, render_t *render);
 
 /**
- * Initializes the round for a poker game.
+ * Cleans an existing poker game instance.
- * 
+ * @param poker Poker instance to cleanup
- * @param poker Poker game to init a new round for.
  */
-void pokerRoundInit(poker_t *poker);
+void pokerDispose(poker_t *poker);

src/poker/render/card.c

@@ -5,61 +5,62 @@
  * https://opensource.org/licenses/MIT
  */
 
+#pragma once
 #include "card.h"
 
-void holdemRenderCardInit() {
+void pokerCardInit(poker_t *poker) {
   tilesetdiv_t *cardBack;
 
   // Load Cards Texture
-  GAME_STATE.cardTexture = assetTextureLoad("cards_normal.png");
+  assetTextureLoad(&poker->cardTexture, "cards_normal.png");
-  GAME_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
+  tilesetInit(&poker->cardTileset,
-    GAME_STATE.cardTexture->width, GAME_STATE.cardTexture->height,
+    CARD_COUNT_PER_SUIT, 6,
-    0, 0, 0, 0
+    poker->cardTexture.width, poker->cardTexture.height,
+    0, 0,
+    0, 0
   );
 
   // Cards Primitive
-  cardBack = GAME_STATE.cardTileset->divisions+(
+  cardBack = poker->cardTileset.divisions+(poker->cardTileset.columns * 4);
-    GAME_STATE.cardTileset->columns * 4
+  primitiveInit(&poker->cardPrimitive,
-  );
-  GAME_STATE.cardPrimitive = primitiveCreate(
     QUAD_VERTICE_COUNT * 2, QUAD_INDICE_COUNT * 2
   );
-  quadBuffer(GAME_STATE.cardPrimitive, -HOLDEM_GAME_CARD_DEPTH,
+  quadBuffer(&poker->cardPrimitive, -POKER_CARD_DEPTH,
-    -HOLDEM_GAME_CARD_WIDTH, -HOLDEM_GAME_CARD_HEIGHT,
+    -POKER_CARD_WIDTH, -POKER_CARD_HEIGHT,
     cardBack->x0, cardBack->y1,
-    HOLDEM_GAME_CARD_WIDTH, HOLDEM_GAME_CARD_HEIGHT,
+    POKER_CARD_WIDTH, POKER_CARD_HEIGHT,
     cardBack->x1, cardBack->y0,
     QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT
   );
 }
 
-pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot) {
+pokerposition_t pokerCardGetPosition(uint8_t seat, uint8_t slot) {
   pokerposition_t position;
   float t, t2;
 
-  position.yaw = HOLDEM_GAME_SEAT_ANGLE(seat);
+  position.yaw = POKER_SEAT_ANGLE(seat);
   position.x = sin(position.yaw) * -0.75;
   position.z = cos(position.yaw) * -0.75;
 
   t = position.yaw + mathDeg2Rad(90);
 
   switch (slot) {
-    case HOLDEM_GAME_CARD_SLOT_HAND0:
+    case POKER_CARD_SLOT_HAND0:
-    case HOLDEM_GAME_CARD_SLOT_HAND1:
+    case POKER_CARD_SLOT_HAND1:
-      t2 = HOLDEM_GAME_CARD_WIDTH+HOLDEM_GAME_CARD_PADDING;
+      t2 = POKER_CARD_WIDTH+POKER_CARD_PADDING;
-      if(slot == HOLDEM_GAME_CARD_SLOT_HAND0) t2 = -t2;
+      if(slot == POKER_CARD_SLOT_HAND0) t2 = -t2;
       t2 += 0.1;
       break;
       
-    case HOLDEM_GAME_CARD_SLOT_FLOP0:
+    case POKER_CARD_SLOT_FLOP0:
-    case HOLDEM_GAME_CARD_SLOT_FLOP1:
+    case POKER_CARD_SLOT_FLOP1:
-    case HOLDEM_GAME_CARD_SLOT_FLOP2:
+    case POKER_CARD_SLOT_FLOP2:
-    case HOLDEM_GAME_CARD_SLOT_FLOP3:
+    case POKER_CARD_SLOT_FLOP3:
-    case HOLDEM_GAME_CARD_SLOT_FLOP4:
+    case POKER_CARD_SLOT_FLOP4:
-      t2 = HOLDEM_GAME_CARD_WIDTH*2+HOLDEM_GAME_CARD_PADDING;
+      t2 = POKER_CARD_WIDTH*2+POKER_CARD_PADDING;
       t2 = (
-        -t2 * ( HOLDEM_GAME_CARD_SLOT_FLOP4-HOLDEM_GAME_CARD_SLOT_FLOP0)
+        -t2 * ( POKER_CARD_SLOT_FLOP4-POKER_CARD_SLOT_FLOP0)
-      )/2 + t2*(slot-HOLDEM_GAME_CARD_SLOT_FLOP0);
+      )/2 + t2*(slot-POKER_CARD_SLOT_FLOP0);
       break;
 
     default:
@@ -72,24 +73,27 @@ pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot) {
   return position;
 }
 
-void holdemRenderCard(card_t card, float x, float y, float z,
+void pokerCardRender(poker_t *poker, card_t card, float x, float y, float z,
   float pitch, float yaw, float roll
 ) {
-  tilesetdiv_t *cardFront = GAME_STATE.cardTileset->divisions + card;
+  tilesetdiv_t *cardFront = poker->cardTileset.divisions + card;
-  quadBuffer(GAME_STATE.cardPrimitive, HOLDEM_GAME_CARD_DEPTH,
+  quadBuffer(&poker->cardPrimitive, POKER_CARD_DEPTH,
-    -HOLDEM_GAME_CARD_WIDTH, -HOLDEM_GAME_CARD_HEIGHT, 
+    -POKER_CARD_WIDTH, -POKER_CARD_HEIGHT, 
     cardFront->x0, cardFront->y1,
-    HOLDEM_GAME_CARD_WIDTH, HOLDEM_GAME_CARD_HEIGHT,
+    POKER_CARD_WIDTH, POKER_CARD_HEIGHT,
     cardFront->x1, cardFront->y0,
     0, 0
   );
 
-  shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.cardTexture);
+  shaderUseTexture(&poker->shader, &poker->cardTexture);
-  shaderUsePosition(GAME_STATE.shaderWorld, x,y,z, pitch,yaw,roll);
+  shaderUsePosition(&poker->shader, x,y,z, pitch,yaw,roll);
-  primitiveDraw(GAME_STATE.cardPrimitive, 0, -1);
+  primitiveDraw(&poker->cardPrimitive, 0, -1);
 }
 
-void holdemRenderCardForSeat(uint8_t seat, card_t card, uint8_t slot) {
+void pokerCardRenderForSeat(poker_t *poker, uint8_t seat, card_t card, uint8_t slot) {
-  pokerposition_t position = holdemRenderCardGetPosition(seat, slot);
+  pokerposition_t position = pokerCardGetPosition(seat, slot);
-  holdemRenderCard(card, position.x, 0, position.z, mathDeg2Rad(-90), position.yaw, 0);
+  pokerCardRender(poker, card,
+    position.x, 0, position.z,
+    mathDeg2Rad(-90), position.yaw, 0
+  );
 }

src/poker/render/card.h

@@ -15,8 +15,9 @@
 
 /**
  * Initializes the Card Renderer.
+ * @param poker The poker game context.
  */
-void holdemRenderCardInit();
+void pokerCardInit(poker_t *poker);
 
 /**
  * Returns the position a card "naturally" sits at for a given seat and slot.
@@ -25,12 +26,13 @@ void holdemRenderCardInit();
  * @param slot Slot within the player/dealers' hand that the card belongs to.
  * @return A struct containing X, Z and YAW properties.
  */
-pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot);
+pokerposition_t pokerCardGetPosition(uint8_t seat, uint8_t slot);
 
 /**
  * Render's a given card at the specified coordinates. Card is a reused quad 
  * and is re-buffered to for every draw call.
  * 
+ * @param poker The poker game context.
  * @param card Card to render.
  * @param x X Position (world space).
  * @param y Y Position (world space).
@@ -39,15 +41,15 @@ pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot);
  * @param yaw Yaw angle.
  * @param roll Roll angle.
  */
-void holdemRenderCard(card_t card, float x, float y, float z,
+void pokerCardRender(poker_t *poker, card_t card, float x, float y, float z,
   float pitch, float yaw, float roll
 );
 
 /**
  * Render's a card at a given seat and slot.
- * 
+ * @param poker The poker game context.
  * @param seat Seat the card is for.
  * @param card Card to render.
  * @param slot Slot the card is for.
  */
-void holdemRenderCardForSeat(uint8_t seat, card_t card, uint8_t slot);
+void pokerCardRenderForSeat(poker_t *poker, uint8_t seat, card_t card, uint8_t slot);

src/poker/render/look.c

@@ -7,23 +7,23 @@
 
 #include "look.h"
 
-void holdemRenderLookSeat(camera_t *camera, uint8_t seat) {
+void pokerLookAtPlayer(camera_t *camera, uint8_t seat) {
   float x, z, angle;
-  angle = HOLDEM_GAME_SEAT_ANGLE(seat);
+  angle = POKER_SEAT_ANGLE(seat);
   x = sin(angle);
   z = cos(angle);
-  cameraLookAt(&GAME_STATE.cameraLeft,
+  cameraLookAt(camera,
      x, 0.2,  z,
     -x, 0.2, -z
   );
 }
 
-void holdemRenderLookHand(camera_t *camera, uint8_t seat) {
+void pokerLookAtHand(camera_t *camera, uint8_t seat) {
   float x, z, angle;
-  angle = HOLDEM_GAME_SEAT_ANGLE(seat);
+  angle = POKER_SEAT_ANGLE(seat);
   x = sin(angle);
   z = cos(angle);
-  cameraLookAt(&GAME_STATE.cameraLeft,
+  cameraLookAt(camera,
     x*0.1, 0.8, z*0.1,
     -x*0.5, 0.2, -z*0.5
   );

src/poker/render/look.h

@@ -9,17 +9,17 @@
 #include "../../display/camera.h"
 
 /**
- * Look at a specific seat
+ * Look at a specific seats' player.
  * 
  * @param camera Camera to adjust.
  * @param seat Seat to look at.
  */
-void holdemRenderLookSeat(camera_t *camera, uint8_t seat);
+void pokerLookAtPlayer(camera_t *camera, uint8_t seat);
 
 /**
- * Look at a specific seats hand.
+ * Look at a specific seats' hand.
  * 
  * @param camera Camera to adjust.
  * @param seat Seats hand to look at.
  */
-void holdemRenderLookHand(camera_t *camera, uint8_t seat);
+void pokerLookAtHand(camera_t *camera, uint8_t seat);

src/poker/render/player.c

@@ -7,63 +7,62 @@
 
 #include "player.h"
 
-void holdemRenderPlayerInit() {
+void pokerPlayerInit(poker_t *poker) {
-  GAME_STATE.kagamiTexture = assetTextureLoad("kagami.png");
+  uint8_t i;
-  GAME_STATE.kagamiTileset = tilesetCreate(3, 2,
+  pokerplayer_t *player;
-    GAME_STATE.kagamiTexture->width,
+  float w, h;
-    GAME_STATE.kagamiTexture->height,
-    0, 0, 0, 0
-  );
-  GAME_STATE.kagamiQuad = quadCreate(0, 0, 0, 0, 0, 1, 1, 1, 1);
-}
 
-uint8_t holdemRenderPlayerGetSeatForPlayer(uint8_t player) { 
+  for(i = 0; i < POKER_PLAYER_COUNT; i++) {
-  switch(player) {
+    player = poker->players + i;
-    case 0x01:
+    assetTextureLoad(&player->bodyTexture, "characters/penny/body.png");
-      return HOLDEM_GAME_SEAT_PLAYER1;
+    assetTextureLoad(&player->faceTexture, "characters/penny/face.png");
-    case 0x02:
+
-      return HOLDEM_GAME_SEAT_PLAYER2;
+    w = 0.6;
-    case 0x03:
+    h=((float)player->faceTexture.width)/((float)player->faceTexture.height)*w;
-      return HOLDEM_GAME_SEAT_PLAYER3;
+    w = w / 2;
-    case 0x04:
+    h = h / 2;
-      return HOLDEM_GAME_SEAT_PLAYER4;
+    quadInit(&player->bodyPrimitive, 0,
-    default:
+      -w, -h, 0, 1,
-      return HOLDEM_GAME_SEAT_PLAYER0;
+       w,  h, 1, 0
+    );
+    quadInit(&player->facePrimitive, 0,
+      -w, -h, 0, 1,
+       w,  h, 1, 0
+    );
   }
 }
 
-void holdemRenderPlayer(uint8_t seat) {
+uint8_t pokerPlayerGetSeatForPlayer(uint8_t player) { 
+  switch(player) {
+    case 0x01:
+      return POKER_SEAT_PLAYER1;
+    case 0x02:
+      return POKER_SEAT_PLAYER2;
+    case 0x03:
+      return POKER_SEAT_PLAYER3;
+    case 0x04:
+      return POKER_SEAT_PLAYER4;
+    default:
+      return POKER_SEAT_PLAYER0;
+  }
+}
+
+void pokerPlayerRender(poker_t* poker, pokerplayer_t *player, uint8_t seat) {
   float x, z, angle;
+  float w, h;
 
   // Determine position
-  angle = HOLDEM_GAME_SEAT_ANGLE(seat);
+  angle = POKER_SEAT_ANGLE(seat);
   x = sin(angle) * -1;
   z = cos(angle) * -1;
 
-  // Determine size
+  shaderUsePosition(&poker->shader,  x,0.34,z,  0,angle,0);
-  float w, h;
-  w = 0.6, h = (
-    (float)GAME_STATE.kagamiTileset->divY /
-    (float)GAME_STATE.kagamiTileset->divX
-  ) * w;
 
-  // Animation
+  // Render Body
-  int i = (int32_t)(TIME_STATE.current*10)%GAME_STATE.kagamiTileset->count;
+  shaderUseTexture(&poker->shader, &player->bodyTexture);
-  quadBuffer(GAME_STATE.kagamiQuad, 0,
+  primitiveDraw(&player->bodyPrimitive, 0, -1);
-    -w/2, -h/2,
-    GAME_STATE.kagamiTileset->divisions[i].x0,
-    GAME_STATE.kagamiTileset->divisions[i].y1,
-    w/2, h/2,
-    GAME_STATE.kagamiTileset->divisions[i].x1,
-    GAME_STATE.kagamiTileset->divisions[i].y0,
-    0, 0
-  );
 
-  // Render
+  // Render Face
-  shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.kagamiTexture);
+  shaderUseTexture(&poker->shader, &player->faceTexture);
-  shaderUsePosition(GAME_STATE.shaderWorld,
+  primitiveDraw(&player->facePrimitive, 0, -1);
-    x, 0.34, z,
-    0, angle, 0
-  );
-  primitiveDraw(GAME_STATE.kagamiQuad, 0, -1);
 }

src/poker/render/player.h

@@ -15,20 +15,20 @@
 
 /**
  * Initializes the player renderer.
+ * @param poker Poker game context.
  */
-void holdemRenderPlayerInit();
+void pokerPlayerInit(poker_t *poker);
 
 /**
  * Returns the seat index for a given player.
- * 
  * @param player Player to get the seat for.
  * @return Seat ID for the given player.
  */
-uint8_t holdemRenderPlayerGetSeatForPlayer(uint8_t player);
+uint8_t pokerPlayerGetSeatForPlayer(uint8_t player);
 
 /**
  * Render's a player at a seat.
- * 
+ * @param poker Poker game context.
  * @param seat Seat to render the player at.
  */
-void holdemRenderPlayer(uint8_t seat);
+void pokerPlayerRender(poker_t *poker, pokerplayer_t *player, uint8_t seat);

src/poker/render/world.c

@@ -7,47 +7,24 @@
 
 #include "world.h"
 
-void holdemRenderWorldInit() {
+void pokerWorldInit(poker_t *poker) {
-  GAME_STATE.tablePrimitive = pokerTableCreate();
+  // Poker Table
-  GAME_STATE.tableTexture = assetTextureLoad("pokertable.png");
+  pokerTableInit(&poker->tablePrimitive);
+  assetTextureLoad(&poker->tableTexture, "pokertable.png");
 }
 
-void holdemRenderWorld() {
+void pokerWorldRender(poker_t *poker) {
-  uint8_t i, j;
-  pokerplayer_t *player;
-  uint8_t seat;
-
   // Poker Table
-  shaderUsePositionAndScale(GAME_STATE.shaderWorld,
+  shaderUsePositionAndScale(&poker->shader,
     0, -0.01, 0,
     0, 0, 0,
     3.4, 3.4, 3.4
   );
-  shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.tableTexture);
+  shaderUseTexture(&poker->shader, &poker->tableTexture);
-  primitiveDraw(GAME_STATE.tablePrimitive, 0, -1);
+  primitiveDraw(&poker->tablePrimitive, 0, -1);
+}
 
-  // Render the dealer and her hand
+void pokerWorldDispose(poker_t *poker) {
-  holdemRenderPlayer(HOLDEM_GAME_SEAT_DEALER);
+  textureDispose(&poker->tableTexture);
-  for(i = 0x00; i < GAME_STATE.cardsFacing; i++) {
+  primitiveDispose(&poker->tablePrimitive);
-    holdemRenderCardForSeat(
-      HOLDEM_GAME_SEAT_DEALER,
-      GAME_STATE.cards[i],
-      HOLDEM_GAME_CARD_SLOT_FLOP0 + i
-    );
-  }
-
-  // Test
-  for(i = 0x00; i < POKER_PLAYER_COUNT; i++) {
-    player = GAME_STATE.players + i;
-    seat = holdemRenderPlayerGetSeatForPlayer(i);
-    holdemRenderPlayer(seat);
-
-    if(player->state & POKER_PLAYER_STATE_SHOWING) continue;
-
-    for(j = 0x00; j < player->cardCount; j++) {
-      holdemRenderCardForSeat(seat, player->cards[j], HOLDEM_GAME_CARD_SLOT_HAND0+j);
-    }
-  }
-
-  holdemRenderChip();
 }

src/poker/render/world.h

@@ -7,17 +7,26 @@
 
 #pragma once
 #include <dawn/dawn.h>
-#include "player.h"
-#include "card.h"
-#include "chip.h"
 #include "../../assets/models/pokertable.h"
+#include "../../display/shader.h"
+#include "../../display/primitive.h"
+#include "../../display/texture.h"
+#include "../../file/asset.h"
 
 /**
  * Initializes the world renderer.
+ * @param poker Poker scene to initialize.
  */
-void holdemRenderWorldInit();
+void pokerWorldInit(poker_t *poker);
 
 /**
  * Renders the world.
+ * @param poker Poker scene to render.
  */
-void holdemRenderWorld();
+void pokerWorldRender(poker_t *poker);
+
+/**
+ * Disposes a poker world.
+ * @param poker Poker game to cleanup the world for.
+ */
+void pokerWorldDispose(poker_t *poker);

src/poker/round/deal.c

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+#include "deal.h"
+
+void pokerDealInit(poker_t *poker) {
+  uint8_t x, y;
+  card_t temporary;
+
+  // Prepare the initial game state
+  poker->round = POKER_ROUND_DEAL;
+  poker->pot = 0;
+  poker->roundBet = 0;
+  poker->graveSize = 0;
+  poker->cardsFacing = 0;
+  poker->deckSize = CARD_DECK_SIZE;
+  for(x = 0; x < CARD_DECK_SIZE; x++) poker->deck[x] = x;
+
+  // Reset the players
+  for(x = 0; x < POKER_PLAYER_COUNT; x++) {
+    poker->players[x].cardCount = 0;
+    poker->players[x].currentBet = 0;
+
+    // Invert then bitwise AND to turn off.
+    poker->players[x].state &= ~(
+      POKER_PLAYER_STATE_FOLDED | 
+      POKER_PLAYER_STATE_SHOWING
+    );
+  }
+
+  // Hard look at the dealer
+
+  // Shuffle the deck
+  for(x = 0; x < CARD_DECK_SIZE - 1; x++) {
+    // Select random element from remaining elements.
+    y = u8randRange(x, CARD_DECK_SIZE);
+    temporary = poker->deck[y];// Take out other card
+    poker->deck[y] = poker->deck[x];// Move my card there
+    poker->deck[x] = temporary;// Put other card here.
+  }
+}

src/poker/round/deal.h

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+
+/**
+ * Resets a poker game for the new round.
+ * @param poker Poker game to reset to a new round.
+ */
+void pokerDealInit(poker_t *poker);

temp/poker/card.c

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "card.h"
+
+void cardDeal(card_t *deck, card_t *hand, uint8_t deckSize, uint8_t handSize) {
+  card_t card;
+  card = deck[deckSize-1];
+  deck[deckSize-1] = 0x00;
+  hand[handSize] = card;
+}

temp/poker/poker.c

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "poker.h"
+
+void pokerInit(poker_t *poker) {
+  uint8_t x;
+
+  // Prepare the initial game state
+  poker->round = POKER_ROUND_DEAL;
+  poker->roundPlayer = 0x00;
+  poker->roundDealer = 0x00;
+  poker->blindSmall = 0;
+  poker->blindBig = 0;
+
+  for(x = 0; x < POKER_PLAYER_COUNT; x++) {
+    poker->players[x].state = 0x00;
+    poker->players[x].chips = 0;
+    poker->players[x].cardCount = 0;
+    poker->players[x].currentBet = 0;
+  }
+
+  pokerRoundInit(poker);
+}
+
+void pokerRoundInit(poker_t *poker) {
+  uint8_t x;
+
+  // Refill the deck
+  cardDeckFill(poker->deck);
+  poker->deckSize = CARD_DECK_SIZE;
+
+  // Reset the players
+  for(x = 0; x < POKER_PLAYER_COUNT; x++) {
+    poker->players[x].cardCount = 0;
+    poker->players[x].currentBet = 0;
+  }
+}

temp/poker/poker.h

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "card.h"
+
+/**
+ * Initializes the poker match for the first time.
+ * 
+ * @param poker Poker game to init.
+ */
+void pokerInit(poker_t *poker);
+
+
+/**
+ * Initializes the round for a poker game.
+ * 
+ * @param poker Poker game to init a new round for.
+ */
+void pokerRoundInit(poker_t *poker);

temp/render/card.c

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "card.h"
+
+void holdemRenderCardInit() {
+  tilesetdiv_t *cardBack;
+
+  // Load Cards Texture
+  GAME_STATE.cardTexture = assetTextureLoad("cards_normal.png");
+  GAME_STATE.cardTileset = tilesetCreate(CARD_COUNT_PER_SUIT, 6,
+    GAME_STATE.cardTexture->width, GAME_STATE.cardTexture->height,
+    0, 0, 0, 0
+  );
+
+  // Cards Primitive
+  cardBack = GAME_STATE.cardTileset->divisions+(
+    GAME_STATE.cardTileset->columns * 4
+  );
+  GAME_STATE.cardPrimitive = primitiveCreate(
+    QUAD_VERTICE_COUNT * 2, QUAD_INDICE_COUNT * 2
+  );
+  quadBuffer(GAME_STATE.cardPrimitive, -HOLDEM_GAME_CARD_DEPTH,
+    -HOLDEM_GAME_CARD_WIDTH, -HOLDEM_GAME_CARD_HEIGHT,
+    cardBack->x0, cardBack->y1,
+    HOLDEM_GAME_CARD_WIDTH, HOLDEM_GAME_CARD_HEIGHT,
+    cardBack->x1, cardBack->y0,
+    QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT
+  );
+}
+
+pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot) {
+  pokerposition_t position;
+  float t, t2;
+
+  position.yaw = HOLDEM_GAME_SEAT_ANGLE(seat);
+  position.x = sin(position.yaw) * -0.75;
+  position.z = cos(position.yaw) * -0.75;
+
+  t = position.yaw + mathDeg2Rad(90);
+
+  switch (slot) {
+    case HOLDEM_GAME_CARD_SLOT_HAND0:
+    case HOLDEM_GAME_CARD_SLOT_HAND1:
+      t2 = HOLDEM_GAME_CARD_WIDTH+HOLDEM_GAME_CARD_PADDING;
+      if(slot == HOLDEM_GAME_CARD_SLOT_HAND0) t2 = -t2;
+      t2 += 0.1;
+      break;
+      
+    case HOLDEM_GAME_CARD_SLOT_FLOP0:
+    case HOLDEM_GAME_CARD_SLOT_FLOP1:
+    case HOLDEM_GAME_CARD_SLOT_FLOP2:
+    case HOLDEM_GAME_CARD_SLOT_FLOP3:
+    case HOLDEM_GAME_CARD_SLOT_FLOP4:
+      t2 = HOLDEM_GAME_CARD_WIDTH*2+HOLDEM_GAME_CARD_PADDING;
+      t2 = (
+        -t2 * ( HOLDEM_GAME_CARD_SLOT_FLOP4-HOLDEM_GAME_CARD_SLOT_FLOP0)
+      )/2 + t2*(slot-HOLDEM_GAME_CARD_SLOT_FLOP0);
+      break;
+
+    default:
+      break;
+  }
+
+  position.x += t2 * sin(t);
+  position.z += t2 * cos(t);
+  
+  return position;
+}
+
+void holdemRenderCard(card_t card, float x, float y, float z,
+  float pitch, float yaw, float roll
+) {
+  tilesetdiv_t *cardFront = GAME_STATE.cardTileset->divisions + card;
+  quadBuffer(GAME_STATE.cardPrimitive, HOLDEM_GAME_CARD_DEPTH,
+    -HOLDEM_GAME_CARD_WIDTH, -HOLDEM_GAME_CARD_HEIGHT, 
+    cardFront->x0, cardFront->y1,
+    HOLDEM_GAME_CARD_WIDTH, HOLDEM_GAME_CARD_HEIGHT,
+    cardFront->x1, cardFront->y0,
+    0, 0
+  );
+
+  shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.cardTexture);
+  shaderUsePosition(GAME_STATE.shaderWorld, x,y,z, pitch,yaw,roll);
+  primitiveDraw(GAME_STATE.cardPrimitive, 0, -1);
+}
+
+void holdemRenderCardForSeat(uint8_t seat, card_t card, uint8_t slot) {
+  pokerposition_t position = holdemRenderCardGetPosition(seat, slot);
+  holdemRenderCard(card, position.x, 0, position.z, mathDeg2Rad(-90), position.yaw, 0);
+}

temp/render/card.h

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "../../file/asset.h"
+#include "../../display/shader.h"
+#include "../../display/primitive.h"
+#include "../../display/primitives/quad.h"
+#include "../../display/tileset.h"
+
+/**
+ * Initializes the Card Renderer.
+ */
+void holdemRenderCardInit();
+
+/**
+ * Returns the position a card "naturally" sits at for a given seat and slot.
+ * 
+ * @param seat Seat that the card belongs to
+ * @param slot Slot within the player/dealers' hand that the card belongs to.
+ * @return A struct containing X, Z and YAW properties.
+ */
+pokerposition_t holdemRenderCardGetPosition(uint8_t seat, uint8_t slot);
+
+/**
+ * Render's a given card at the specified coordinates. Card is a reused quad 
+ * and is re-buffered to for every draw call.
+ * 
+ * @param card Card to render.
+ * @param x X Position (world space).
+ * @param y Y Position (world space).
+ * @param z Z Position (world space).
+ * @param pitch Pitch angle.
+ * @param yaw Yaw angle.
+ * @param roll Roll angle.
+ */
+void holdemRenderCard(card_t card, float x, float y, float z,
+  float pitch, float yaw, float roll
+);
+
+/**
+ * Render's a card at a given seat and slot.
+ * 
+ * @param seat Seat the card is for.
+ * @param card Card to render.
+ * @param slot Slot the card is for.
+ */
+void holdemRenderCardForSeat(uint8_t seat, card_t card, uint8_t slot);

temp/render/look.c

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "look.h"
+
+void holdemRenderLookSeat(camera_t *camera, uint8_t seat) {
+  float x, z, angle;
+  angle = HOLDEM_GAME_SEAT_ANGLE(seat);
+  x = sin(angle);
+  z = cos(angle);
+  cameraLookAt(&GAME_STATE.cameraLeft,
+     x, 0.2,  z,
+    -x, 0.2, -z
+  );
+}
+
+void holdemRenderLookHand(camera_t *camera, uint8_t seat) {
+  float x, z, angle;
+  angle = HOLDEM_GAME_SEAT_ANGLE(seat);
+  x = sin(angle);
+  z = cos(angle);
+  cameraLookAt(&GAME_STATE.cameraLeft,
+    x*0.1, 0.8, z*0.1,
+    -x*0.5, 0.2, -z*0.5
+  );
+}

temp/render/look.h

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <dawn/dawn.h>
+#include "../../display/camera.h"
+
+/**
+ * Look at a specific seat
+ * 
+ * @param camera Camera to adjust.
+ * @param seat Seat to look at.
+ */
+void holdemRenderLookSeat(camera_t *camera, uint8_t seat);
+
+/**
+ * Look at a specific seats hand.
+ * 
+ * @param camera Camera to adjust.
+ * @param seat Seats hand to look at.
+ */
+void holdemRenderLookHand(camera_t *camera, uint8_t seat);

temp/render/player.c

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "player.h"
+
+void holdemRenderPlayerInit(poker_t *poker) {
+  
+
+  GAME_STATE.kagamiTexture = assetTextureLoad("kagami.png");
+  GAME_STATE.kagamiTileset = tilesetCreate(3, 2,
+    GAME_STATE.kagamiTexture->width,
+    GAME_STATE.kagamiTexture->height,
+    0, 0, 0, 0
+  );
+  GAME_STATE.kagamiQuad = quadCreate(0, 0, 0, 0, 0, 1, 1, 1, 1);
+}
+
+uint8_t holdemRenderPlayerGetSeatForPlayer(uint8_t player) { 
+  switch(player) {
+    case 0x01:
+      return HOLDEM_GAME_SEAT_PLAYER1;
+    case 0x02:
+      return HOLDEM_GAME_SEAT_PLAYER2;
+    case 0x03:
+      return HOLDEM_GAME_SEAT_PLAYER3;
+    case 0x04:
+      return HOLDEM_GAME_SEAT_PLAYER4;
+    default:
+      return HOLDEM_GAME_SEAT_PLAYER0;
+  }
+}
+
+void holdemRenderPlayer(uint8_t seat) {
+  float x, z, angle;
+
+  // Determine position
+  angle = HOLDEM_GAME_SEAT_ANGLE(seat);
+  x = sin(angle) * -1;
+  z = cos(angle) * -1;
+
+  // Determine size
+  float w, h;
+  w = 0.6, h = (
+    (float)GAME_STATE.kagamiTileset->divY /
+    (float)GAME_STATE.kagamiTileset->divX
+  ) * w;
+
+  // Animation
+  int i = (int32_t)(TIME_STATE.current*10)%GAME_STATE.kagamiTileset->count;
+  quadBuffer(GAME_STATE.kagamiQuad, 0,
+    -w/2, -h/2,
+    GAME_STATE.kagamiTileset->divisions[i].x0,
+    GAME_STATE.kagamiTileset->divisions[i].y1,
+    w/2, h/2,
+    GAME_STATE.kagamiTileset->divisions[i].x1,
+    GAME_STATE.kagamiTileset->divisions[i].y0,
+    0, 0
+  );
+
+  // Render
+  shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.kagamiTexture);
+  shaderUsePosition(GAME_STATE.shaderWorld,
+    x, 0.34, z,
+    0, angle, 0
+  );
+  primitiveDraw(GAME_STATE.kagamiQuad, 0, -1);
+}

temp/render/player.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "../../file/asset.h"
+#include "../../display/shader.h"
+#include "../../display/primitive.h"
+#include "../../display/tileset.h"
+#include "../../display/primitives/quad.h"
+
+/**
+ * Initializes the player renderer.
+ */
+void holdemRenderPlayerInit();
+
+/**
+ * Returns the seat index for a given player.
+ * 
+ * @param player Player to get the seat for.
+ * @return Seat ID for the given player.
+ */
+uint8_t holdemRenderPlayerGetSeatForPlayer(uint8_t player);
+
+/**
+ * Render's a player at a seat.
+ * 
+ * @param seat Seat to render the player at.
+ */
+void holdemRenderPlayer(uint8_t seat);

temp/render/world.c

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "world.h"
+
+void holdemRenderWorldInit() {
+  GAME_STATE.tablePrimitive = pokerTableCreate();
+  GAME_STATE.tableTexture = assetTextureLoad("pokertable.png");
+}
+
+void holdemRenderWorld() {
+  uint8_t i, j;
+  pokerplayer_t *player;
+  uint8_t seat;
+
+  // Poker Table
+  shaderUsePositionAndScale(GAME_STATE.shaderWorld,
+    0, -0.01, 0,
+    0, 0, 0,
+    3.4, 3.4, 3.4
+  );
+  shaderUseTexture(GAME_STATE.shaderWorld, GAME_STATE.tableTexture);
+  primitiveDraw(GAME_STATE.tablePrimitive, 0, -1);
+
+  // Render the dealer and her hand
+  holdemRenderPlayer(HOLDEM_GAME_SEAT_DEALER);
+  for(i = 0x00; i < GAME_STATE.cardsFacing; i++) {
+    holdemRenderCardForSeat(
+      HOLDEM_GAME_SEAT_DEALER,
+      GAME_STATE.cards[i],
+      HOLDEM_GAME_CARD_SLOT_FLOP0 + i
+    );
+  }
+
+  // Test
+  for(i = 0x00; i < POKER_PLAYER_COUNT; i++) {
+    player = GAME_STATE.players + i;
+    seat = holdemRenderPlayerGetSeatForPlayer(i);
+    holdemRenderPlayer(seat);
+
+    if(player->state & POKER_PLAYER_STATE_SHOWING) continue;
+
+    for(j = 0x00; j < player->cardCount; j++) {
+      holdemRenderCardForSeat(seat, player->cards[j], HOLDEM_GAME_CARD_SLOT_HAND0+j);
+    }
+  }
+
+  holdemRenderChip();
+}

temp/render/world.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "player.h"
+#include "card.h"
+#include "chip.h"
+#include "../../assets/models/pokertable.h"
+
+/**
+ * Initializes the world renderer.
+ */
+void holdemRenderWorldInit();
+
+/**
+ * Renders the world.
+ */
+void holdemRenderWorld();