Added AABB Point

CMakeLists.txt

@@ -24,9 +24,9 @@ set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/modules)
 set(SETTING_PLATFORM_GLFW 1)
 set(SETTING_PLATFORM_SDL 2)
 set(SETTING_PLATFORM_GBM 3)
-set(SETTING_PLATFORM SETTING_PLATFORM_GBM)
+set(SETTING_PLATFORM SETTING_PLATFORM_GLFW)
 
-set(SETTING_USE_GLAD 0)
+set(SETTING_USE_GLAD 1)
 
 # Game Settings
 set(SETTING_GAME_POKER 1)
@@ -86,7 +86,6 @@ add_executable(${PROJECT_NAME} ${HEADER_FILES} ${SOURCE_FILES})
 # Math
 if(NOT WIN32)
   target_link_libraries(${PROJECT_NAME} m)
-  target_link_libraries(${PROJECT_NAME} ${CMAKE_DL_LIBS})
 endif()
 
 # GLAD
@@ -126,15 +125,14 @@ endif()
 
 
 # CGLM
-add_subdirectory(${CMAKE_SOURCE_DIR}/lib/cglm)
+if(NOT cglm_FOUND)
-# if(NOT cglm_FOUND)
+  FetchContent_Declare(
-#   FetchContent_Declare(
+    cglm
-#     cglm
+    GIT_REPOSITORY https://github.com/recp/cglm
-#     GIT_REPOSITORY https://github.com/recp/cglm
+    GIT_TAG v0.8.3
-#     GIT_TAG v0.8.3
+  )
-#   )
+  FetchContent_MakeAvailable(cglm)
-#   FetchContent_MakeAvailable(cglm)
+endif()
-# endif()
 target_link_libraries(${PROJECT_NAME} cglm)
 
 # OpenGL

include/dawn/dawn.h

@@ -51,6 +51,9 @@
 // Locales
 #include "locale/language.h"
 
+// Physics
+#include "physics/aabb.h"
+
 // Poker Game Logic
 #include "poker/turn.h"
 #include "poker/bet.h"

include/dawn/input/input.h

@@ -19,6 +19,10 @@
 #define INPUT_DEBUG_PLUS  (inputbind_t)0x08
 #define INPUT_DEBUG_MINUS (inputbind_t)0x09
 
+/** Reserved Inputs (Starts at 64) */
+#define INPUT_MOUSE_X     (inputbind_t)0x40
+#define INPUT_MOUSE_Y     (inputbind_t)0x41
+
 /** Real Inputs (Starts at 128/0x80) */
 #define INPUT_UP          (inputbind_t)0x80
 #define INPUT_DOWN        (inputbind_t)0x81
@@ -26,9 +30,8 @@
 #define INPUT_RIGHT       (inputbind_t)0x83
 #define INPUT_ACCEPT      (inputbind_t)0x84
 
-
 #define INPUT_BIND_COUNT 0xFF
-#define INPUT_SOURCE_COUNT 0xFF
+#define INPUT_SOURCE_COUNT 1024
 
 /**
  * Input Bind, a specific action bind reference for the game engine to use.
@@ -41,7 +44,7 @@ typedef uint8_t inputbind_t;
  * hell this number refers to. For most platforms it will be an input, such as a
  * keyboard scancode or a (pad number * button count) + button.
  */
