Added player, refactored mesh code

[dragonblocks3d.git] / src / dragonblocks / mesh.cpp

diff --git a/src/dragonblocks/mesh.cpp b/src/dragonblocks/mesh.cpp
index f934e8e58f005d5e78f8a66a1a8ba46fd67d9dc8..2d077f3d0a558cb15b8b8fec0e20e5dd33893e90 100644 (file)
--- a/src/dragonblocks/mesh.cpp
+++ b/src/dragonblocks/mesh.cpp
@@ -12,22 +12,22 @@ using namespace std;
 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);
                        }
@@ -36,16 +36,16 @@ mat4 Mesh::Effect::getModelMatrix(double dtime, vec3 pos, vec3 size, vec3 rotati
        }       
 
        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:
@@ -57,46 +57,43 @@ mat4 Mesh::Effect::getModelMatrix(double dtime, vec3 pos, vec3 size, vec3 rotati
        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
        
@@ -107,57 +104,48 @@ void Mesh::render(double dtime, ShaderProgram *shader_program)
        }
        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
@@ -172,6 +160,5 @@ void Mesh::runVertexConfig()
        
        free(vertices);
        vertices = NULL;
-       vertices_changed = false;
        configured = true;
 }