Scene.cpp

Go to the documentation of this file.

#include "Application.hpp"

SceneInstance::SceneInstance(Application* app, Scene* parent, bool pickable)
    : ISceneObject(app, pickable)
    , m_scene(parent)
    , m_animation(AnimationStart(-1, 0.0f))
{
    m_state.resize(m_scene->m_drawNodeCount, mat4(1.0f));
}
SceneInstance::~SceneInstance()
{
    m_scene->unregisterInstance(this);
}
bool SceneInstance::update(double time, double timeDelta)
{
    float ftime = (float)time;

    if (!m_animationQueue.empty())
    {
        auto& next = m_animationQueue.front();

        if (next.time <= ftime)
        {
            m_animation = next;
            m_animationQueue.pop();
        }
        return true;
    }

    return m_animation.animation != -1 || m_transformation.needsRecalc();
}
void SceneInstance::queueAnimation(float time, uint animation)
{
    m_animationQueue.push(AnimationStart((int)animation, time));
}
void SceneInstance::queueAnimation(float time, string animation)
{
    m_animationQueue.push(AnimationStart((int)m_scene->m_animationsByName[animation], time));
}





Scene::Scene(Application* app, string const & name)
    : m_app(app)
    , m_name(name)
    , m_positionsBuffer(0)
    , m_uvBuffer(0)
    , m_normalsBuffer(0)
    , m_indicesBuffer(0)
    , m_boneIdBuffer(0)
    , m_boneWeightBuffer(0)
    , m_vao(0)
    , m_instancesInBuffer(0)
    , m_needToUpdateIdBuffer(true)
{
    Assimp::Importer imp;

    auto scene = imp.ReadFile(("content\\scenes\\" + name).c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals);

    if (!scene)
    {
        cerr << "ERROR: Failed to load scene '" << name << "'" << endl;
        exit(EXIT_FAILURE);
    }

    string baseDir = "scenes\\" + name;
    baseDir = baseDir.substr(0, baseDir.find_last_of("\\") + 1);

    // load materials
    {
        aiColor4D color;
        vec4 ambient;
        vec4 diffuse;
        vec4 specular;
        float shininess;
        Texture* texture;

        m_materials.resize(scene->mNumMaterials);
        for (uint i = 0; i < m_materials.size(); i++)
        {
            auto& assimpMtl = scene->mMaterials[i];
            auto& mtl = m_materials[i];


            if (AI_SUCCESS == aiGetMaterialColor(assimpMtl, AI_MATKEY_COLOR_AMBIENT, &color))
                ambient = vec4(color.r, color.g, color.b, color.a);
            else
                ambient = vec4(0, 0, 0, 0);

            if (AI_SUCCESS == aiGetMaterialColor(assimpMtl, AI_MATKEY_COLOR_DIFFUSE, &color))
                diffuse = vec4(color.r, color.g, color.b, color.a);
            else
                diffuse = vec4(0, 0, 0, 0);

            if (AI_SUCCESS == aiGetMaterialColor(assimpMtl, AI_MATKEY_COLOR_SPECULAR, &color))
                specular = vec4(color.r, color.g, color.b, color.a);
            else
                specular = vec4(0, 0, 0, 0);

            uint max;
            shininess = 1.0f;
            aiGetMaterialFloatArray(assimpMtl, AI_MATKEY_SHININESS, &(shininess), &max);
             

            aiString texPath;
            if (AI_SUCCESS == assimpMtl->GetTexture(aiTextureType_DIFFUSE, 0, &texPath))
                texture = app->getTextures().get("..\\" + baseDir + texPath.C_Str());
            else
                texture = nullptr; 

            mtl.reset(new Material(ambient, diffuse, specular, shininess, texture));
        }
    }

    map<string, uint> bones;
     
    // load meshes
    {
        vector<vec3> positions;
        vector<vec2> uvs;
        vector<vec3> normals;
        vector<ivec4> boneIds;
        vector<vec4> boneWeights;
        vector<uint> indices;

        vector<uint> boneCount;

        m_meshes.resize(scene->mNumMeshes);
        for (uint i = 0; i < m_meshes.size(); i++)
        {
            auto& assimpMesh = scene->mMeshes[i];
            auto& mesh = m_meshes[i];

            if (!assimpMesh->HasPositions())
            {
                cerr << "ERROR: Failed to load scene '" << name << "' (Mesh '" << assimpMesh->mName.C_Str() << "' has no positions)" << endl;
                exit(EXIT_FAILURE);
            }
            if (!assimpMesh->HasNormals())
            {
                cerr << "ERROR: Failed to load scene '" << name << "' (Mesh '" << assimpMesh->mName.C_Str() << "' has no normals)" << endl;
                exit(EXIT_FAILURE);
            }
            if (!assimpMesh->HasTextureCoords(0))
            {
                cerr << "ERROR: Failed to load scene '" << name << "' (Mesh '" << assimpMesh->mName.C_Str() << "' has no texture-coordinates)" << endl;
                exit(EXIT_FAILURE);
            }
            if (!assimpMesh->HasFaces())
            {
                cerr << "ERROR: Failed to load scene '" << name << "' (Mesh '" << assimpMesh->mName.C_Str() << "' has no faces)" << endl;
                exit(EXIT_FAILURE);
            }
            if (!assimpMesh->HasBones())
            {
                cerr << "ERROR: Failed to load scene '" << name << "' (Mesh '" << assimpMesh->mName.C_Str() << "' has no bones)" << endl;
                exit(EXIT_FAILURE);
            }

            auto meshBaseVertex = positions.size();
            auto meshBaseIdx = indices.size();
            auto meshBaseBone = m_boneOffsets.size();

            auto meshVertexCount = assimpMesh->mNumVertices;
            auto meshIndexCount = assimpMesh->mNumFaces * 3;
            auto meshBoneCount = assimpMesh->mNumBones;

            auto newVertexCount = meshBaseVertex + meshVertexCount;
            auto newIndexCount = meshBaseIdx + meshIndexCount;
            auto newBoneCount = meshBaseBone + meshBoneCount;

            indices.reserve(newIndexCount);
            for (uint fid = 0; fid < meshIndexCount/3; fid++)
            {
                auto& face = assimpMesh->mFaces[fid];

                if (face.mNumIndices != 3)
                {
                    cerr << "ERROR: Failed to load scene '" << name << "' (Mesh '" << assimpMesh->mName.C_Str() << "' has faces with " << face.mNumIndices << " vertices)" << endl;
                    exit(EXIT_FAILURE);
                }

                for (size_t iid = 0; iid < 3; iid++)
                    indices.push_back(meshBaseVertex + face.mIndices[iid]);
            }

            uvs.reserve(newVertexCount);
            positions.reserve(newVertexCount);
            normals.reserve(newVertexCount);
            for (uint vid = 0; vid < meshVertexCount; vid++)
            {
                auto& uv = assimpMesh->mTextureCoords[0][vid];
                auto& pos = assimpMesh->mVertices[vid];
                auto& normal = assimpMesh->mNormals[vid];

                uvs.push_back(vec2(uv.x, uv.y));
                positions.push_back(vec3(pos.x, pos.y, pos.z));
                normals.push_back(vec3(normal.x, normal.y, normal.z));
            }

            boneIds.resize(newVertexCount);
            boneWeights.resize(newVertexCount);
            boneCount.resize(newVertexCount);
            for (uint vid = 0; vid < meshVertexCount; vid++)
            {
                boneIds[meshBaseVertex + vid] = ivec4(0);
                boneWeights[meshBaseVertex + vid] = vec4(0);
                boneCount[meshBaseVertex + vid] = 0;
            }

            m_boneOffsets.resize(newBoneCount);
            for (uint bid = 0; bid < assimpMesh->mNumBones; bid++)
            {
                auto& bone = assimpMesh->mBones[bid];
                
                auto gbid = bones.size();

                auto found = bones.find(bone->mName.C_Str());
                if (found != bones.end())
                {
                    gbid = found->second;
                }
                else
                {
                    bones[bone->mName.C_Str()] = gbid;
                    auto boneMat = bone->mOffsetMatrix;
                    boneMat.Transpose();
                    m_boneOffsets[gbid] = *reinterpret_cast<mat4*>(&boneMat);
                }
                
                
                for (uint wid = 0; wid < bone->mNumWeights; wid++)
                {
                    auto& weight = bone->mWeights[wid];
                    auto& vid = weight.mVertexId;
                    
                    auto& count = boneCount[meshBaseVertex + vid]; 

                    if (count >= 4) continue;
                    
                    auto& v_bid = boneIds[meshBaseVertex + vid];
                    auto& v_bweight = boneWeights[meshBaseVertex + vid];

                    v_bid[count] = gbid;
                    v_bweight[count] = weight.mWeight;

                    count++;
                }
            }

            mesh.reset(new Mesh(this,
                                assimpMesh->mName.C_Str(),
                                meshBaseIdx,
                                meshIndexCount,
                                m_materials[assimpMesh->mMaterialIndex].get()));
        }

        auto vertexCount = positions.size();
        auto indexCount = indices.size();
        
        glGenBuffers(1, &m_positionsBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_positionsBuffer);
        {
            glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(vec3), &positions[0], GL_STATIC_DRAW);
        }
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        glGenBuffers(1, &m_normalsBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_normalsBuffer);
        {
            glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(vec3), &normals[0], GL_STATIC_DRAW);
        }
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        glGenBuffers(1, &m_uvBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_uvBuffer);
        {
            glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(vec2), &uvs[0], GL_STATIC_DRAW);
        }
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        glGenBuffers(1, &m_boneIdBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_boneIdBuffer);
        {
            glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(ivec4), &boneIds[0], GL_STATIC_DRAW);
        }
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        glGenBuffers(1, &m_boneWeightBuffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_boneWeightBuffer);
        {
            glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(vec4), &boneWeights[0], GL_STATIC_DRAW);
        }
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        glGenBuffers(1, &m_indicesBuffer);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indicesBuffer);
        {
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * sizeof(uint), &indices[0], 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_ARRAY_BUFFER, m_boneIdBuffer);
            GLint boneIdIndex = Shader::boneId;
            glEnableVertexAttribArray(boneIdIndex);
            glVertexAttribIPointer(boneIdIndex, 4, GL_INT, 0, 0);

            glBindBuffer(GL_ARRAY_BUFFER, m_boneWeightBuffer);
            GLint boneWeightIndex = Shader::boneWeight;
            glEnableVertexAttribArray(boneWeightIndex);
            glVertexAttribPointer(boneWeightIndex, 4, 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);
    }
    
    map<string, Node*> nodesByName;
    list<pair<int,Node*>> nodes;

    // load scene
    {
        struct create_node
        {
            aiNode* assimpNode;
            function<void(Node*)> storeResult;

            create_node(aiNode* _assimpNode, function<void(Node*)> _storeResult)
                : assimpNode(_assimpNode)
                , storeResult(_storeResult)
            { }
        };

        queue<create_node> todos;

        todos.push(create_node(scene->mRootNode, [this]
                                                 (Node* result)
                                                 {
                                                     m_root.reset(result);
                                                 }));

        {
            auto temp = scene->mRootNode->mTransformation;
            temp.Transpose();
            m_inverseRootTransform = glm::inverse(*reinterpret_cast<mat4*>(&temp));
        }

        while (!todos.empty())
        {
            auto& todo = todos.front();
            auto& assimpNode = todo.assimpNode;

            
            aiMatrix4x4 assimpLocal = assimpNode->mTransformation;
            assimpLocal.Transpose();
            mat4* local = reinterpret_cast<mat4*>(&assimpLocal);
            
            Node* node = new Node(this,*local);
            todo.storeResult(node);
            nodesByName[assimpNode->mName.C_Str()] = node;

            auto foundBone = bones.find(assimpNode->mName.C_Str());
            if (foundBone != bones.end())
            {
                node->m_isBone = true;
                nodes.push_back(pair<int,Node*>(foundBone->second,node));
            }
            else if (assimpNode->mNumMeshes != 0)
            {
                nodes.push_back(pair<int,Node*>(-1,node));
            }

            node->m_meshes.resize(assimpNode->mNumMeshes);
            for (size_t i = 0; i < assimpNode->mNumMeshes; i++)
            {
                node->m_meshes[i] = m_meshes[assimpNode->mMeshes[i]].get();
            }

            node->m_children.reserve(assimpNode->mNumChildren);
            for (size_t i = 0; i < assimpNode->mNumChildren; i++)
            {
                todos.push(create_node(assimpNode->mChildren[i], [node]
                                                                 (Node* result)
                                                                 {
                                                                     node->m_children.push_back(unique_ptr<Node>(result));
                                                                 }));
            }

            todos.pop();
        }
    }

    // sort nodes
    {
        m_boneCount = bones.size();

        for (auto& node : nodes)
            if (node.first == -1)
                node.first = m_boneCount;

        // sort. first: all bones by their indices. then all others
        nodes.sort([]
                (pair<int,Node*> const & left, pair<int,Node*> const & right)
                {
                    return left.first < right.first;
                });

        int i = 0;
        for (auto& node : nodes)
        {
            node.second->m_idx = i;
            
            for (auto& mesh : node.second->m_meshes)
                mesh->m_nodeIndices.push_back(i);

            i++;
        }

        m_drawNodeCount = nodes.size();
    }

    // load animations
    {
        m_animationsDuration.clear();
        m_animationsDuration.resize(scene->mNumAnimations);
        for (size_t aid = 0; aid < scene->mNumAnimations; aid++)
        {
            auto& anim = scene->mAnimations[aid];

            auto ticks = 1.0 / (anim->mTicksPerSecond == 0 ? 25.0 : anim->mTicksPerSecond);
            
            m_animationsByName[anim->mName.C_Str()] = aid;
            m_animationsDuration[aid] = (float)(anim->mDuration * ticks);

            for (size_t cid = 0; cid < anim->mNumChannels; cid++)
            {
                auto& chan = anim->mChannels[cid];
                auto& node = nodesByName[chan->mNodeName.C_Str()]->m_animations[aid];

                node.m_positions.resize(chan->mNumPositionKeys);
                for (size_t kid = 0; kid < chan->mNumPositionKeys; kid++)
                {
                    auto& assimpKey = chan->mPositionKeys[kid];
                    auto& key = node.m_positions[kid];

                    key.time = (float)(assimpKey.mTime * ticks);
                    key.value = vec3(assimpKey.mValue.x, assimpKey.mValue.y, assimpKey.mValue.z);
                }
                sort(node.m_positions.begin(), node.m_positions.end(), []
                                                                        (NodeAnimation::Frame<vec3> const & left, NodeAnimation::Frame<vec3> const & right)
                                                                        {
                                                                            return left.time < right.time;
                                                                        });

                node.m_rotations.resize(chan->mNumRotationKeys);
                for (size_t kid = 0; kid < chan->mNumRotationKeys; kid++)
                {
                    auto& assimpKey = chan->mRotationKeys[kid];
                    auto& key = node.m_rotations[kid];

                    key.time = (float)(assimpKey.mTime * ticks);
                    key.value = quat(assimpKey.mValue.w, assimpKey.mValue.x, assimpKey.mValue.y, assimpKey.mValue.z);
                }
                sort(node.m_rotations.begin(), node.m_rotations.end(), []
                                                                        (NodeAnimation::Frame<quat> const & left, NodeAnimation::Frame<quat> const & right)
                                                                        {
                                                                            return left.time < right.time;
                                                                        });

                node.m_scalings.resize(chan->mNumScalingKeys);
                for (size_t kid = 0; kid < chan->mNumScalingKeys; kid++)
                {
                    auto& assimpKey = chan->mScalingKeys[kid];
                    auto& key = node.m_scalings[kid];

                    key.time = (float)(assimpKey.mTime * ticks);
                    key.value = vec3(assimpKey.mValue.x, assimpKey.mValue.y, assimpKey.mValue.z);
                }
                sort(node.m_scalings.begin(), node.m_scalings.end(), []
                                                                        (NodeAnimation::Frame<vec3> const & left, NodeAnimation::Frame<vec3> const & right)
                                                                        {
                                                                            return left.time < right.time;
                                                                        });
            }
        }
    }


    // setup instance-buffers
    {
        glGenBuffers(1, &m_stateBuffer);
        glBindBuffer(GL_TEXTURE_BUFFER, m_stateBuffer);
        {
            glBufferData( GL_TEXTURE_BUFFER, m_instancesInBuffer*m_boneCount*sizeof(mat4), nullptr, GL_STREAM_DRAW );
        }
        glBindBuffer(GL_TEXTURE_BUFFER, 0);

        glGenTextures(1, &m_stateTBO);
        glBindTexture(GL_TEXTURE_BUFFER, m_stateTBO);
        {
            glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_stateBuffer);
        }
        glBindTexture(GL_TEXTURE_BUFFER, 0);


        glGenBuffers(1, &m_idBuffer);
        glBindBuffer(GL_TEXTURE_BUFFER, m_idBuffer);
        {
            glBufferData( GL_TEXTURE_BUFFER, m_instancesInBuffer*sizeof(id_t), nullptr, GL_DYNAMIC_DRAW );
        }
        glBindBuffer(GL_TEXTURE_BUFFER, 0);

        glGenTextures(1, &m_idTBO);
        glBindTexture(GL_TEXTURE_BUFFER, m_idTBO);
        {
            glTexBuffer(GL_TEXTURE_BUFFER, GL_ID_FORMAT, m_idBuffer);
        }
        glBindTexture(GL_TEXTURE_BUFFER, 0);
    }
}
Scene::~Scene()
{
    glDeleteBuffers(1, &m_positionsBuffer);
    glDeleteBuffers(1, &m_normalsBuffer);
    glDeleteBuffers(1, &m_uvBuffer);
    glDeleteBuffers(1, &m_boneIdBuffer);
    glDeleteBuffers(1, &m_boneWeightBuffer);
    glDeleteBuffers(1, &m_indicesBuffer);
    glDeleteVertexArrays(1, &m_vao);

    glDeleteTextures(1, &m_stateTBO);
    glDeleteBuffers(1, &m_stateBuffer);
}
void Scene::updateAllInstances(float const time)
{
    if (m_instances.empty())
        return;
    
    size_t const minInstancesForParallel = 20;

    if (m_app->getConfig().skinnningMultiThreaded() && (m_instances.size() >= minInstancesForParallel))
    {
        for (auto& instance : m_instances)
            m_app->getTasks().schedule([this, &instance, time]() { updateInstance(instance, time); }, &m_parallelEvent);
        
        m_parallelEvent.wait(m_instances.size());
    }
    else
    {
        for (auto& instance : m_instances)
            updateInstance(instance, time);
    }
}   
void Scene::updateInstance(SceneInstance* instance, float const time)
{
    float instanceTime = time;
    if (instance->m_animation.animation >= 0 && instance->m_animation.animation < (int)m_animationsDuration.size())
        instanceTime = fmod(instance->m_animation.time + instanceTime, m_animationsDuration[instance->m_animation.animation]);
                
    m_root->updateInstance(*instance, instanceTime, instance->getTransform().getMatrix());
}
void Scene::drawAllInstances(DrawArgs& args, Shader* shader)
{   
    shader->uniform("statesPerInstance", (int)m_boneCount);

    // Push instance-data to GPU
    {
        bool needBufferResize = m_instancesInBuffer != m_instances.size();
        m_instancesInBuffer = m_instances.size();

        // push states
        glBindBuffer(GL_TEXTURE_BUFFER, m_stateBuffer);
        {
            if (needBufferResize)
                glBufferData(GL_TEXTURE_BUFFER, m_boneCount*m_instancesInBuffer*sizeof(mat4), NULL, GL_STREAM_DRAW);

            mat4 * states = (mat4 *)glMapBuffer(GL_TEXTURE_BUFFER, GL_WRITE_ONLY);
            {
                size_t instanceIdx = 0;
                for (auto& instance : m_instances)
                {
                    for (size_t i = 0; i < m_boneCount; i++)
                        states[instanceIdx*m_boneCount + i] = instance->m_state[i];

                    instanceIdx++;
                }
            }
            glUnmapBuffer(GL_TEXTURE_BUFFER);
        }
        
        // push ids
        if (m_needToUpdateIdBuffer || needBufferResize)
        {
            glBindBuffer(GL_TEXTURE_BUFFER, m_idBuffer);
            {
                if (needBufferResize)
                    glBufferData(GL_TEXTURE_BUFFER, m_instancesInBuffer*sizeof(id_t), NULL, GL_STREAM_DRAW);

                id_t * ids = (id_t *)glMapBuffer(GL_TEXTURE_BUFFER, GL_WRITE_ONLY);

                size_t instanceIdx = 0;
                for (auto& instance : m_instances)
                {
                    ids[instanceIdx] = instance->getPickId();
                    instanceIdx++;
                }

                glUnmapBuffer(GL_TEXTURE_BUFFER);
            }
            glBindBuffer(GL_TEXTURE_BUFFER, 0);

            m_needToUpdateIdBuffer = false;
        }
    }
    
    // draw all instances
    {
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_BUFFER, m_stateTBO);       
        glActiveTexture(GL_TEXTURE2);
        glBindTexture(GL_TEXTURE_BUFFER, m_idTBO);
        {
            glBindVertexArray(m_vao);
            {
                for (auto& mesh : m_meshes)
                    mesh->drawInstances(shader, m_instances);
            }
            glBindVertexArray(0);
        }
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_BUFFER, 0);
        glActiveTexture(GL_TEXTURE2);
        glBindTexture(GL_TEXTURE_BUFFER, 0);
        glActiveTexture(GL_TEXTURE0);
    }
}   
void Scene::updateNdraw(DrawArgs& args, Shader* shader)
{   
    updateAllInstances((float)args.time);
    
    drawAllInstances(args, shader);
}   
SceneInstance* Scene::createInstance(bool pickable)
{
    SceneInstance* instance = new SceneInstance(m_app, this, pickable);
    m_instances.insert(instance);

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

    m_needToUpdateIdBuffer = true;

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

    m_needToUpdateIdBuffer = true;
}