-typedef uint8_t inputsource_t;
+typedef uint16_t inputsource_t;
 
 /**
  * Value that represents the state of an input. Defined as 0-1 where 0 is set

include/dawn/libs.h

@@ -16,6 +16,7 @@
 #endif
 
 #if SETTING_PLATFORM == SETTING_PLATFORM_GLFW
+  #include <GLFW/glfw3.h>
 #elif SETTING_PLATFORM == SETTING_PLATFORM_SDL
   #include <SDL2/SDL.h>
   #include <SDL2/SDL_opengl.h>
@@ -41,6 +42,7 @@
 #include <stdbool.h>
 #include <malloc.h>
 #include <string.h>
+#include <math.h>
 
 #if defined(_WIN32) || defined(_WIN64)
   // Windows Fixes
@@ -48,5 +50,4 @@
   # define sleep(n) _sleep(n)
 #else
   #include <unistd.h>
-  #include <math.h>
 #endif

include/dawn/physics/aabb.h

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+
+typedef struct {
+  float hitX;
+  float hitY;
+
+  float normalX;
+  float normalY;
+} aabbpointhit_t;

include/dawn/util/math.h

@@ -15,4 +15,5 @@
 #define mathMin(a,b)  (a>b?b:a)
 #define mathAbs(n)    (n<0?-n:n)
 #define mathDeg2Rad(n) (n * M_PI / 180.0)
-#define mathRad2Deg(n) (n * 180 / M_PI)
+#define mathRad2Deg(n) (n * 180 / M_PI)
+#define mathSign(n) (n>=0 ? 1 : -1)

platform/glfw/glwfwplatform.c

@@ -17,8 +17,8 @@ int32_t main() {
   glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, false);
 
   // Create Window
-  window = glfwCreateWindow(WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT,
+  window = glfwCreateWindow(
-    "", NULL, NULL
+    WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT, "", NULL, NULL
   );
   if(!window) {
     glfwTerminate();
@@ -33,8 +33,8 @@ int32_t main() {
   // Setup window listeners
   glfwSetWindowSizeCallback(window, &glfwOnResize);
   glfwSetKeyCallback(window, &glfwOnKey);
-
   glfwSetErrorCallback(&glfwOnError);
+  glfwSetCursorPosCallback(window, &glfwOnCursor);
 
   // Prepare the game
   game_t *game = malloc(sizeof(game_t));
@@ -51,28 +51,33 @@ int32_t main() {
   // Init the game
   if(gameInit(game)) {
     // Bind initial keys
-    inputBind(input, INPUT_NULL,         (inputsource_t)GLFW_KEY_ESCAPE);
+    inputBind(input, INPUT_NULL,          (inputsource_t)GLFW_KEY_ESCAPE);
-    inputBind(input, INPUT_DEBUG_UP,     (inputsource_t)GLFW_KEY_W);
+    inputBind(input, INPUT_DEBUG_UP,      (inputsource_t)GLFW_KEY_W);
-    inputBind(input, INPUT_DEBUG_DOWN,   (inputsource_t)GLFW_KEY_S);
+    inputBind(input, INPUT_DEBUG_DOWN,    (inputsource_t)GLFW_KEY_S);
-    inputBind(input, INPUT_DEBUG_LEFT,   (inputsource_t)GLFW_KEY_A);
+    inputBind(input, INPUT_DEBUG_LEFT,    (inputsource_t)GLFW_KEY_A);
-    inputBind(input, INPUT_DEBUG_RIGHT,  (inputsource_t)GLFW_KEY_D);
+    inputBind(input, INPUT_DEBUG_RIGHT,   (inputsource_t)GLFW_KEY_D);
-    inputBind(input, INPUT_DEBUG_RAISE,  (inputsource_t)GLFW_KEY_Q);
+    inputBind(input, INPUT_DEBUG_RAISE,   (inputsource_t)GLFW_KEY_Q);
-    inputBind(input, INPUT_DEBUG_LOWER,  (inputsource_t)GLFW_KEY_E);
+    inputBind(input, INPUT_DEBUG_LOWER,   (inputsource_t)GLFW_KEY_E);
-    inputBind(input, INPUT_DEBUG_FINE,   (inputsource_t)GLFW_KEY_LEFT_CONTROL);
+    inputBind(input, INPUT_DEBUG_FINE,    (inputsource_t)GLFW_KEY_LEFT_CONTROL);
-    inputBind(input, INPUT_DEBUG_PLUS,   (inputsource_t)GLFW_KEY_EQUAL);
+    inputBind(input, INPUT_DEBUG_PLUS,    (inputsource_t)GLFW_KEY_EQUAL);
-    inputBind(input, INPUT_DEBUG_MINUS,  (inputsource_t)GLFW_KEY_MINUS);
+    inputBind(input, INPUT_DEBUG_MINUS,   (inputsource_t)GLFW_KEY_MINUS);
 
-    inputBind(input, INPUT_UP,           (inputsource_t)GLFW_KEY_UP);
+    inputBind(input, INPUT_UP,            (inputsource_t)GLFW_KEY_UP);
-    inputBind(input, INPUT_DOWN,         (inputsource_t)GLFW_KEY_DOWN);
+    inputBind(input, INPUT_DOWN,          (inputsource_t)GLFW_KEY_DOWN);
-    inputBind(input, INPUT_LEFT,         (inputsource_t)GLFW_KEY_LEFT);
+    inputBind(input, INPUT_LEFT,          (inputsource_t)GLFW_KEY_LEFT);
-    inputBind(input, INPUT_RIGHT,        (inputsource_t)GLFW_KEY_RIGHT);
+    inputBind(input, INPUT_RIGHT,         (inputsource_t)GLFW_KEY_RIGHT);
-    inputBind(input, INPUT_UP,           (inputsource_t)GLFW_KEY_W);
+    inputBind(input, INPUT_UP,            (inputsource_t)GLFW_KEY_W);
-    inputBind(input, INPUT_DOWN,         (inputsource_t)GLFW_KEY_S);
+    inputBind(input, INPUT_DOWN,          (inputsource_t)GLFW_KEY_S);
-    inputBind(input, INPUT_LEFT,         (inputsource_t)GLFW_KEY_A);
+    inputBind(input, INPUT_LEFT,          (inputsource_t)GLFW_KEY_A);
-    inputBind(input, INPUT_RIGHT,        (inputsource_t)GLFW_KEY_D);
+    inputBind(input, INPUT_RIGHT,         (inputsource_t)GLFW_KEY_D);
-    inputBind(input, INPUT_ACCEPT,       (inputsource_t)GLFW_KEY_E);
+    inputBind(input, INPUT_ACCEPT,        (inputsource_t)GLFW_KEY_E);
-    inputBind(input, INPUT_ACCEPT,       (inputsource_t)GLFW_KEY_ENTER);
+    inputBind(input, INPUT_ACCEPT,        (inputsource_t)GLFW_KEY_ENTER);
-    inputBind(input, INPUT_ACCEPT,       (inputsource_t)GLFW_KEY_SPACE);
+    inputBind(input, INPUT_ACCEPT,        (inputsource_t)GLFW_KEY_SPACE);
+
+    // Bind the fake inputs
+    inputBind(input, INPUT_MOUSE_X,       (inputsource_t)INPUT_MOUSE_X);
+    inputBind(input, INPUT_MOUSE_Y,       (inputsource_t)INPUT_MOUSE_Y);
+    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
 
     // Update the window title.
     glfwSetWindowTitle(window, SETTING_GAME_NAME);
@@ -123,4 +128,10 @@ void glfwOnKey(GLFWwindow *window,
 
 void glfwOnError(int error, const char* description) {
   fputs(description, stderr);
+}
+
+void glfwOnCursor(GLFWwindow *window, double x, double y) {
+  input_t *input = &GAME_STATE->engine.input;
+  input->buffer[INPUT_MOUSE_X] = x;
+  input->buffer[INPUT_MOUSE_Y] = y;
 }

platform/glfw/glwfwplatform.h

@@ -5,11 +5,6 @@
 
 #pragma once
 
-// I load GLAD and GLFW Here because they need to be included in specific orders
-#if SETTING_USE_GLAD == 1
-  #include <glad/glad.h>
-#endif
-#include <GLFW/glfw3.h>
 #include <dawn/dawn.h>
 #include "../../src/display/render.h"
 #include "../../src/game/game.h"
@@ -49,4 +44,5 @@ void glfwOnKey(GLFWwindow *window,
 );
 
 
-void glfwOnError(int error, const char* description);
+void glfwOnError(int error, const char* description);
+void glfwOnCursor(GLFWwindow *window, double x, double y);

src/display/framebuffer.c

@@ -25,11 +25,11 @@ void frameBufferInit(framebuffer_t *fb, int32_t w, int32_t h) {
   // Render Buffer
   glGenRenderbuffers(1, &fb->rboId);
   glBindRenderbuffer(GL_RENDERBUFFER, fb->rboId); 
-  // glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, w, h);
+  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, w, h);
   glBindRenderbuffer(GL_RENDERBUFFER, 0);
-  // glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
-  //   GL_RENDERBUFFER, fb->rboId
+    GL_RENDERBUFFER, fb->rboId
-  // );
+  );
 
   if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
     uint32_t error;

src/display/render.c

@@ -18,7 +18,7 @@ void renderInit() {
   glDepthMask(GL_TRUE);
   glDepthFunc(GL_LEQUAL);
 
-  glClearColor(1.0, 0, 0, 1.0);
+  glClearColor(0,0,0, 1.0);
 }
 
 void renderFrameStart(render_t *render) {

src/game/game.c

@@ -7,6 +7,11 @@
 
 #include "game.h"
 
+#include "../physics/vector.h"
+
+primitive_t primitive;
+texture_t texture;
+
 bool gameInit(game_t *game) {
   // Init the engine and the rendering pipeline
   engineInit(&game->engine, game);

src/game/poker/pokergame.c

@@ -7,6 +7,10 @@
 
 #include "pokergame.h"
 
+primitive_t primitive;
+primitive_t dot;
+float x, y;
+
 bool pokerGameInit(game_t *game) {
   pokergame_t *pokerGame = &game->pokerGame;
 
@@ -21,6 +25,11 @@ 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;
 } 
 
@@ -29,7 +38,7 @@ 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);
@@ -38,7 +47,26 @@ void pokerGameUpdate(game_t *game) {
   // Render the visual novel scene
   // 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/game/poker/pokergame.h

@@ -15,6 +15,8 @@
 #include "pokerui.h"
 
 #include "../../ui/frame.h"
+#include "../../physics/aabb.h"
+#include "../../input/input.h"
 
 /**
  * Initializes the game state for the poker game.

src/physics/aabb.c

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "aabb.h"
+
+bool aabbPoint2D(
+  float pointX, float pointY,
+  float x, float y, float width, float height,
+  aabbpointhit_t *hit
+) {
+
+  float dx, px, sx, halfWidth;
+  float dy, py, sy, halfHeight;
+  
+  if(hit == NULL) {
+    // Check X Axis, are we outside the box
+    if(pointX < x || pointY < y) return false;
+    if(pointX > x+width || pointY > y+height) return false;
+    return true;
+  }
+
+  halfWidth = width / 2;
+  halfHeight = height / 2;
+  x += halfWidth;
+  y += halfHeight;
+
+  dx = pointX - x;
+  px = halfWidth - mathAbs(dx);
+  if(px <= 0) return false;
+
+  dy = pointY - y;
+  py = halfHeight - mathAbs(dy);
+  if(py <= 0) return false;
+
+  if(px < py) {
+    sx = mathSign(dx);
+    // float deltaX = px *sx;
+    hit->normalX = sx;
+    hit->normalY = 0;
+    hit->hitX = x + (halfWidth * sx);
+    hit->hitY = pointY;
+  } else {
+    sy = mathSign(dy);
+    // float deltaY = py * sy;
+    hit->normalX = 0;
+    hit->normalY = sy;
+    hit->hitX = pointX;
+    hit->hitY = x + (halfHeight * sy);
+  }
+
+  return true;
+}
+

src/physics/aabb.h

@@ -0,0 +1,17 @@
+/**
+ * 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 "sphere.h"
+#include "../input/input.h"
+
+bool aabbPoint2D(
+  float pointX, float pointY,
+  float x, float y, float width, float height,
+  aabbpointhit_t *hit
+);

src/physics/sphere.c

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "sphere.h"
+
+bool sphereDistance2D(float x0, float y0, float x1, float y1, float radius) {
+  x0 = vectorDistance2D(x0, y0, x1, y1);
+  return x0 <= radius;
+}
+
+bool sphereDistance3D(
+  float x0, float y0, float z0, float x1, float y1, float z1, float radius
+) {
+  x0 = vectorDistance3D(x0, y0, z0, x1, y1, z1);
+  return x0 <= radius;
+}

src/physics/sphere.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 <dawn/dawn.h>
+#include "vector.h"
+
+/**
+ * Checks whether a point is colliding with a circle.
+ * 
+ * @param x0 X Position of the vector.
+ * @param y0 Y position of the vector.
+ * @param x1 Center point of the circle. X Coordinate.
+ * @param y1 Center point of the circle. Y Coordinate.
+ * @param radius Radius of the circle
+ * @return True if the point is colliding, otherwise false.
+ */
+bool sphereDistance2D(float x0, float y0, float x1, float y1, float radius);
+
+/**
+ * Checks whether a point is colliding with a sphere.
+ * 
+ * @param x0 X Position of the vector.
+ * @param y0 Y Position of the vector.
+ * @param z0 Z Position of the vector.
+ * @param x1 Center point of the circle, X Coordinate.
+ * @param y1 Center point of the circle, Y Coordinate.
+ * @param z1 Center point of the circle, Z Coordinate.
+ * @param radius Radius of the sphere.
+ * @return True if the point is colliding with the sphere.
+ */
+bool sphereDistance3D(
+  float x0, float y0, float z0, float x1, float y1, float z1, float radius
+);

