Testing SDL support

CMakeLists.txt

@@ -14,10 +14,13 @@ include(FetchContent)
 #Vars
 set(DEPS_DIR "${PROJECT_BINARY_DIR}/_deps")
 
+set(SDL2_DIR ${CMAKE_CURRENT_LIST_DIR}/lib/SDL2)
+
 ################################## Settings ####################################
 # Platform Settings
 set(SETTING_PLATFORM_GLFW 1)
-set(SETTING_PLATFORM SETTING_PLATFORM_GLFW)
+set(SETTING_PLATFORM_SDL 2)
+set(SETTING_PLATFORM SETTING_PLATFORM_SDL)
 
 # Game Settings
 set(SETTING_GAME_POKER 1)
@@ -36,12 +39,21 @@ project(${SETTING_GAME_NAME} VERSION 1.0)
 file(GLOB_RECURSE SOURCE_FILES ${CMAKE_SOURCE_DIR}/src/*.c)
 file(GLOB_RECURSE HEADER_FILES ${CMAKE_SOURCE_DIR}/src/*.h)
 
-file(GLOB_RECURSE SOURCE_PLATFORM_FILES
+# GLFW Sources
-  ${CMAKE_SOURCE_DIR}/platform/${PLATFORM}/*.c
+if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_GLFW})
-)
+  file(GLOB_RECURSE SRC ${CMAKE_SOURCE_DIR}/platform/glfw/*.c)
-file(GLOB_RECURSE HEADER_PLATFORM_FILES
+  file(GLOB_RECURSE HDRS ${CMAKE_SOURCE_DIR}/platform/glfw/*.h)
-  ${CMAKE_SOURCE_DIR}/platform/${PLATFORM}/*.h
+  list(APPEND SOURCE_FILES ${SRC})
-)
+  list(APPEND HEADER_FILES ${HDRS})
+endif()
+
+# SDL Sources
+if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_SDL})
+  file(GLOB_RECURSE SRC ${CMAKE_SOURCE_DIR}/platform/sdl/*.c)
+  file(GLOB_RECURSE HDRS ${CMAKE_SOURCE_DIR}/platform/sdl/*.h)
+  list(APPEND SOURCE_FILES ${SRC})
+  list(APPEND HEADER_FILES ${HDRS})
+endif()
 
 file(COPY ${CMAKE_CURRENT_LIST_DIR}/assets DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 
@@ -51,16 +63,14 @@ include_directories(${CMAKE_SOURCE_DIR}/include)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 ################################## EXECUTABLE ##################################
-add_executable(${PROJECT_NAME}
+add_executable(${PROJECT_NAME} ${HEADER_FILES} ${SOURCE_FILES})
-  ${HEADER_FILES} ${HEADER_PLATFORM_FILES}
-  ${SOURCE_FILES} ${SOURCE_PLATFORM_FILES}
-)
 
 ################################# STATIC LIBS ##################################
 # GLFW and GLAD
 if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_GLFW})
   add_subdirectory(${CMAKE_SOURCE_DIR}/lib/glad)
   target_link_libraries(${PROJECT_NAME} glad)
+  
   if(NOT glfw3_FOUND)
     FetchContent_Declare(
       glfw
@@ -72,6 +82,15 @@ if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_GLFW})
   target_link_libraries(${PROJECT_NAME} glfw)
 endif()
 
+# SDL
+if(${SETTING_PLATFORM} EQUAL ${SETTING_PLATFORM_SDL})
+  add_subdirectory(${CMAKE_SOURCE_DIR}/lib/glad)
+  target_link_libraries(${PROJECT_NAME} glad)
+  find_package(SDL2 REQUIRED)
+  include_directories(${SDL2_INCLUDE_DIRS})
+  target_link_libraries(${PROJECT_NAME} ${SDL2_LIBRARIES})
+endif()
+
 # CGLM
 if(NOT cglm_FOUND)
   FetchContent_Declare(

config.h.in

@@ -7,6 +7,7 @@
 
 // Platform Settings
 #cmakedefine SETTING_PLATFORM_GLFW @SETTING_PLATFORM_GLFW@
+#cmakedefine SETTING_PLATFORM_SDL @SETTING_PLATFORM_SDL@
 #cmakedefine SETTING_PLATFORM @SETTING_PLATFORM@
 
 // Game Settings

include/dawn/input/input.h

@@ -28,7 +28,7 @@
 
 
 #define INPUT_BIND_COUNT 0xFF
-#define INPUT_SOURCE_COUNT 4096
+#define INPUT_SOURCE_COUNT 0xFF
 
 /**
  * Input Bind, a specific action bind reference for the game engine to use.
@@ -41,7 +41,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 uint32_t inputsource_t;
+typedef uint8_t inputsource_t;
 
 /**
  * Value that represents the state of an input. Defined as 0-1 where 0 is set

include/dawn/libs.h

@@ -13,6 +13,11 @@
 
 #if SETTING_PLATFORM == SETTING_PLATFORM_GLFW
   #include <glad/glad.h>
+#elif SETTING_PLATFORM == SETTING_PLATFORM_SDL
+  #include <glad/glad.h>
+  #include <SDL.h>
+  #include <SDL_opengl.h>
+  #include <SDL_opengles2.h>
 #endif
 
 #include <stb_image.h>

include/dawn/settings.h

@@ -1,20 +0,0 @@
-/**
- * Copyright (c) 2021 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-#pragma once
-
-// Game Definitions
-#define SETTING_GAME_POKER 1
-#define SETTING_GAME_DAWN 2
-
-// Settings
-#define SETTING_GAME SETTING_GAME_POKER
-
-
-// Compiler setting fallbacks
-#ifndef SETTING_PLATFORM
-  #error Missing platform setting from compiler.
-#endif

platform/sdl/sdl.c

@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "sdl.h"
+
+game_t *GAME_STATE;
+
+int main(int argc, char *argv[]) {
+  game_t *game;
+  input_t *input;
+  SDL_GLContext context;
+  SDL_Window* displayWindow;
+  SDL_Event event;
+  SDL_Renderer* renderer;
+  bool running;
+  uint32_t currentTime;
+  uint32_t lastTime;
+  float timeDelta;
+
+  // Init SEDL
+  if(SDL_Init( SDL_INIT_VIDEO) < 0) {
+    printf("No init SDL\n");
+    return 1;
+  }
+
+  // Setup GL Information.
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, OPENGL_MAJOR_VERSION);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, OPENGL_MINOR_VERSION);
+
+  // Create a window
+  displayWindow = SDL_CreateWindow("test",
+    SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+    SCREEN_WIDTH, SCREEN_HEIGHT,
+    SDL_WINDOW_OPENGL | SDL_RENDERER_ACCELERATED
+    // SDL_WINDOW_OPENGL | SDL_RENDERER_ACCELERATED | SDL_WINDOW_FULLSCREEN
+  );
+  if(displayWindow == NULL) {
+    printf("No make window %s\n", SDL_GetError());
+    return 1;
+  }
+
+  // Create Renderer
+  renderer = SDL_CreateRenderer(displayWindow, -1, SDL_RENDERER_ACCELERATED);
+  if(renderer == NULL) {
+    printf("SDL2 Renderer couldn't be created. Error: %s\n", SDL_GetError());
+    return 1;
+  }
+
+  // Create a GL Context
+  context = SDL_GL_CreateContext(displayWindow);
+  if(context == NULL) {
+    printf("No make context\n");
+    return 1;
+  }
+
+  // Load glad
+  if (!gladLoadGLLoader((GLADloadproc) SDL_GL_GetProcAddress)) {
+    printf("Failed to initialize the OpenGL context.\n");
+    return 1;
+  }
+
+  // Bind the GL Context
+  SDL_GL_MakeCurrent(displayWindow, context);
+
+  // SDL Time management init
+  currentTime = SDL_GetTicks();
+  lastTime = currentTime - EPOCH_FIXED_STEP;
+
+  // Initialize the game
+  game = malloc(sizeof(game_t));
+  GAME_STATE = game;
+  printf("Game is %zu bytes.\n", sizeof(game_t));
+  renderSetResolution(&game->engine.render, SCREEN_WIDTH, SCREEN_HEIGHT);
+
+  if(gameInit(game)) {
+    input = &game->engine.input;
+
+    // Bind initial keys
+    inputBind(input, INPUT_NULL,         (inputsource_t)SDLK_ESCAPE);
+    inputBind(input, INPUT_DEBUG_UP,     (inputsource_t)SDLK_w);
+    inputBind(input, INPUT_DEBUG_DOWN,   (inputsource_t)SDLK_s);
+    inputBind(input, INPUT_DEBUG_LEFT,   (inputsource_t)SDLK_a);
+    inputBind(input, INPUT_DEBUG_RIGHT,  (inputsource_t)SDLK_d);
+
+    inputBind(input, INPUT_UP,           (inputsource_t)SDLK_UP);
+    inputBind(input, INPUT_DOWN,         (inputsource_t)SDLK_DOWN);
+    inputBind(input, INPUT_LEFT,         (inputsource_t)SDLK_LEFT);
+    inputBind(input, INPUT_RIGHT,        (inputsource_t)SDLK_RIGHT);
+    inputBind(input, INPUT_UP,           (inputsource_t)SDLK_w);
+    inputBind(input, INPUT_DOWN,         (inputsource_t)SDLK_s);
+    inputBind(input, INPUT_LEFT,         (inputsource_t)SDLK_a);
+    inputBind(input, INPUT_RIGHT,        (inputsource_t)SDLK_d);
+    inputBind(input, INPUT_ACCEPT,       (inputsource_t)SDLK_e);
+    inputBind(input, INPUT_ACCEPT,       (inputsource_t)SDLK_RETURN);
+    inputBind(input, INPUT_ACCEPT,       (inputsource_t)SDLK_SPACE);
+
+    // Update window title.
+    SDL_SetWindowTitle(displayWindow, SETTING_GAME_NAME);
+    running = true;
+
+    while(running) {
+      // Poll for SDL Events
+      while(SDL_PollEvent(&event)) {
+        switch(event.type) {
+          case SDL_QUIT:
+            running = false;
+            break;
+
+          case SDL_KEYDOWN:
+            input->buffer[(inputsource_t)event.key.keysym.sym] = true;
+            break;
+
+          case SDL_KEYUP:
+            input->buffer[(inputsource_t)event.key.keysym.sym] = false;
+            break;
+            
+          default:
+            break;
+        }
+      }
+      
+      if(!running) break;
+
+      // Calc time delta
+      lastTime = currentTime;
+      currentTime = SDL_GetTicks();
+      timeDelta = (currentTime - lastTime) / 1000.0f;
+
+      // Tick Game
+      if(!gameUpdate(game, timeDelta)) break;
+
+      // Swap buffers
+      SDL_GL_SwapWindow(displayWindow);
+    }
+
+    // Game has finished running, cleanup.
+    gameDispose(game);
+  }
+  free(game);
+
+  // Cleanup SDL
+  SDL_GL_DeleteContext(context);
+  SDL_DestroyRenderer(renderer);
+  SDL_DestroyWindow(displayWindow);
+  SDL_Quit();
+
+  return 0;
+}

platform/sdl/sdl.h

@@ -0,0 +1,24 @@
+/**
+ * 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 <glad/glad.h>
+#include <SDL.h>
+#include <SDL_opengl.h>
+#include <SDL_opengles2.h>
+#include "../../src/display/render.h"
+#include "../../src/game/game.h"
+#include "../../src/input/input.h"
+
+#define SCREEN_WIDTH 480
+#define SCREEN_HEIGHT 320
+
+#define OPENGL_MAJOR_VERSION 2
+#define OPENGL_MINOR_VERSION 1
+
+int main(int argc, char *argv[]);

src/display/camera.c

@@ -24,15 +24,15 @@ void cameraLook(camera_t *camera,
 }
 
 void cameraPerspective(camera_t *camera,
-  float fov, float aspect, float near, float far
+  float fov, float aspect, float camNear, float camFar
 ) {
   matrixIdentity(&camera->projection);
-  matrixPerspective(&camera->projection, mathDeg2Rad(fov), aspect, near, far);
+  matrixPerspective(&camera->projection,mathDeg2Rad(fov),aspect,camNear,camFar);
 }
 
 void cameraOrtho(camera_t *camera,
-  float left, float right, float bottom, float top, float near, float far
+  float left, float right, float bottom, float top, float camNear, float camFar
 ) {
   matrixIdentity(&camera->projection);
-  matrixOrtho(&camera->projection, left, right, bottom, top, near, far);
+  matrixOrtho(&camera->projection, left, right, bottom, top, camNear, camFar);
 }

src/display/camera.h

@@ -46,11 +46,11 @@ void cameraLook(camera_t *camera,
  * @param camera The camera to project.
  * @param fov The field of view of the camera (in degrees).
  * @param aspect The aspect ratio of the camera (w / h)
- * @param near The near plane clip.
+ * @param camNear The near plane clip.
- * @param far the far plane clip.
+ * @param camFar the far plane clip.
  */
 void cameraPerspective(camera_t *camera,
-  float fov, float aspect, float near, float far
+  float fov, float aspect, float camNear, float camFar
 );
 
 /**
@@ -60,9 +60,9 @@ void cameraPerspective(camera_t *camera,
  * @param left The left side of the viewport.
  * @param right The right side of the viewport.
  * @param bottom The bottom side of the viewport.
- * @param near The near plane clip.
+ * @param camNear The near plane clip.
- * @param far the far plane clip.
+ * @param camFar the far plane clip.
  */
 void cameraOrtho(camera_t *camera,
-  float left, float right, float bottom, float top, float near, float far
+  float left, float right, float bottom, float top, float camNear, float camFar
 );

src/display/matrix.c

@@ -38,15 +38,15 @@ void matrixLook(matrix_t *matrix,
 }
 
 void matrixPerspective(matrix_t *matrix,
-  float fov,float aspect,float near,float far
+  float fov, float aspect, float camNear, float camFar
 ) {
-  glm_perspective(fov, aspect, near, far, matrix->internalMatrix);
+  glm_perspective(fov, aspect, camNear, camFar, matrix->internalMatrix);
 }
 
 void matrixOrtho(matrix_t *matrix,
-  float left, float right, float bottom, float top, float near, float far
+  float left, float right, float bottom, float top, float camNear, float camFar
 ) {
-  glm_ortho(left, right, bottom, top, near, far, matrix->internalMatrix);
+  glm_ortho(left, right, bottom, top, camNear, camFar, matrix->internalMatrix);
 }
 
 void matrixTranslate(matrix_t *matrix, float x, float y, float z) {

src/display/matrix.h

@@ -60,11 +60,11 @@ void matrixLook(matrix_t *matrix,
  * @param matrix Matrix to apply to.
  * @param fov Field of View (in radians) to use.
  * @param aspect Aspect ratio (w/h) of the viewport.
- * @param near Near vector, > 0.
+ * @param camNear Near vector, > 0.
- * @param far Far view vector.
+ * @param camFar Far view vector.
  */
 void matrixPerspective(matrix_t *matrix,
-  float fov,float aspect,float near,float far
+  float fov,float aspect, float camNear, float camFar
 );
 
 /**
@@ -75,11 +75,11 @@ void matrixPerspective(matrix_t *matrix,
  * @param right Right view position.
  * @param bottom Bottom view position.
  * @param top Top view position.
- * @param near Near vector, > 0.
+ * @param camNear Near vector, > 0.
- * @param far Far view vector.
+ * @param camFar Far view vector.
  */
 void matrixOrtho(matrix_t *matrix,
-  float left, float right, float bottom, float top, float near, float far
+  float left, float right, float bottom, float top, float camNear, float camFar
 );
 
 /**