Committing current progress.

include/dawn/dawn.h

@@ -66,6 +66,7 @@
 // User Interface Objects
 #include "ui/frame.h"
 #include "ui/label.h"
+#include "ui/menu.h"
 
 // Utility Objects
 #include "util/array.h"

include/dawn/physics/aabb.h

@@ -13,4 +13,14 @@ typedef struct {
 
   float normalX;
   float normalY;
-} aabbpointhit_t;
+} aabbpointhit2d_t;
+
+typedef struct {
+  float time;
+  
+  float normalX;
+  float normalY;
+
+  float hitX;
+  float hitY;
+} aabbvectorhit2d_t;

include/dawn/ui/menu.h

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+
+#define MENU_ITEMS_COLUMNS_MAX 16
+#define MENU_ITEMS_ROWS_MAX 128
+#define MENU_ITEMS_MAX MENU_ITEMS_COLUMNS_MAX * MENU_ITEMS_ROWS_MAX
+
+#define MENU_DIRECTION_DOWN 0x01
+#define MENU_DIRECTION_UP 0x02
+#define MENU_DIRECTION_LEFT 0x03
+#define MENU_DIRECTION_RIGHT 0x04
+
+#define MENU_HOLD_DURATION 1.0
+
+typedef struct {
+  int32_t bruh;
+} menuitem_t;
+
+typedef struct {
+  int32_t columns;
+  int32_t rows;
+
+  int32_t x;
+  int32_t y;
+  
+  uint8_t direction;
+
+  menuitem_t* items[MENU_ITEMS_MAX];
+  bool holdAllow;
+  float holdLast;
+} menu_t;

include/dawn/util/math.h

@@ -16,4 +16,5 @@
 #define mathAbs(n)    (n<0?-n:n)
 #define mathDeg2Rad(n) (n * M_PI / 180.0)
 #define mathRad2Deg(n) (n * 180 / M_PI)
-#define mathSign(n) (n>=0 ? 1 : -1)
+#define mathSign(n) (n>=0 ? 1 : -1)
+#define mathClamp(val,min,max) mathMin(mathMax(val,min),max)

src/game/poker/pokergame.c

@@ -7,10 +7,6 @@
 
 #include "pokergame.h"
 
