src/dragonblocks/render_engine.cpp

   1 #include <stdexcept>
   2 #include <glm/gtc/matrix_transform.hpp>
   3 #include "camera.hpp"
   4 #include "client.hpp"                                           // ugly, only keep until player is implemented
   5 #include "core.hpp"                                             // this one too
   6 #include "gldebug.hpp"
   7 #include "input_handler.hpp"
   8 #include "map.hpp"                                              // this one three
   9 #include "mesh_gen_mgr.hpp"
  10 #include "render_engine.hpp"
  11 #include "scene.hpp"
  12 #include "shader_program.hpp"
  13 #include "window.hpp"
  14
  15 using namespace std;
  16 using namespace glm;
  17 using namespace dragonblocks;
  18
  19 void RenderEngine::render()
  20 {
  21         double dtime = glfwGetTime() - last_time;
  22         last_time = glfwGetTime();
  23
  24         input_handler->processInput(dtime);
  25
  26         glEnable(GL_DEPTH_TEST); CHECKERR
  27         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); CHECKERR
  28
  29         updateViewMatrix();     CHECKERR
  30
  31         scene->render(dtime, shader_program);
  32
  33         window->swapBuffers(); CHECKERR
  34         glfwPollEvents(); CHECKERR
  35 }
  36
  37 void RenderEngine::loadChunks()
  38 {
  39         ivec3 chunkp = Map::getChunkPos(camera->pos);
  40         for (int x = chunkp.x - 1; x <= chunkp.x + 1; x++) {
  41                 for (int y = chunkp.y - 1; y < chunkp.y + 1; y++) {
  42                         for (int z = chunkp.z - 1; z <= chunkp.z + 1; z++) {
  43                                 client->map->createChunk(ivec3(x, y, z));
  44                         }
  45                 }
  46         }
  47 }
  48
  49 void RenderEngine::loop()
  50 {
  51         while (! window->shouldClose()) {
  52                 render();
  53                 loadChunks();
  54         }
  55 }
  56
  57 void RenderEngine::updateProjectionMatrix()
  58 {
  59         dvec2 bounds = window->getSize();
  60         mat4 projection_matrix = perspective(radians(fov), bounds.x / bounds.y, 0.01, render_distance);
  61         shader_program->set("projection", projection_matrix); CHECKERR
  62 }
  63
  64 void RenderEngine::updateViewMatrix()
  65 {
  66         shader_program->set("view", camera->getViewMatrix()); CHECKERR
  67 }
  68
  69 void RenderEngine::setSky(vec3 sky)
  70 {
  71         glClearColor(sky.r, sky.g, sky.b, 1.0); CHECKERR
  72         shader_program->set("sky", sky); CHECKERR
  73 }
  74
  75 void RenderEngine::setRenderDistance(double d)
  76 {
  77         render_distance = d;
  78         updateProjectionMatrix();
  79 }
  80
  81 void RenderEngine::setFov(double f)
  82 {
  83         fov = f;
  84         updateProjectionMatrix();
  85 }
  86
  87 RenderEngine::RenderEngine()
  88 {
  89         if (! glfwInit())
  90                 throw runtime_error("Failed to initialize GLFW");
  91         glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  92         glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  93         glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  94
  95         window = Window::create(this);
  96         camera = new Camera;
  97         input_handler = new InputHandler(camera, window);
  98         mesh_gen_mgr = new MeshGenMgr;
  99         scene = new Scene;
 100
 101         GLenum glew_init_err = glewInit();
 102         if (glew_init_err != GLEW_OK)
 103                 throw runtime_error("Failed to initialize GLEW");
 104
 105         shader_program = new ShaderProgram("shaders");
 106
 107         setSky(vec3(1.0, 1.0, 1.0));
 108         setRenderDistance(16);
 109         setFov(45);
 110
 111         last_time = glfwGetTime();
 112 }
 113
 114 RenderEngine::~RenderEngine()
 115 {
 116         delete window;
 117         delete camera;
 118         delete input_handler;
 119         delete mesh_gen_mgr;
 120         delete scene;
 121         delete shader_program;
 122 }