Moved some code around and cleaned things a bit.

src/engine/engine.c

@@ -7,11 +7,15 @@
 
 #include "engine.h"
 
-engine_t * engineInit(char *gameName) {
+engine_t * engineInit(
+  platform_t *platform, char *gameName, uint32_t inputCount
+) {
   // Create the engine instance.
   engine_t *engine = malloc(sizeof(engine_t));
   if(engine == NULL) return NULL;
 
+  engine->platform = platform;
+
   // Setup the renderer.
   engine->render = renderInit(gameName);
   if(engine->render == NULL) {
@@ -20,7 +24,7 @@ engine_t * engineInit(char *gameName) {
   }
 
   // Setup the input manager.
-  engine->input = inputInit(0);
+  engine->input = inputInit(platform, inputCount);
   if(engine->input == NULL) {
     free(engine->render);
     free(engine);
@@ -32,7 +36,7 @@ engine_t * engineInit(char *gameName) {
 
 void engineStart(engine_t *engine) {
   while(!glfwWindowShouldClose(engine->render->window)) {
-    inputUpdate(engine->input);
+    inputUpdate(engine->platform, engine->input);
     renderFrame(engine->render);
     glfwSwapBuffers(engine->render->window);
     glfwPollEvents();

src/engine/engine.h

@@ -5,6 +5,7 @@
 
 #pragma once
 #include <stdbool.h>
+#include "../platform/platform.h"
 #include "../display/render.h"
 #include "../file/asset.h"
 #include "../input/input.h"
@@ -14,6 +15,9 @@ typedef struct {
   /** Name of the game running. */
   char *gameName;
 
+  /** Platform for the game */
+  platform_t *platform;
+
   /** Renderer for the engine. */
   render_t *render;
   
@@ -24,10 +28,14 @@ typedef struct {
 /**
  * Initialize the engine context.
  * 
+ * @param platform The platform that the game is running on.
  * @param gameName Name of the game being initialized.
+ * @param inputCount Count of input binds that exist in-engine.
  * @return The engine context.
  */
-engine_t * engineInit(char *gameName);
+engine_t * engineInit(
+  platform_t *platform, char *gameName, uint32_t inputCount
+);
 
 /**
  * Start the main engine loop.

src/game/game.h

@@ -7,6 +7,7 @@
 
 #pragma once
 #include <stdbool.h>
+#include "../platform/platform.h"
 #include "../engine/engine.h"
 
 /** Information about the current game context. */
@@ -14,9 +15,11 @@ typedef void game_t;
 
 /**
  * Initialize the game context.
+ * 
+ * @param platform The platform that the game is running on.
  * @return The game instance context.
  */
-game_t * gameInit();
+game_t * gameInit(platform_t *platform);
 
 /**
  * Start the main game loop.

src/games/dawn/dawngame.c

@@ -5,19 +5,15 @@
  * https://opensource.org/licenses/MIT
  */
 
-#include "game.h"
+#include "dawngame.h"
 
-typedef struct {
-  engine_t *engine;
-} dawngame_t;
-
-game_t * gameInit(char *gameName) {
+game_t * gameInit(platform_t *platform) {
   // Create the game
   dawngame_t *dawn = malloc(sizeof(dawngame_t));
   if(dawn == NULL) return NULL;
 
   // Load the game engine
-  dawn->engine = engineInit("Dawn Game");
+  dawn->engine = engineInit(platform, GAME_NAME, INPUT_COUNT);
   if(dawn->engine == NULL) {
     free(dawn);
     return NULL;

src/games/dawn/dawngame.h

@@ -0,0 +1,28 @@
+// Copyright (c) 2021 Dominic Msters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <malloc.h>
+#include "../../game/game.h"
+
+/////////////////////////////////// CONSTANTS //////////////////////////////////
+
+/** Name of the Game */
+#define GAME_NAME "Dawn Game"
+
+/** Inputs */
+#define INPUT_UP          (inputbind_t)0x01
+#define INPUT_DOWN        (inputbind_t)0x02
+#define INPUT_LEFT        (inputbind_t)0x03
+#define INPUT_RIGHT       (inputbind_t)0x04
+
+#define INPUT_COUNT 5
+
+/////////////////////////////// Type Definitions ///////////////////////////////
+/** Context about Dawn Game */
+typedef struct {
+  /** The engine context for the game */
+  engine_t *engine;
+} dawngame_t;

src/input/input.c

@@ -7,91 +7,108 @@
 
 #include "input.h"
 
-input_t * inputInit(uint32_t inputBindCount) {
+input_t * inputInit(platform_t *platform, uint32_t inputBindCount) {
+  // Create the input manager
   input_t *input = malloc(sizeof(input_t));
   if(!input) return NULL;
+
+  // Setup the binds
   input->inputBindCount = inputBindCount;
-
-  input->inputsCurrent = malloc(sizeof(float) * inputBindCount);
-  if(input->inputsCurrent == NULL) {
+  input->binds = malloc(sizeof(inputbind_t) * inputBindCount);
+  if(input->binds == NULL) {
     free(input);
     return NULL;
   }
 
-  input->inputsPrevious = malloc(sizeof(float) * inputBindCount);
-  if(input->inputsPrevious == NULL) {
-    free(input->inputsCurrent);
+  // Create the current input states
+  input->current = malloc(sizeof(float) * inputBindCount);
+  if(input->current == NULL) {
+    free(input->binds);
     free(input);
     return NULL;
   }
 
-  input->inputTime = malloc(sizeof(float) * inputBindCount);
-  if(input->inputTime == NULL) {
-    free(input->inputsPrevious);
-    free(input->inputsCurrent);
+  // Create the previous input states.
+  input->previous = malloc(sizeof(float) * inputBindCount);
+  if(input->previous == NULL) {
+    free(input->current);
+    free(input->binds);
     free(input);
     return NULL;
   }
 
+  // Create the input actuate times array.
+  input->times = malloc(sizeof(float) * inputBindCount);
+  if(input->times == NULL) {
+    free(input->previous);
+    free(input->current);
+    free(input->binds);
+    free(input);
+    return NULL;
+  }
+
+  // Pass off the input manager
   return input;
 }
 
-void inputUpdate(input_t *input) {
+void inputUpdate(platform_t *platform, input_t *input) {
   // Flip the states to save memory.
-  float * currentCurrent = input->inputsCurrent;
-  input->inputsCurrent = input->inputsPrevious;
-  input->inputsPrevious = currentCurrent;
+  float * currentCurrent = input->current;
+  input->current = input->previous;
+  input->previous = currentCurrent;
+
+  // Now look at each bind, get the state from the platform
+  for(uint32_t i = 0; i < input->inputBindCount; i++) {
+    // For this bind, get the sources.
+  }
 }
 
 void inputDispose(input_t *input) {
-  free(input->inputTime);
-  free(input->inputsPrevious);
-  free(input->inputsCurrent);
+  free(input->times);
+  free(input->previous);
+  free(input->current);
+  free(input->binds);
   free(input);
 }
 
 inputbindmap_t inputBind(input_t *input, inputbind_t bind,
-  inputsource_t *source
+  platforminputsource_t *source
 ) {
   return NULL;
 }
 
-float inputGetState(inputbind_t binding, inputsource_t *source) {
-  return 0;
-}
-
 bool inputIsDown(input_t *input, inputbind_t binding) {
-  return input->inputsCurrent[binding] != 0;
+  return input->current[binding] != 0;
 }
 
 bool inputIsUp(input_t *input, inputbind_t binding) {
-  return input->inputsCurrent[binding] == 0;
+  return input->current[binding] == 0;
 }
 
 bool inputIsPressed(input_t *input, inputbind_t binding) {
   return (
-    input->inputsPrevious[binding] == 0 &&
-    input->inputsCurrent[binding] != 0
+    input->previous[binding] == 0 &&
+    input->current[binding] != 0
   );
 }
 
 bool inputIsReleased(input_t *input, inputbind_t binding) {
   return (
-    input->inputsCurrent[binding] == 0 &&
-    input->inputsPrevious[binding] != 0
+    input->current[binding] == 0 &&
+    input->previous[binding] != 0
   );
 }
 
 float inputGetAxis(input_t *input, inputbind_t binding) {
-  return input->inputsCurrent[binding];
+  return input->current[binding];
 }
 
 float inputGetFullAxis(input_t *input, inputbind_t positive,
   inputbind_t negative
 ) {
-  return input->inputsCurrent[negative] + input->inputsCurrent[positive];
+  return input->current[negative] + input->current[positive];
 }
 
 float inputGetAccuated(input_t *input, inputbind_t binding) {
-  return input->inputTime[binding];
+  return input->times[binding];
 }

src/input/input.h

@@ -7,13 +7,13 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <malloc.h>
+#include "../platform/platform.h"
+
+/////////////////////////////////// CONSTANTS //////////////////////////////////
+#define INPUT_NULL (inputbind_t)0x00
+#define INPUT_INPUTS_PER_BIND
 
 /////////////////////////////// Type Definitions ///////////////////////////////
-/**
- * Input Source, can be a button or an axis. Currently a void type.
- */
-typedef void inputsource_t;
-
 /**
  * Input Bind, a specific action bind reference for the game engine to use.
  * e.g. "Jump" or "Walk Forward".
@@ -21,7 +21,7 @@ typedef void inputsource_t;
 typedef uint8_t inputbind_t;
 
 /**
- * Input Bind Map, contains the bound link between an inputsource_t and an
+ * Input Bind Map, contains the bound link between an input source and an
  * inputbind_t. Bind Maps can be added and removed.
  */
 typedef uint16_t inputbindmap_t;
@@ -34,28 +34,21 @@ typedef struct {
   uint32_t inputBindCount;
 
   /** Float of the input between 0 and 1. For teh current frame */
-  float *inputsCurrent;
+  float *current;
 
   /** Float of the input between 0 and 1. For the last frame */
-  float *inputsPrevious;
+  float *previous;
 
   /** Float of the GameTime that the input was actuated last. */
-  float *inputTime;
-
-  /**
-   * Array of pointers to all of the input sources. This must be set up by the 
-   * platform to register each known input to poll on. Essentially the engine is
-   * going to query the platform for the current state of each input based on the
-   * entries within this list.
-   */
-  inputsource_t **bindingSources;
+  float *times;
   
   /**
    * Array of input bindings. This is the list of "possible actions" that the
    * user can perform. This would contain "jump", "walk forward", "run"... etc.
    */
-  inputbind_t *INPUT_BINDING_BINDS;
+  inputbind_t *binds;
 } input_t;
+
 //////////////////////////////////// Methods ///////////////////////////////////
 
 /**
@@ -64,13 +57,13 @@ typedef struct {
  * @param inputCount The input binding counts to allow for.
  * @return The input manager
  */
-input_t * inputInit(uint32_t inputBindCount);
+input_t * inputInit(platform_t *platform, uint32_t inputBindCount);
 
 /**
  * Tick the input manager.
  * @param input The input to update.
  */
-void inputUpdate(input_t *input);
+void inputUpdate(platform_t *platform, input_t *input);
 
 /**
  * Destroy the input manager and cleanup.
@@ -88,19 +81,10 @@ void inputDispose(input_t *input);
  * @return The map between the bind and the source, needed to unbind later.
  */
 inputbindmap_t inputBind(input_t *input, inputbind_t bind,
-  inputsource_t *source
+  platforminputsource_t *source
 );
 
-/**
- * Platform-centric method. Method will be polled for each known input source to
- * request the current state from the device. Values returned will be defined
- * within the 0 to 1 range.
- * 
- * @param binding The binding that has been created.
- * @param source The input source, this was created when the binding was defined
- * @return Input state between 0 and 1.
- */
-float inputGetState(inputbind_t binding, inputsource_t *source);
+float inputGetState(inputbind_t binding, platforminputsource_t *source);
 
 /**
  * Is the current input "down", not being pressed, being moved, not in a state

src/main.c

@@ -8,8 +8,11 @@
 #include "main.h"
 
 int32_t main() {
+  platform_t *platform = platformInit();
+  if(platform == NULL) return 1;
+
   // Create the game instance
-  game_t *game = gameInit();
+  game_t *game = gameInit(platform);
   if(game == NULL) return 1;
 
   // Start running the game instance
@@ -17,6 +20,7 @@ int32_t main() {
 
   // Game has finished running, cleanup.
   gameDispose(game);
+  platformDispose(platform);
 
   return 0;
 }

src/main.h

@@ -7,7 +7,7 @@
 
 #pragma once
 #include <stdint.h>
-
+#include "platform/platform.h"
 #include "game/game.h"
 
 /**

src/platform/platform.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2021 Dominic Msters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <malloc.h>
+#include <stdint.h>
+
+typedef void platforminputsource_t;
+
+/**
+ * Platform stuct, contains information about the device/method that is running
+ * the program that the game itself is running on, typically this will be either
+ * the operating system, or perhaps the specific device information.
+ */
+typedef struct {
+  /** Internal name of the platform */
+  char *name;
+
+  /** List of known input sources */
+  platforminputsource_t **inputSources;
+  /** Count of known input source */
+  uint32_t *inputSourceCount;
+  /** State of the input sources, updated by the platform. */
+  float *inputStates;
+} platform_t;
+
+/**
+ * Initialize the current platform context. The platform itself is responsible
+ * for deciding how this method is implemented.
+ * 
+ * @return The context information for the platform.
+ */
+platform_t * platformInit();
+
+/**
+ * Cleanup a previously created platform instance.
+ * 
+ * @param platform The platform instance to cleanse.
+ */
+void platformDispose(platform_t *platform);
+
+/**
+ * Method will be polled for each known input source to request the current
+ * state from the device. Values returned will be defined within the 0 to 1
+ * range.
+ * 
+ * @param source The input source.
+ * @return Input state between 0 and 1.
+ */
+float platformInputGetState(platforminputsource_t *source);

src/platform/win32/win32platform.c

@@ -0,0 +1,26 @@
+// Copyright (c) 2021 Dominic Msters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "win32platform.h"
+
+platform_t * platformInit() {
+  platform_t *platform = malloc(sizeof(platform_t));
+  
+  platform->name = WIN32_NAME;
+
+  platform->inputSourceCount = 0;
+  platform->inputSources = NULL;
+  platform->inputStates = NULL;
+
+  return platform;
+}
+
+void platformDispose(platform_t *platform) {
+  free(platform);
+}
+
+float platformInputGetState(platforminputsource_t *source) {
+  return 0;
+}

src/platform/win32/win32platform.h

@@ -0,0 +1,9 @@
+// Copyright (c) 2021 Dominic Msters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "../platform.h"
+
+#define WIN32_NAME "Win32"

src/util/list/list.c

@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2021 Dominic Msters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "list.h"
+
+List * listCreate() {
+  List *list = malloc(sizeof(List));
+  if(list == NULL) return NULL;
+
+  list->start = NULL;
+  list->end = NULL;
+  list->size = 0;
+  return list;
+}
+
+ListEntry * listAdd(List *list, void *data) {
+  //Create the list entry
+  ListEntry *entry = malloc(sizeof(ListEntry));
+  if(entry == NULL) return NULL;
+
+  entry->data = data;
+  entry->next = NULL;
+  entry->prev = NULL;
+
+  //Add it to the list
+  listAddEntry(list, entry);
+
+  //Return the entry
+  return entry;
+}
+
+void listAddEntry(List *list, ListEntry *entry) {
+  //Is this the first / only thing in the list?
+  if(list->start == NULL) {
+    list->start = entry;
+    list->end = entry;
+  } else {
+    //Make the end's next be this entry, and this entry's prev the end, then 
+    //make this the new end
+    entry->prev = list->end;
+    list->end->next = entry;
+    list->end = entry;
+  }
+  list->size++;
+}
+
+
+void listRemove(List *list, ListEntry *entry, bool freeData) {
+  //Update next and prev
+  if(entry->prev != NULL) entry->prev->next = entry->next;
+  if(entry->next != NULL) entry->next->prev = entry->prev;
+
+  //Was this at the end?
+  if(list->start == entry) list->start = entry->next;
+  if(list->end == entry) list->end = entry->prev;
+
+  if(freeData) free(entry->data);
+  free(entry);
+
+  list->size--;
+}
+
+ListEntry * listGetByIndex(List *list, int index) {
+  if(index >= list->size) return NULL;
+
+  //TODO: We can probably make this more efficient by deciding which way we 
+  //should loop from based on the list size.
+
+  int i = 0;
+  ListEntry *previous = list->start;
+
+  while(previous != NULL) {
+    if(i == index) return previous;
+    i++;
+    previous = previous->next;
+  }
+
+  return NULL;
+}
+
+int listGetIndex(List *list, ListEntry *entry) {
+  int i = 0;
+  ListEntry *previous = list->start;
+
+  while(previous != NULL) {
+    if(previous == entry) return i;
+    i++;
+    previous = previous->next;
+  }
+  
+  return -1;
+}
+
+void listDispose(List *list, bool freeData) {
+  //Free all of the entries
+  ListEntry *next = list->start;
+  ListEntry *current;
+  
+  while(next != NULL) {
+    current = next;
+    next = current->next;
+    if(freeData) free(current->data);
+    free(current);
+  }
+
+  free(list);
+}

src/util/list/list.h

@@ -0,0 +1,86 @@
+// Copyright (c) 2021 Dominic Msters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <stdio.h>
+#include <stdbool.h>
+#include <malloc.h>
+
+/**
+ * Entry within a given linked list.
+ * @param data* The pointer to the data that is within the entry.
+ * @param prev* Pointer to the previous entry in the list.
+ * @param next* Pointer to the next entry in the list.
+ */
+typedef struct ListEntry {
+  void *data;
+  struct ListEntry *prev;
+  struct ListEntry *next;
+} ListEntry;
+
+/**
+ * Linked List of elements, Doubly Linked.
+ * @param size The count of elements currently within the list
+ * @param start* First element within the list.
+ * @param end* Last element within the list.
+ */
+typedef struct {
+  int size;
+  ListEntry *start;
+  ListEntry *end;
+} List;
+
+//Method definitions
+
+/**
+ * Creates a new linked list
+ * @return Pointer to a new linked list.
+ */
+List * listCreate();
+
+/**
+ * Adds data to a linked list
+ * 
+ * @param list* Pointer to a previously created linked list
+ * @param data* Pointer to your data
+ * @return A pointer to the new entry in the linked list that was created
+ */
+ListEntry * listAdd(List *list, void *data);
+
+/**
+ * Internal function
+ */
+void listAddEntry(List *list,  ListEntry *entry);
+
+/**
+ * Remove a list entry from the linked list
+ * @param list* Pointer to a previously created linked list
+ * @param entry* Pointer to the entry within the linked list.
+ * @param freeData If true the data of the ListEntry will be free()'d
+ */
+void listRemove(List *list, ListEntry *entry, bool freeData);
+
+/**
+ * Returns the entry at a given index. This method is costly.
+ * @param list* Pointer to a previously created linked list
+ * @param index Index of element within the linked list to remove
+ * @return The entry at the index or NULL if outside the bounds.
+ */
+ListEntry * listGetByIndex(List *list, int index);
+
+/**
+ * Returns the index of an entry within the linked list. This method is costly.
+ * @param list* Pointer to a previously created linked list
+ * @param entry* Pointer to the entry within the linked list.
+ * @return The index within the list the entry is in, or -1 if not found.
+ */ 
+int listGetIndex(List *list, ListEntry *entry);
+
+/**
+ * Dispose a previously created link list.
+ * @param list* Pointer to a previously created linked list
+ * @param freeData If true the data within each ListEntry will be free()'d
+ */
+void listDispose(List *list, bool freeData);