Added input manager and license.

src/input/input.c

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2021 Dominic Msters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "input.h"
+
+input_t * inputInit(uint32_t inputBindCount) {
+  input_t *input = malloc(sizeof(input_t));
+  if(!input) return NULL;
+  input->inputBindCount = inputBindCount;
+
+  input->inputsCurrent = malloc(sizeof(float) * inputBindCount);
+  if(input->inputsCurrent == NULL) {
+    free(input);
+    return NULL;
+  }
+
+  input->inputsPrevious = malloc(sizeof(float) * inputBindCount);
+  if(input->inputsPrevious == NULL) {
+    free(input->inputsCurrent);
+    free(input);
+    return NULL;
+  }
+
+  input->inputTime = malloc(sizeof(float) * inputBindCount);
+  if(input->inputTime == NULL) {
+    free(input->inputsPrevious);
+    free(input->inputsCurrent);
+    free(input);
+    return NULL;
+  }
+
+  return input;
+}
+
+void inputUpdate(input_t *input) {
+  // Flip the states to save memory.
+  float * currentCurrent = input->inputsCurrent;
+  input->inputsCurrent = input->inputsPrevious;
+  input->inputsPrevious = currentCurrent;
+}
+
+void inputDispose(input_t *input) {
+  free(input->inputTime);
+  free(input->inputsPrevious);
+  free(input->inputsCurrent);
+  free(input);
+}
+
+inputbindmap_t inputBind(input_t *input, inputbind_t bind,
+  inputsource_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;
+}
+
+bool inputIsUp(input_t *input, inputbind_t binding) {
+  return input->inputsCurrent[binding] == 0;
+}
+
+bool inputIsPressed(input_t *input, inputbind_t binding) {
+  return (
+    input->inputsPrevious[binding] == 0 &&
+    input->inputsCurrent[binding] != 0
+  );
+}
+
+bool inputIsReleased(input_t *input, inputbind_t binding) {
+  return (
+    input->inputsCurrent[binding] == 0 &&
+    input->inputsPrevious[binding] != 0
+  );
+}
+
+float inputGetAxis(input_t *input, inputbind_t binding) {
+  return input->inputsCurrent[binding];
+}
+
+float inputGetFullAxis(input_t *input, inputbind_t positive,
+  inputbind_t negative
+) {
+  return input->inputsCurrent[negative] + input->inputsCurrent[positive];
+}
+
+float inputGetAccuated(input_t *input, inputbind_t binding) {
+  return input->inputTime[binding];
+}

src/input/input.h

@@ -0,0 +1,176 @@
+// Copyright (c) 2021 Dominic Msters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <stdbool.h>
+#include <stdint.h>
+#include <malloc.h>
+
+/////////////////////////////// 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".
+ */
+typedef uint8_t inputbind_t;
+
+/**
+ * Input Bind Map, contains the bound link between an inputsource_t and an
+ * inputbind_t. Bind Maps can be added and removed.
+ */
+typedef uint16_t inputbindmap_t;
+
+/**
+ * Structure for the entire input mapping.
+ */
+typedef struct {
+  /** How many input bindings are in the input managers' scope */
+  uint32_t inputBindCount;
+
+  /** Float of the input between 0 and 1. For teh current frame */
+  float *inputsCurrent;
+
+  /** Float of the input between 0 and 1. For the last frame */
+  float *inputsPrevious;
+
+  /** 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;
+  
+  /**
+   * 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;
+} input_t;
+//////////////////////////////////// Methods ///////////////////////////////////
+
+/**
+ * Initializes the input manager.
+ * 
+ * @param inputCount The input binding counts to allow for.
+ * @return The input manager
+ */
+input_t * inputInit(uint32_t inputBindCount);
+
+/**
+ * Tick the input manager.
+ * @param input The input to update.
+ */
+void inputUpdate(input_t *input);
+
+/**
+ * Destroy the input manager and cleanup.
+ * @param input The input to destroy.
+ */
+void inputDispose(input_t *input);
+
+/**
+ * Binds the given input binding to the input source. Essentially allowing any
+ * time we fetch the state of bind, we will read the value from source.
+ * 
+ * @param input The input manager to bind for.
+ * @param bind The binding to bind against
+ * @param source The source that is being bound.
+ * @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
+);
+
+/**
+ * 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);
+
+/**
+ * Is the current input "down", not being pressed, being moved, not in a state
+ * of rest.
+ * 
+ * @param state The input state to check against.
+ * @param binding The previously bound input binding.
+ * @return True if the input vector is non-zero.
+ */
+bool inputIsDown(input_t *state, inputbind_t binding);
+
+/**
+ * Is the current input "up", in a state of rest, not being actioned, moved.
+ * 
+ * @param state The input state to check against.
+ * @param binding The previously bound input binding.
+ * @return True if input vector is zero
+ */
+bool inputIsUp(input_t *state, inputbind_t binding);
+
+/**
+ * Returns true on the first tick that an input was actioned/downed.
+ * 
+ * @param input The input manager.
+ * @param binding The previously bound input binding.
+ * @return True if the input vector was non-zeroed this tick but not last. 
+ */
+bool inputIsPressed(input_t *input, inputbind_t binding);
+
+/**
+ * Returns true on the first tick that an input was released/upped.
+ * 
+ * @param input The input manager.
+ * @param binding The previously bound input binding.
+ * @return True if the input vector was zeroed this tick but not last. 
+ */
+bool inputIsReleased(input_t *input, inputbind_t binding);
+
+/**
+ * Returns the raw input value as a float between 0 and 1. For digital (buttons)
+ * this will typicall be 0 or 1 only. Other analogue inputs will have anywhere
+ * within the range.
+ * 
+ * @param input The input manager to check against.
+ * @param binding The previously bound input binding.
+ * @return A float between 0 and 1 representing the action force of the input.
+ */
+float inputGetAxis(input_t *input, inputbind_t binding);
+
+/**
+ * Returns a raw input value between -1 and 1 between two axis. This would be
+ * indicitive of having an input with an axis that can be moved one direction
+ * for a positive input and another for a negative input, typically a game
+ * controller's analogue sticks.
+ * 
+ * @param input The input manager to check against.
+ * @param postitive The positive axis binding.
+ * @param negative The negative axis binding.
+ * @return A float between -1 and 1 representing the result of both.
+ */
+float inputGetFullAxis(input_t *input, inputbind_t positive,
+  inputbind_t negative
+);
+
+/**
+ * Returns the time that an input was actuated at. Actuate would count as a
+ * non-zero input for analogue inputs.
+ * 
+ * @param input The input manager to check against.
+ * @param binding The previously bound input binding.
+ * @return Game Engine time that an input was non-zeroed
+ */
+float inputGetAccuated(input_t *input, inputbind_t binding);