src/physics/vector.c

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "vector.h"
+
+float vectorDistance2D(float x0, float y0, float x1, float y1) {
+  x0 = x1 - x0;
+  y0 = y1 - y0;
+  return sqrt(x0*x0 + y0*y0);
+}
+
+
+float vectorDistance3D(
+  float x0, float y0, float z0, float x1, float y1, float z1
+) {
+  x0 = x1 - x0;
+  y0 = y1 - y0;
+  z0 = z1 - z0;
+  return sqrt(x0*x0 + y0*y0 + z0*z0);
+}

src/physics/vector.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+
+/**
+ * Calculate the distance between two points in 2D space.
+ * 
+ * @param x0 First Position X Coordinate.
+ * @param y0 First Position Y Coordinate.
+ * @param x1 Second Position X Coordinate.
+ * @param y1 Second Position Y Coordinate.
+ * @return The distance measurement.
+ */
+float vectorDistance2D(float x0, float y0, float x1, float y1);
+
+/**
+ * Calculate the distance between two points in 3D space.
+ * 
+ * @param x0 First Position X Coordinate.
+ * @param y0 First Position Y Coordinate.
+ * @param z0 First Position Z Coordinate.
+ * @param x1 Second Position X Coordinate.
+ * @param y1 Second Position Y Coordinate.
+ * @param z1 Second Position Z Coordinate.
+ * @return The distance measurement.
+ */
+float vectorDistance3D(
+  float x0, float y0, float z0, float x1, float y1, float z1
+);

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);
 }