-primitive_t primitive;
-primitive_t dot;
-float x, y;
-
 bool pokerGameInit(game_t *game) {
   pokergame_t *pokerGame = &game->pokerGame;
 
@@ -25,11 +21,6 @@ bool pokerGameInit(game_t *game) {
   pokerGameActionStartAdd(pokerGame);
   queueNext(&pokerGame->scene.conversation.actionQueue);
 
-  // 
-  quadInit(&primitive, 0,  0,0,0,0,  64,64,1,1);
-  quadInit(&dot, 0,  0,0,0,0,  2,2,1,1);
-  x = 0, y = 0;
-
   return true;
 } 
 
@@ -38,35 +29,15 @@ void pokerGameUpdate(game_t *game) {
   pokerGame = &game->pokerGame;
 
   // Update the scene
-  // vnSceneUpdate(&pokerGame->scene, &game->engine);
+  vnSceneUpdate(&pokerGame->scene, &game->engine);
 
   // Bind the shader.
   shaderUse(&pokerGame->assets.shader);
 
-
   // Render the visual novel scene
-  // vnSceneRenderWorld(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
+  vnSceneRenderWorld(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
   vnSceneRenderGui(&pokerGame->scene, &game->engine, &pokerGame->assets.shader);
-
+  pokerUiRender(pokerGame);
-  shaderUseTexture(&pokerGame->assets.shader, &pokerGame->assets.testTexture);
-
-  x = inputGetAxis(&game->engine.input, INPUT_MOUSE_X);
-  y = inputGetAxis(&game->engine.input, INPUT_MOUSE_Y);
-  
-  aabbpointhit_t hitting;
-  bool hit = aabbPoint2D(x, y, 64,64, 64,64, &hitting);
-
-  shaderUsePosition(&pokerGame->assets.shader,  64,64,0,  0,0,0);
-  primitiveDraw(&primitive, 0, -1);
-
-  if(hit) {
-    shaderUsePosition(&pokerGame->assets.shader,  hitting.hitX,hitting.hitY,0,  0,0,0);
-  } else {
-    shaderUsePosition(&pokerGame->assets.shader,  x,y,0,  0,0,0);
-  }
-  primitiveDraw(&dot, 0, -1);
-
-  // pokerUiRender(pokerGame);
 }
 
 void pokerGameDispose(game_t *game) {

src/physics/aabb.c

@@ -10,7 +10,7 @@
 bool aabbPoint2D(
   float pointX, float pointY,
   float x, float y, float width, float height,
-  aabbpointhit_t *hit
+  aabbpointhit2d_t *hit
 ) {
 
   float dx, px, sx, halfWidth;
@@ -55,3 +55,46 @@ bool aabbPoint2D(
   return true;
 }
 
+bool aabbVector2D(
+  float x, float y,
+  float vx, float vy,
+  float bx, float by, float width, float height,
+  aabbvectorhit2d_t *hit
+) {
+  // float halfWidth = width / 2.0;
+  // float halfHeight = height / 2.0;
+  // float paddingX = 0;
+  // float paddingY = 0;
+
+  // float scaleX = 1.0 / vx;
+  // float scaleY = 1.0 / vy;
+  // float signX = mathSign(scaleX);
+  // float signY = mathSign(scaleY);
+
+  // float nearTimeX = (bx - signX * (halfWidth + paddingX) - bx) * scaleX;
+  // float nearTimeY = (by - signY * (halfHeight + paddingY) - by) * scaleY;
+  // float farTimeX = (bx + signX * (halfWidth + paddingX) - bx) * scaleX;
+  // float farTimeY = (by + signY * (halfHeight + paddingY) - by) * scaleY;
+
+  // if(nearTimeX > farTimeY || nearTimeY > farTimeX) return false;
+
+  // float nearTime = nearTimeX > nearTimeY ? nearTimeX : nearTimeY;
+  // float farTime = farTimeX < farTimeY ? farTimeX : farTimeY;
+  // if (nearTime >= 1 || farTime <= 0) return false;
+
+  // hit->time = mathClamp(nearTime, 0, 1);
+  // if(nearTimeX > nearTimeY) {
+  //   hit->normalX = -signX;
+  //   hit->normalY = 0;
+  // } else {
+  //   hit->normalX = 0;
+  //   hit->normalY = -signY;
+  // }
+
+  // float deltaX = (1.0 - hit->time) * -vx;
+  // float deltaY = (1.0 - hit->time) * -vy;
+  // hit->hitX = bx + deltaX * hit->time;
+  // hit->hitY = by + deltaY * hit->time;
+
+  return true;
+}

src/physics/aabb.h

@@ -13,5 +13,11 @@
 bool aabbPoint2D(
   float pointX, float pointY,
   float x, float y, float width, float height,
-  aabbpointhit_t *hit
+  aabbpointhit2d_t *hit
+);
+
+bool aabbVector2D(
+  float x, float y, float vx, float vy,
+  float bx, float by, float width, float height,
+  aabbvectorhit2d_t *vector
 );

src/ui/menu.c

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "menu.h"
+
+void menuInit(menu_t *menu, int32_t columns, int32_t rows) {
+  int32_t i;
+  menu->columns = columns;
+  menu->rows = rows;
+  menu->holdAllow = true;
+  menu->direction = 0x00;
+  for(i = 0; i < MENU_ITEMS_MAX; i++) menu->items[i] = NULL;
+}
+
+void menuUpdate(menu_t *menu, engine_t *engine) {
+  inputbind_t bind;
+  float heldTime, heldDue;
+
+  // Handle press binds.
+  if(inputIsPressed(&engine->input, INPUT_DOWN)) {
+    menu->y = (menu->y + 1) % menu->rows;
+    menu->direction = MENU_DIRECTION_DOWN;
+  } else if(inputIsPressed(&engine->input, INPUT_UP)) {
+    menu->y = (menu->y - 1) % menu->rows;
+    menu->direction = MENU_DIRECTION_DOWN;
+  } else if(inputIsPressed(&engine->input, INPUT_LEFT)) {
+    menu->x = (menu->x - 1) % menu->columns;
+    menu->direction = MENU_DIRECTION_DOWN;
+  } else if(inputIsPressed(&engine->input, INPUT_RIGHT)) {
+    menu->x = (menu->x + 1) % menu->columns;
+    menu->direction = MENU_DIRECTION_DOWN;
+  }
+
+  // Handle held
+  if(menu->holdAllow && menu->direction != 0x00) {
+    bind = (
+      menu->direction == MENU_DIRECTION_DOWN ? INPUT_DOWN :
+      menu->direction == MENU_DIRECTION_UP ? INPUT_UP :
+      menu->direction == MENU_DIRECTION_LEFT ? INPUT_LEFT :
+      menu->direction == MENU_DIRECTION_RIGHT ? INPUT_RIGHT :
+      INPUT_NULL
+    );
+
+    if(inputIsDown(&engine->input, bind)) {
+      heldTime = engine->time.current - inputGetAccuated(&engine->input, bind);
+      heldDue = engine->time.current - menu->holdLast;
+      
+      // Have we held long enough?
+      if(heldTime >= MENU_HOLD_DURATION) {
+        
+        menu->holdLast = engine->time.current;
+      }
+    } else {
+      menu->holdLast = engine->time.current;
+    }
+  }
+
+  // Handle Mouse
+
+}

src/ui/menu.h

@@ -0,0 +1,28 @@
+/**
+ * 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 "../input/input.h"
+#include "../epoch/epoch.h"
+
+/**
+ * Initialize a menu.
+ * 
+ * @param menu Menu to initialize.
+ * @param columns Count of rows.
+ * @param rows Count of columns.
+ */
+void menuInit(menu_t *menu, int32_t columns, int32_t rows);
+
+/**
+ * Updates the menu to handle inputs.
+ * 
+ * @param menu Menu to update.
+ * @param engine Engine to update from.
+ */
+void menuUpdate(menu_t *menu, engine_t *engine);

src/vn/vnscene.c

@@ -80,5 +80,5 @@ void vnSceneRenderGui(vnscene_t *scene, engine_t *engine, shader_t *shader) {
   shaderUseCamera(shader, &scene->camera);
 
   // Render Conversation Element
-  // vnConversationRender(&scene->conversation, shader);
+  vnConversationRender(&scene->conversation, shader);
 }