SimpleMesh.cpp

Go to the documentation of this file.

#include "Application.hpp"
#include "meshes/cube.hpp"
#include "meshes/plane.hpp"


SimpleMeshInstance::SimpleMeshInstance(Application* app, SimpleMesh* mesh, bool pickable)
    : ISceneObject(app, pickable)
    , m_mesh(mesh)
{
}
SimpleMeshInstance::~SimpleMeshInstance()
{
    m_mesh->unregisterInstance(this);
}


void SimpleMeshInstance::prepareDraw(DrawArgs& args, Shader* shader)
{
    shader->uniform("model", m_transformation.getMatrix()); 
    shader->uniform("id",    m_pickable ? m_id : (id_t) 0); 
    
    for (auto& kvp : m_uniforms)
        kvp.second(shader);

    if (m_app->getPicker().hasFocusId() && m_id == m_app->getPicker().getFocusId())
    {
        shader->uniform("color", glm::mix(vec3(1,0,0), vec3(1,1,0), (float)(0.5 + 0.5*sin(args.time*5))));
    }
}
bool SimpleMeshInstance::update(double time, double timeDelta)
{
    return m_transformation.needsRecalc();
}



void SimpleMesh::create()
{
    glGenBuffers(1, &m_positionsBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_positionsBuffer);
    glBufferData(GL_ARRAY_BUFFER, m_positions.size() * sizeof(vec3), m_positions.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &m_normalsBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_normalsBuffer);
    glBufferData(GL_ARRAY_BUFFER, m_normals.size() * sizeof(vec3), m_normals.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &m_uvBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_uvBuffer);
    glBufferData(GL_ARRAY_BUFFER, m_uvs.size() * sizeof(vec2), m_uvs.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &m_indicesBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indicesBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indices.size() * sizeof(uint), m_indices.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);


    glGenVertexArrays(1, &m_vao);
    glBindVertexArray(m_vao);

    glBindBuffer(GL_ARRAY_BUFFER, m_positionsBuffer);
    GLint positionIndex = Shader::position;
    glEnableVertexAttribArray(positionIndex);
    glVertexAttribPointer(positionIndex, 3, GL_FLOAT, GL_FALSE, 0, 0);

    glBindBuffer(GL_ARRAY_BUFFER, m_normalsBuffer);
    GLint normalIndex = Shader::normal;
    glEnableVertexAttribArray(normalIndex);
    glVertexAttribPointer(normalIndex, 3, GL_FLOAT, GL_FALSE, 0, 0);

    glBindBuffer(GL_ARRAY_BUFFER, m_uvBuffer);
    GLint uvIndex = Shader::uv;
    glEnableVertexAttribArray(uvIndex);
    glVertexAttribPointer(uvIndex, 2, GL_FLOAT, GL_FALSE, 0, 0);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indicesBuffer);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
SimpleMesh::~SimpleMesh()
{
    glDeleteBuffers(1, &m_positionsBuffer);
    glDeleteBuffers(1, &m_indicesBuffer);
    glDeleteBuffers(1, &m_normalsBuffer);
    glDeleteBuffers(1, &m_uvBuffer);
    glDeleteVertexArrays(1, &m_vao);
}
void SimpleMesh::drawAllInstances(DrawArgs& args, Shader* shader)
{
    glBindVertexArray(m_vao);
    {
        for(auto& instance : m_instances)
        {
            instance->prepareDraw(args, shader);
            
            glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, 0);
        }
    }
    glBindVertexArray(0);
}
SimpleMeshInstance* SimpleMesh::createInstance(bool pickable)
{
    SimpleMeshInstance* instance = new SimpleMeshInstance(m_app, this, pickable);
    m_instances.insert(instance);

    m_app->getSceneGraph().add(instance);

    return instance;
}
void SimpleMesh::unregisterInstance(SimpleMeshInstance* obj)
{
    m_instances.erase(m_instances.find(obj));
}













void copy_to_mesh(vector<vec3>* _positions, vector<vec3>* _normals, vector<vec2>* _uvs, vector<uint>* _idx,
                  float const *positions, float const * normals, float const *uvs, uint const *indices, size_t vertexCount, size_t indexCount)
{
    _positions->resize(vertexCount);
    memcpy(_positions->data(), positions, vertexCount * sizeof(vec3));
    
    _normals->resize(vertexCount);
    memcpy(_normals->data(), normals, vertexCount * sizeof(vec3));
    
    _uvs->resize(vertexCount);
    memcpy(_uvs->data(), uvs, vertexCount * sizeof(vec2));
    
    _idx->resize(indexCount);
    memcpy(_idx->data(), indices, indexCount * sizeof(uint));
}
function<void(vector<vec3>*, vector<vec3>*, vector<vec2>*, vector<uint>*)> create_mesh(float const *positions, float const * normals, float const *uvs, uint const *indices, size_t vertexCount, size_t indexCount)
{
    return [positions, normals, uvs, indices, vertexCount, indexCount]
           (vector<vec3>* _positions, vector<vec3>* _normals, vector<vec2>* _uvs, vector<uint>* _idx)
           {
               copy_to_mesh(_positions, _normals, _uvs, _idx, positions, normals, uvs, indices, vertexCount, indexCount);
           };
}



SimpleMeshes::SimpleMeshes(Application* app)
    : m_app(app)
    , m_shader(m_app->getShaders().get("mesh"))
{
    create("cube", create_mesh(cube_positions, 
                               cube_normals, 
                               cube_uvs, 
                               cube_indices,
                               ARRAYSIZE(cube_positions)/3,
                               ARRAYSIZE(cube_indices)));

    create("plane", create_mesh(plane_positions, 
                                plane_normals, 
                                plane_uvs, 
                                plane_indices,
                                ARRAYSIZE(plane_positions)/3,
                                ARRAYSIZE(plane_indices)));
}

SimpleMesh* SimpleMeshes::get(string const & name)
{
    auto found = m_meshes.find(name);

    if (found == m_meshes.end())
        return nullptr;

    return found->second.get();
}

void SimpleMeshes::drawAll(DrawArgs& args)
{
    m_shader->use();

    m_shader->uniform("proj", *args.projectionMatrix);
    m_shader->uniform("view", *args.viewMatrix);
    
    for(auto& mesh : m_meshes)
        mesh.second->drawAllInstances(args, m_shader);
}