_deps
libdragonblocks.so
dragonblockslauncher
+oprofile_data/
gldebug.cpp
input_handler.cpp
log.cpp
- mainmenu.cpp
map.cpp
mapgen.cpp
mesh.cpp
mesh_gen_mgr.cpp
+ player.cpp
render_engine.cpp
scene.cpp
- server.cpp
shader_program.cpp
texture.cpp
window.cpp
#include "mesh.hpp"
#include "texture.hpp"
+#include "scene.hpp"
+
#define SIZE DRAGONBLOCKS_CHUNK_SIZE
using namespace std;
{
log(string("Update Chunk Mesh at ") + to_string(pos.x) + " " + to_string(pos.y) + " " + to_string(pos.z));
- if (mesh_created && ! effect_finished)
+ if (mesh_created && ! animation_finished)
return;
bool mesh_created_before = mesh_created;
if (! any_drawable_block) {
if (! mesh_created_before) {
- afterEffect();
+ afterAnimation();
} else if (mesh) {
- mesh->reset();
+ delete mesh;
+ mesh = nullptr;
}
return;
}
- if (! mesh) {
- mesh = new Mesh(scene);
- } else {
- mesh->reset();
- }
+ Mesh *oldmesh = mesh;
+
+ mesh = new Mesh(scene, &vertices[0], vertices.size() * sizeof(GLfloat));
mesh->pos = pos * SIZE + SIZE / 2;
- mesh->vertexConfig(&vertices[0], vertices.size() * sizeof(GLfloat));
mesh->textures = textures;
mesh->vertices_per_texture = 6;
if (! mesh_created_before) {
- mesh->effect = Mesh::Effect(Mesh::Effect::Type::FLYIN, Chunk::staticAfterEffect, this);
+ mesh->animation = Mesh::Animation(Mesh::Animation::Type::FLYIN, Chunk::staticAfterAnimation, this);
+ }
+
+ if (oldmesh) {
+ oldmesh->die();
}
- mesh->addToScene();
}
-Chunk::Chunk(Map *m, const glm::ivec3 &p, const Data &d, MeshGenMgr *mgt, Scene *s) : map(m), data(d), pos(p), mesh_gen_mgr(mgt), scene(s)
+Chunk::Chunk(Map *m, const glm::ivec3 &p, const Data &d, MeshGenMgr *mg, Scene *s) : map(m), data(d), pos(p), mesh_gen_mgr(mg), scene(s)
{
addMeshUpdateTask();
}
Chunk::~Chunk()
{
if (mesh) {
- mesh->removeFromScene();
delete mesh;
}
}
-void Chunk::staticAfterEffect(void *chunk)
+void Chunk::staticAfterAnimation(void *chunk)
{
if (chunk) {
- ((Chunk *)chunk)->afterEffect();
+ ((Chunk *)chunk)->afterAnimation();
}
}
-void Chunk::afterEffect()
+void Chunk::afterAnimation()
{
- effect_finished = true;
+ animation_finished = true;
addMeshUpdateTaskWithEdge();
}
~Chunk();
private:
- static void staticAfterEffect(void *);
+ static void staticAfterAnimation(void *);
Map *map;
Mesh *mesh = nullptr;
MeshGenMgr *mesh_gen_mgr;
Scene *scene;
Data data;
- bool effect_finished = false;
+ bool animation_finished = false;
bool mesh_created = false;
- void afterEffect();
- void deleteMesh();
+ void afterAnimation();
};
};
#include "log.hpp"
#include "map.hpp"
#include "mapgen.hpp"
+#include "player.hpp"
#include "render_engine.hpp"
#include "texture.hpp"
#include "window.hpp"
render_engine->window->setPos(0, 0);
render_engine->window->setTitle("Dragonblocks");
render_engine->window->toggleFullscreen();
- render_engine->camera->pos = vec3(8, 8, 8);
render_engine->input_handler->mouse_sensitivity = 20;
- render_engine->input_handler->pitch_move = false;
- render_engine->input_handler->yaw = -90;
- render_engine->input_handler->pitch = -80;
- render_engine->input_handler->speed = 10;
+
render_engine->setSky(vec3(0.52941176470588, 0.8078431372549, 0.92156862745098));
render_engine->setRenderDistance(1000);
render_engine->setFov(86.1);
map = new Map(mapgen, render_engine->mesh_gen_mgr, render_engine->scene);
+ player = Player::createLocalplayer(render_engine->camera, render_engine->input_handler, map);
+
+ player->pitch_move = false;
+ player->yaw = -90;
+ player->pitch = -80;
+ player->speed = 10;
+ player->pos = vec3(8, 8, 8);
+
game = new Game(mapgen);
log("Initialisation complete.");
void Client::start()
{
- render_engine->mesh_gen_mgr->start();
- render_engine->loop();
+ render_engine->startMeshGenMgr();
+ while (render_engine->running()) {
+ render_engine->render();
+ }
}
class Game;
class Map;
class Mapgen;
+ class Player;
class RenderEngine;
class Client
Game *game;
Map *map;
Mapgen *mapgen;
+ Player *player;
RenderEngine *render_engine;
void start();
#include "core.hpp"
#include "client.hpp"
#include "render_engine.hpp"
-#include "server.hpp"
-#include "mainmenu.hpp"
using namespace dragonblocks;
Gametype dragonblocks::gametype;
Client *dragonblocks::client = nullptr;
-Server *dragonblocks::server = nullptr;
-Mainmenu *dragonblocks::mainmenu = nullptr;
extern "C" void _dragonblocks_start_client()
{
client = new Client();
client->start();
}
-
-extern "C" void _dragonblocks_start_server()
-{
- gametype = Gametype::SERVER;
- server = new Server();
- server->start();
-}
-
-extern "C" void _dragonblocks_start_mainmenu()
-{
- gametype = Gametype::MAINMENU;
- mainmenu = new Mainmenu();
- mainmenu->start();
-}
namespace dragonblocks
{
class Client;
- class Server;
- class Mainmenu;
enum Gametype
{
- SERVER,
- CLIENT,
- MAINMENU
+ CLIENT
};
extern Gametype gametype;
extern Client *client;
- extern Server *server;
- extern Mainmenu *mainmenu;
}
case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break;
case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break;
}
- log(string("OpenGL Error: ") + error + " | " + file + " (" + ")");
+ log(string("OpenGL Error: ") + error + " | " + file + " (" + to_string(line) + ")");
}
return errorCode;
}
processKeyInput(dtime);
}
-void InputHandler::processMouseInput(double dtime)
+void InputHandler::listenFor(int key)
{
- vec2 cursor_delta = vec2(mouse_sensitivity * dtime) * (vec2)window->getCursorDelta();
- onMouseMove(dtime, cursor_delta.x, cursor_delta.y);
+ listened_keys.insert(key);
}
-void InputHandler::processKeyInput(double dtime)
+void InputHandler::dontListenFor(int key)
{
- set<int> keysDown;
- for (auto it = listened_keys.begin(); it != listened_keys.end(); it++) {
- int key = *it;
- if (window->wasKeyDown(key)) {
- keysDown.insert(key);
- }
- }
- onKeyPress(dtime, keysDown);
+ listened_keys.erase(key);
}
-void InputHandler::onMouseMove(double dtime, double x, double y)
+void InputHandler::addMouseHandler(void (*callback)(double, double, double))
{
- yaw += x;
- pitch -= y;
- pitch = clamp(pitch, -89.0, 89.0);
- camera->update(yaw, pitch);
+ mouse_handlers.insert(callback);
}
-void InputHandler::onKeyPress(double dtime, set<int> keys)
+void InputHandler::removeMouseHandler(void (*callback)(double, double, double))
{
- vec3 vel = vec3(speed * dtime);
- vec3 front = camera->front(), right = camera->right(), up = camera->up();
- if (! pitch_move) {
- front = normalize(vec3(front.x, 0, front.z));
- up = normalize(vec3(0, up.y, 0));
- }
- if (keys.find(GLFW_KEY_W) != keys.end()) {
- camera->pos += vel * front;
- } else if (keys.find(GLFW_KEY_S) != keys.end()) {
- camera->pos -= vel * front;
- }
- if (keys.find(GLFW_KEY_D) != keys.end()) {
- camera->pos += vel * right;
- } else if (keys.find(GLFW_KEY_A) != keys.end()) {
- camera->pos -= vel * right;
- }
- if (keys.find(GLFW_KEY_SPACE) != keys.end()) {
- camera->pos += vel * up;
- } else if (keys.find(GLFW_KEY_LEFT_SHIFT) != keys.end()) {
- camera->pos -= vel * up;
- }
+ mouse_handlers.erase(callback);
}
-void InputHandler::listenFor(int key)
+void InputHandler::addKeyHandler(void (*callback)(double, set<int>))
{
- listened_keys.insert(key);
+ key_handlers.insert(callback);
}
-void InputHandler::dontListenFor(int key)
+void InputHandler::removeKeyHandler(void (*callback)(double, set<int>))
{
- listened_keys.erase(key);
+ key_handlers.erase(callback);
}
-InputHandler::InputHandler(Camera *c, Window *w) : camera(c), window(w)
+InputHandler::InputHandler(Window *w) : window(w)
+{
+}
+
+void InputHandler::processMouseInput(double dtime)
{
- listenFor(GLFW_KEY_W);
- listenFor(GLFW_KEY_A);
- listenFor(GLFW_KEY_S);
- listenFor(GLFW_KEY_D);
- listenFor(GLFW_KEY_SPACE);
- listenFor(GLFW_KEY_LEFT_SHIFT);
+ vec2 cursor_delta = vec2(mouse_sensitivity * dtime) * (vec2)window->getCursorDelta();
+ double x, y;
+ x = cursor_delta.x;
+ y = cursor_delta.y;
+ if (x != 0 && y != 0) {
+ for (auto it = mouse_handlers.begin(); it != mouse_handlers.end(); it++) {
+ (**it)(dtime, x, y);
+ }
+ }
}
+void InputHandler::processKeyInput(double dtime)
+{
+ set<int> keysDown;
+ for (auto it = listened_keys.begin(); it != listened_keys.end(); it++) {
+ int key = *it;
+ if (window->wasKeyDown(key)) {
+ keysDown.insert(key);
+ }
+ }
+ if (keysDown.begin() != keysDown.end()) {
+ for (auto it = key_handlers.begin(); it != key_handlers.end(); it++) {
+ (**it)(dtime, keysDown);
+ }
+ }
+}
{
public:
void processInput(double);
- void processMouseInput(double);
- void processKeyInput(double);
- void onMouseMove(double, double, double);
- void onKeyPress(double, std::set<int>);
void listenFor(int);
void dontListenFor(int);
+ void addMouseHandler(void (*)(double, double, double));
+ void removeMouseHandler(void (*)(double, double, double));
+ void addKeyHandler(void (*)(double, std::set<int>));
+ void removeKeyHandler(void (*)(double, std::set<int>));
- bool pitch_move;
double mouse_sensitivity;
- double yaw, pitch;
- double speed;
+
+ InputHandler(Window *);
- InputHandler(Camera *, Window *);
+ private:
+ void processMouseInput(double);
+ void processKeyInput(double);
- private:
- Camera *camera;
Window *window;
std::set<int> listened_keys;
+ std::set<void (*)(double, double, double)> mouse_handlers;
+ std::set<void (*)(double, std::set<int>)> key_handlers;
};
}
case Gametype::CLIENT:
gt = "Client";
break;
- case Gametype::SERVER:
- gt = "Server";
- break;
- case Gametype::MAINMENU:
- gt = "Mainmenu";
- break;
}
cout << "[" << gt << "] " << l << endl;
}
+++ /dev/null
-#include "log.hpp"
-#include "mainmenu.hpp"
-
-using namespace dragonblocks;
-
-void Mainmenu::start()
-{
- log("Main Menu is not available yet.");
-}
+++ /dev/null
-#pragma once
-
-namespace dragonblocks
-{
- class Mainmenu
- {
- public:
- void start();
- };
-}
-
chunks.clear();
}
-Map::Map(Mapgen *m, MeshGenMgr *mgt, Scene *s) : mapgen(m), mesh_gen_mgr(mgt), scene(s)
+Map::Map(Mapgen *m, MeshGenMgr *mg, Scene *s) : mapgen(m), mesh_gen_mgr(mg), scene(s)
{
}
using namespace glm;
using namespace dragonblocks;
-double Mesh::Effect::grow_time = 0.25; // s
-double Mesh::Effect::flyin_time = 0.4; // s
-double Mesh::Effect::flyin_offset = 20; // m
-double Mesh::Effect::rotate_speed = 1; // turns/s
+double Mesh::Animation::grow_time = 0.25; // s
+double Mesh::Animation::flyin_time = 0.4; // s
+double Mesh::Animation::flyin_offset = 20; // m
+double Mesh::Animation::rotate_speed = 1; // turns/s
-mat4 Mesh::Effect::getModelMatrix(double dtime, vec3 pos, vec3 size, vec3 rotation_axis, float rotation_angle)
+mat4 Mesh::Animation::getModelMatrix(double dtime, vec3 pos, vec3 size, vec3 rotation_axis, float rotation_angle)
{
mat4 trans = mat4(1.0);
- if (type == Mesh::Effect::Type::NONE)
+ if (type == Mesh::Animation::Type::NONE)
goto finish;
if (expires) {
time_left -= dtime;
if (time_left < 0) {
- type = Mesh::Effect::Type::NONE;
+ type = Mesh::Animation::Type::NONE;
if (on_finish) {
(*on_finish)(extra_data);
}
}
switch (type) {
- case Mesh::Effect::Type::FLYIN:
- pos.y -= Mesh::Effect::flyin_offset * time_left / Mesh::Effect::flyin_time;
+ case Mesh::Animation::Type::FLYIN:
+ pos.y -= Mesh::Animation::flyin_offset * time_left / Mesh::Animation::flyin_time;
break;
- case Mesh::Effect::Type::GROW:
- size *= 1 - time_left / Mesh::Effect::grow_time;
+ case Mesh::Animation::Type::GROW:
+ size *= 1 - time_left / Mesh::Animation::grow_time;
break;
- case Mesh::Effect::Type::ROTATE:
- rotation_angle += glfwGetTime() * Mesh::Effect::rotate_speed * pi<float>() * 2;
+ case Mesh::Animation::Type::ROTATE:
+ rotation_angle += glfwGetTime() * Mesh::Animation::rotate_speed * pi<float>() * 2;
}
finish:
return trans;
}
-Mesh::Effect::Effect(Mesh::Effect::Type t, void (*o)(void *), void *e) : type(t), on_finish(o), extra_data(e)
+Mesh::Animation::Animation(Mesh::Animation::Type t, void (*o)(void *), void *e) : type(t), on_finish(o), extra_data(e)
{
switch(type) {
- case Mesh::Effect::Type::FLYIN:
+ case Mesh::Animation::Type::FLYIN:
expires = true;
- time_left = Mesh::Effect::flyin_time;
+ time_left = Mesh::Animation::flyin_time;
break;
- case Mesh::Effect::Type::GROW:
+ case Mesh::Animation::Type::GROW:
expires = true;
- time_left = Mesh::Effect::grow_time;
+ time_left = Mesh::Animation::grow_time;
break;
- case Mesh::Effect::Type::ROTATE:
+ case Mesh::Animation::Type::ROTATE:
expires = false;
+ break;
}
}
-void Mesh::vertexConfig(const GLvoid *v, GLsizei s)
-{
- if (vertices_changed || configured)
- throw runtime_error("Attempt to configure Mesh that is already configured");
- vertices = malloc(s);
- memcpy(vertices, v, s);
- vertices_size = s;
- vertices_changed = true;
-}
-
void Mesh::render(double dtime, ShaderProgram *shader_program)
{
- if (vertices_changed) {
- runVertexConfig();
- }
-
- if (! configured)
+ rendering = true;
+
+ if (do_delete) {
+ delete this;
return;
+ } else if (prepare_death) {
+ do_delete = true;
+ }
+
+ if (! configured) {
+ configure();
+ }
shader_program->use(); CHECKERR
- mat4 model_matrix = effect.getModelMatrix(dtime, pos, size, rotation_axis, rotation_angle); CHECKERR
+ mat4 model_matrix = animation.getModelMatrix(dtime, pos, size, rotation_axis, rotation_angle); CHECKERR
shader_program->set("model", model_matrix); CHECKERR
}
glBindVertexArray(0); CHECKERR
glBindTexture(GL_TEXTURE_2D, 0); CHECKERR
+
+ rendering = false;
}
-void Mesh::reset()
+bool Mesh::isRendering()
{
- removeFromScene();
- pos = vec3(0.0);
- size = vec3(1.0);
- rotation_axis = vec3(0.0, 1.0, 0.0);
- vertices_per_texture = 0;
- textures = {};
- rotation_angle = 0;
- if (VAO) {
- glDeleteVertexArrays(1, &VAO); CHECKERR
- }
- if (VBO) {
- glDeleteBuffers(1, &VAO); CHECKERR
- }
- vertices_changed = false;
- if (vertices) {
- free(vertices);
- }
- vertices = NULL;
- configured = false;
+ return rendering;
}
-void Mesh::addToScene()
+void Mesh::die()
{
- scene->add(this);
+ prepare_death = true;
}
-void Mesh::removeFromScene()
+Mesh::Mesh(Scene *s, const GLvoid *v, GLsizei vs): pos(0), size(1), rotation_axis(0, 1, 0), scene(s), vertices_size(vs)
{
- scene->remove(this);
+ if (! v || ! vs)
+ throw runtime_error("Invalid Mesh configuration");
+ vertices = malloc(vs);
+ memcpy(vertices, v, vs);
+ scene->add(this);
}
-Mesh::Mesh(Scene *s): scene(s)
+Mesh::~Mesh()
{
- reset();
+ scene->remove(this);
+ if (VAO) {
+ glDeleteVertexArrays(1, &VAO); CHECKERR
+ }
+ if (VBO) {
+ glDeleteBuffers(1, &VAO); CHECKERR
+ }
}
-void Mesh::runVertexConfig()
+void Mesh::configure()
{
- if (! vertices || vertices_size == 0)
- throw runtime_error("Invalid Mesh configuration");
-
glGenVertexArrays(1, &VAO); CHECKERR
glGenBuffers(1, &VBO); CHECKERR
glBindVertexArray(VAO); CHECKERR
glBindBuffer(GL_ARRAY_BUFFER, VBO); CHECKERR
-
+
glBufferData(GL_ARRAY_BUFFER, vertices_size, vertices, GL_STATIC_DRAW); CHECKERR
GLsizei stride = 5 * sizeof(GLfloat); CHECKERR
free(vertices);
vertices = NULL;
- vertices_changed = false;
configured = true;
}
class Mesh
{
public:
- class Effect
+ class Animation
{
public:
- static double grow_time; // s
- static double flyin_time; // s
- static double flyin_offset; // m
- static double rotate_speed; // turns/s
+ static double grow_time;
+ static double flyin_time;
+ static double flyin_offset;
+ static double rotate_speed;
enum Type
{
glm::mat4 getModelMatrix(double, glm::vec3, glm::vec3, glm::vec3, float);
- Effect() = default;
- Effect(Type, void (*)(void *) = nullptr, void * = nullptr);
- Effect(const Effect &) = default;
+ Animation() = default;
+ Animation(Type, void (*)(void *) = nullptr, void * = nullptr);
+ Animation(const Animation &) = default;
private:
Type type = Type::NONE;
int vertices_per_texture;
glm::vec3 pos, size, rotation_axis;
- float rotation_angle;
+ float rotation_angle = 0;
std::vector<Texture> textures;
- Effect effect;
+ Animation animation;
- void reset();
- void vertexConfig(const GLvoid *v, GLsizei s);
void render(double dtime, ShaderProgram *);
- void addToScene();
- void removeFromScene();
- void runVertexConfig();
+ bool isRendering();
+ void die();
- Mesh(Scene *);
+ Mesh(Scene *, const GLvoid *, GLsizei);
+ ~Mesh();
private:
GLuint VAO = 0, VBO = 0;
Scene *scene;
GLvoid *vertices = NULL;
GLsizeiptr vertices_size;
- bool configured;
- bool vertices_changed;
+ bool configured = false;
+ bool rendering = false;
+ bool prepare_death = false;
+ bool do_delete = false;
+ void configure();
};
}
--- /dev/null
+#include <stdexcept>
+#include "camera.hpp"
+#include "input_handler.hpp"
+#include "map.hpp"
+#include "player.hpp"
+
+using namespace std;
+using namespace glm;
+using namespace dragonblocks;
+
+Player* Player::localplayer = nullptr;
+
+Player *Player::createLocalplayer(Camera *c, InputHandler *i, Map *m)
+{
+ if (localplayer)
+ throw runtime_error("Localplayer already exists");
+ return localplayer = new Player(c, i, m);
+}
+
+void Player::staticMouseHandler(double dtime, double x, double y)
+{
+ localplayer->mouseHandler(dtime, x, y);
+}
+
+void Player::staticKeyHandler(double dtime, set<int> keys)
+{
+ localplayer->keyHandler(dtime, keys);
+}
+
+void Player::mouseHandler(double dtime, double x, double y)
+{
+ yaw += x;
+ pitch -= y;
+ pitch = clamp(pitch, -89.0, 89.0);
+ camera->update(yaw, pitch);
+}
+
+void Player::keyHandler(double dtime, set<int> keys)
+{
+ vec3 vel = vec3(speed * dtime);
+ vec3 front = camera->front(), right = camera->right(), up = camera->up();
+ if (! pitch_move) {
+ front = normalize(vec3(front.x, 0, front.z));
+ up = normalize(vec3(0, up.y, 0));
+ }
+ if (keys.find(GLFW_KEY_W) != keys.end()) {
+ pos += vel * front;
+ } else if (keys.find(GLFW_KEY_S) != keys.end()) {
+ pos -= vel * front;
+ }
+ if (keys.find(GLFW_KEY_D) != keys.end()) {
+ pos += vel * right;
+ } else if (keys.find(GLFW_KEY_A) != keys.end()) {
+ pos -= vel * right;
+ }
+ if (keys.find(GLFW_KEY_SPACE) != keys.end()) {
+ pos += vel * up;
+ } else if (keys.find(GLFW_KEY_LEFT_SHIFT) != keys.end()) {
+ pos -= vel * up;
+ }
+ camera->pos = pos;
+ loadChunks();
+}
+
+void Player::loadChunks()
+{
+ ivec3 chunkp = Map::getChunkPos(pos);
+ for (int x = chunkp.x - 1; x <= chunkp.x + 1; x++) {
+ for (int y = chunkp.y - 1; y < chunkp.y + 1; y++) {
+ for (int z = chunkp.z - 1; z <= chunkp.z + 1; z++) {
+ map->createChunk(ivec3(x, y, z));
+ }
+ }
+ }
+}
+
+Player::Player(Camera *c, InputHandler *i, Map *m) : camera(c), input_handler(i), map(m)
+{
+ input_handler->listenFor(GLFW_KEY_W);
+ input_handler->listenFor(GLFW_KEY_A);
+ input_handler->listenFor(GLFW_KEY_S);
+ input_handler->listenFor(GLFW_KEY_D);
+ input_handler->listenFor(GLFW_KEY_SPACE);
+ input_handler->listenFor(GLFW_KEY_LEFT_SHIFT);
+
+ input_handler->addMouseHandler(Player::staticMouseHandler);
+ input_handler->addKeyHandler(Player::staticKeyHandler);
+}
--- /dev/null
+#pragma once
+
+#include <vector>
+#include "gl.hpp"
+
+namespace dragonblocks
+{
+ class Camera;
+ class InputHandler;
+ class Map;
+
+ class Player
+ {
+ public:
+ static Player *createLocalplayer(Camera *, InputHandler *, Map *);
+
+ glm::vec3 pos;
+ bool pitch_move;
+ double yaw, pitch;
+ double speed;
+
+ private:
+ static Player *localplayer;
+
+ static void staticMouseHandler(double, double, double);
+ static void staticKeyHandler(double, std::set<int>);
+
+ Camera *camera;
+ InputHandler *input_handler;
+ Map *map;
+
+ void mouseHandler(double, double, double);
+ void keyHandler(double, std::set<int>);
+ void loadChunks();
+
+ Player(Camera *, InputHandler *, Map *);
+ };
+}
#include <stdexcept>
#include <glm/gtc/matrix_transform.hpp>
#include "camera.hpp"
-#include "client.hpp" // ugly, only keep until player is implemented
-#include "core.hpp" // this one too
#include "gldebug.hpp"
#include "input_handler.hpp"
-#include "map.hpp" // this one three
#include "mesh_gen_mgr.hpp"
#include "render_engine.hpp"
#include "scene.hpp"
glfwPollEvents(); CHECKERR
}
-void RenderEngine::loadChunks()
+bool RenderEngine::running()
{
- ivec3 chunkp = Map::getChunkPos(camera->pos);
- for (int x = chunkp.x - 1; x <= chunkp.x + 1; x++) {
- for (int y = chunkp.y - 1; y < chunkp.y + 1; y++) {
- for (int z = chunkp.z - 1; z <= chunkp.z + 1; z++) {
- client->map->createChunk(ivec3(x, y, z));
- }
- }
- }
-}
-
-void RenderEngine::loop()
-{
- while (! window->shouldClose()) {
- render();
- loadChunks();
- }
+ return ! window->shouldClose();
}
void RenderEngine::updateProjectionMatrix()
updateProjectionMatrix();
}
+void RenderEngine::startMeshGenMgr()
+{
+ mesh_gen_mgr->start();
+}
+
RenderEngine::RenderEngine()
{
if (! glfwInit())
window = Window::create(this);
camera = new Camera;
- input_handler = new InputHandler(camera, window);
+ input_handler = new InputHandler(window);
mesh_gen_mgr = new MeshGenMgr;
scene = new Scene;
Window *window;
void render();
- void loadChunks();
- void loop();
+ bool running();
void updateViewMatrix();
void updateProjectionMatrix();
void setSky(glm::vec3);
void setRenderDistance(double);
void setFov(double);
+ void startMeshGenMgr();
+
RenderEngine();
~RenderEngine();
+++ /dev/null
-#include "log.hpp"
-#include "server.hpp"
-
-using namespace dragonblocks;
-
-void Server::start()
-{
- log("Server is not available yet.");
-}
+++ /dev/null
-#pragma once
-
-namespace dragonblocks
-{
- class Server
- {
- public:
- void start();
- };
-}
-
projects / dragonblocks3d.git / commitdiff