Dawn/src/dawnglfw/host/DawnGLFWHost.cpp

/**
 * Copyright (c) 2022 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

#include "DawnGLFWHost.hpp"
#include "game/DawnGame.hpp"
#include "dawnopengl.hpp"
#include "display/BackBufferRenderTarget.hpp"

using namespace Dawn;

// Static declaration of the host, needed due to GLFW events being C-like
DawnHost *DAWN_HOST = nullptr;

// Host
DawnHost::DawnHost() {
  this->data = new DawnHostData();
  this->data->window = nullptr;
}

int32_t DawnHost::init(DawnGame *game) {
  // Update values
  this->game = game;
  DAWN_HOST = this;

  // Init GLFW
  if(!glfwInit()) return DAWN_GLFW_INIT_RESULT_INIT_FAILED;

  glfwSetErrorCallback(&glfwOnError);
  
  // Setup window hints 
  glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, false);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
  
  // Create Window
  this->data->window = glfwCreateWindow(
    DAWN_GLFW_WINDOW_WIDTH_DEFAULT,
    DAWN_GLFW_WINDOW_HEIGHT_DEFAULT,
    "Dawn", NULL, NULL
  );
  if(this->data->window == nullptr) {
    glfwTerminate();
    return DAWN_GLFW_INIT_RESULT_WINDOW_CREATE_FAILED;
  }

  // Load GLAD
  glfwMakeContextCurrent(this->data->window);
  glfwSwapInterval(1);
  gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
  assertNoGLError();

  // Override the defaults
  game->renderManager.backBuffer.setSize(
    DAWN_GLFW_WINDOW_WIDTH_DEFAULT,
    DAWN_GLFW_WINDOW_HEIGHT_DEFAULT
  );
  assertNoGLError();

  // Default keybinds
  game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_ENTER);
  game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_E);
  game->inputManager.bind(INPUT_BIND_ACCEPT, GLFW_KEY_SPACE);
  game->inputManager.bind(INPUT_BIND_POSITIVE_X, GLFW_KEY_D);
  game->inputManager.bind(INPUT_BIND_NEGATIVE_X, GLFW_KEY_A);
  game->inputManager.bind(INPUT_BIND_POSITIVE_Y, GLFW_KEY_S);
  game->inputManager.bind(INPUT_BIND_NEGATIVE_Y, GLFW_KEY_W);
  game->inputManager.bind(INPUT_BIND_CANCEL, GLFW_KEY_ESCAPE);
  game->inputManager.bind(INPUT_BIND_CANCEL, GLFW_KEY_Q);

  game->inputManager.bind(INPUT_BIND_MOUSE_CLICK, INPUT_MANAGER_AXIS_MOUSE_0);
  game->inputManager.bind(INPUT_BIND_MOUSE_X, INPUT_MANAGER_AXIS_MOUSE_X);
  game->inputManager.bind(INPUT_BIND_MOUSE_Y, INPUT_MANAGER_AXIS_MOUSE_Y);

  // Initialize the game
  auto result = game->init();
  if(result != DAWN_GAME_INIT_RESULT_SUCCESS) return result;

  // Hard-Load the first scene assets.
  if(game->scene != nullptr) {
    auto assets = game->scene->getRequiredAssets();
    game->assetManager.queueLoad(assets);
    game->assetManager.syncLoad();
    game->scene->stage();
  }

  // Set up event listeners
  glfwSetFramebufferSizeCallback(this->data->window, &glfwOnResize);
  glfwSetKeyCallback(this->data->window, &glfwOnKey);
  glfwSetCursorPosCallback(this->data->window, &glfwOnCursor);
  glfwSetMouseButtonCallback(this->data->window, &glfwOnMouseButton);

  return DAWN_HOST_INIT_RESULT_SUCCESS;
}

int32_t DawnHost::start(DawnGame *game) {
  double_t time, newTime;
  float_t fDelta;
  int32_t updateResult;

  // Main Render Loop 
  time = 0.0f;
  while(!glfwWindowShouldClose(this->data->window)) {
    // Determine the delta.
    newTime = glfwGetTime();
    fDelta = (float_t)(newTime - time);
    time = newTime;

    // Perform update
    updateResult = this->update(game, fDelta);

    // Did the update complete successfully?
    if(updateResult == DAWN_HOST_UPDATE_RESULT_EXIT) {
      break;
    } else if(updateResult != DAWN_HOST_UPDATE_RESULT_SUCCESS) {
      return DAWN_GLFW_START_RESULT_UPDATE_FAILED;
    }
    
    // Tick the engine.
    glfwSwapBuffers(this->data->window);
    
    // Update events
    glfwPollEvents();
  }

  return DAWN_HOST_START_RESULT_EXIT_SUCCESS;
}

int32_t DawnHost::update(DawnGame *game, float_t delta) {
  // Tick game.
  auto ret = game->update(delta);
  switch(ret) {
    case DAWN_GAME_UPDATE_RESULT_SUCCESS:
      return DAWN_HOST_UPDATE_RESULT_SUCCESS;
    
    case DAWN_GAME_UPDATE_RESULT_EXIT:
      return DAWN_HOST_UPDATE_RESULT_EXIT;

    default:
      return ret;
  }
}

void DawnHost::unload(DawnGame *game) {
  glfwDestroyWindow(this->data->window);
  this->data->window = nullptr;
  glfwTerminate();
}

DawnHost::~DawnHost() {
  delete this->data;
  DAWN_HOST = nullptr;
}


// GLFW Callbacks
void glfwOnError(int error, const char* description) {
  fputs(description, stderr);
}

void glfwOnResize(GLFWwindow *window, int32_t w, int32_t h) {
  if(DAWN_HOST == nullptr) return;

  // TODO: I may throttle this, it calls for every frame the window's resized.
  DAWN_HOST->game->renderManager.backBuffer.setSize((float_t)w, (float_t)h);
}

void glfwOnKey(
  GLFWwindow *window,
  int32_t key,
  int32_t scancode,
  int32_t action,
  int32_t mods
) {
  if(DAWN_HOST == nullptr) return;

  // Determine Value
  float_t value;
  if(action == GLFW_PRESS) {
    value = 1.0f;
  } else if(action == GLFW_RELEASE) {
    value = 0.0f;
  } else {
    return;
  }

  // Determine the input axis
  DAWN_HOST->game->inputManager.rawInputValues[key] = value;
}

void glfwOnCursor(GLFWwindow* window, double xpos, double ypos) {
  if(DAWN_HOST == nullptr) return;

  DAWN_HOST->game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_X] = mathClamp<float_t>(
    (float_t)(xpos / DAWN_HOST->game->renderManager.backBuffer.getWidth()),
    0, 1
  );
  DAWN_HOST->game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_Y] = mathClamp<float_t>(
    (float_t)(ypos / DAWN_HOST->game->renderManager.backBuffer.getHeight()),
    0, 1
  );
}

void glfwOnMouseButton(GLFWwindow* window, int button, int action, int mods) {
  if(DAWN_HOST == nullptr) return;
  assertTrue(window == DAWN_HOST->data->window, "glfwOnMouseButton: Window mismatch");

  float_t value = action == GLFW_PRESS ? 1 : 0;
  DAWN_HOST->game->inputManager.rawInputValues[INPUT_MANAGER_AXIS_MOUSE_0 + button] = value;
}