Scene::Material::Material(vec4 const & ambient, vec4 const & diffuse, vec4 const & specular, float const shininess, Texture* texture)
    : m_texture(texture)
    , m_ubuffer(0)
{
    data buffer_data;
    buffer_data.ambient = ambient;
    buffer_data.diffuse = diffuse;
    buffer_data.specular = specular;
    buffer_data.shininess = shininess;

    glGenBuffers(1,&m_ubuffer);
    glBindBuffer(GL_UNIFORM_BUFFER, m_ubuffer);
    {
        glBufferData(GL_UNIFORM_BUFFER, sizeof(data), &buffer_data, GL_STATIC_DRAW);
    }
    glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
Scene::Material::~Material()
{
    glDeleteBuffers(1, &m_ubuffer);
}
void Scene::Material::bindTo(Shader * shader, string const uniform)
{
    if (m_texture)
        m_texture->bind(0);
    else
        cerr << "no texture found" << endl;

    glBindBufferRange(GL_UNIFORM_BUFFER, shader->uniformBlock(uniform), m_ubuffer, 0, sizeof(data));  
}








Scene::Mesh::Mesh(Scene* scene, string const & name, GLuint const baseIdx, GLuint const idxCount, Material* material)
    : m_scene(scene)
    , m_name(name)
    , m_material(material)
    , m_indexCount(idxCount)
    , m_baseIndex(baseIdx)
{ }
void Scene::Mesh::drawInstances(Shader* shader, set<SceneInstance*> const & instances)
{
    m_material->bindTo(shader, "material");
    
    glDrawElementsInstanced(GL_TRIANGLES, 
                            m_indexCount, 
                            GL_UNSIGNED_INT, 
                            reinterpret_cast<GLuint const*>(0) + m_baseIndex,
                            instances.size());
}








bool Scene::NodeAnimation::transformationByTime(float const time, OUT mat4& result)
{
    result = 
           glm::translate(mat4(1), interpolate(m_positions, time))
         * glm::mat4_cast(interpolate(m_rotations, time))
         * glm::scale(mat4(1), interpolate(m_scalings, time));

    return true;
}








Scene::Node::Node(Scene* scene, mat4 const & local)
    : m_local(local)
    , m_idx(-1)
    , m_scene(scene)
    , m_isBone(false)
{ }
void Scene::Node::updateInstance(SceneInstance& instance, float time, mat4 const & parentTransformation)
{
    auto model =  parentTransformation * transformationByTime(instance.m_animation.animation, time);

    if (m_isBone)
    {
        //instance.m_state[m_idx] = m_scene->m_inverseRootTransform * m_scene->m_boneOffsets[m_idx] * model;
        instance.m_state[m_idx] = model * m_scene->m_boneOffsets[m_idx]; // *m_scene->m_inverseRootTransform* / ;
    }
    else if (m_idx != -1)
    {
        //instance.m_state[m_idx] = model;
    }

    for (auto& child : m_children)
        child->updateInstance(instance, time, model);
}
mat4 Scene::Node::transformationByTime(uint const animation, float const time)
{
    auto& found = m_animations.find(animation);

    if (found == m_animations.end())
        return m_local;

    mat4 result;
    if (!found->second.transformationByTime(time, OUT result))
        return m_local;

    return result;
}









Scenes::Scenes(Application* app)
    : m_app(app)
    , m_shader(app->getShaders().get("scene.mesh"))
{ 
    m_shader->use();
    m_shader->uniform("texDiffuse", 0);
    m_shader->uniform("states", 1);
    m_shader->uniform("ids", 2);

    
    if (m_app->getConfig().skinnningMultiThreaded())
        cout << "Skinning-Mode: multi-threaded" << endl;
    else
        cout << "Skinning-Mode: single-threaded" << endl;
}
Scene* Scenes::get(string const & name)
{
    auto found = m_scenes.find(name);

    if (found == m_scenes.end())
    {
        auto& instance = m_scenes[name];
        instance.reset(new Scene(m_app, name));
        return instance.get();
    }

    return found->second.get();
}
void Scenes::drawAll(DrawArgs& args)
{
    m_shader->use();

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