Add a brewfile

[opengl.git] / model.cpp

diff --git a/model.cpp b/model.cpp
index 5302df06238038d32a686e8bffb2c62881f19a91..9e4cfc6ca026fb0e7e8ee6345acbdaf3bf90f98b 100644 (file)
--- a/model.cpp
+++ b/model.cpp
@@ -2,11 +2,10 @@
 #include <iostream>
 #include <assimp/quaternion.h>
 #include <glm/gtc/type_ptr.hpp>
+#include <glm/gtx/closest_point.hpp>
 #include "util.hpp"
 
-
-Model::Mesh::Mesh(const aiMesh *aiMesh, GLuint progId) {
-
+Model::Mesh::Mesh(const aiMesh *aiMesh, GLuint progId) : progId(progId), ai(*aiMesh) {
        std::vector<glm::vec3> vertices, normals, tangents, bitangents;
        std::vector<glm::vec2> texCoords;
 
@@ -48,13 +47,12 @@ Model::Mesh::Mesh(const aiMesh *aiMesh, GLuint progId) {
        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);
        
-       GLuint vbos[6];
        glGenBuffers(6, vbos);
-       GLuint vertexVbo = vbos[0], normalVbo = vbos[1], texCoordVbo = vbos[2], indicesVbo = vbos[3];
+       GLuint posVbo = vbos[0], normalVbo = vbos[1], texCoordVbo = vbos[2], indicesVbo = vbos[3];
        GLuint boneVbo = vbos[4];
        
        GLuint posLoc = glGetAttribLocation(progId, "pos");
-       glBindBuffer(GL_ARRAY_BUFFER, vertexVbo);
+       glBindBuffer(GL_ARRAY_BUFFER, posVbo);
        glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
        glEnableVertexAttribArray(posLoc);
        glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
@@ -115,13 +113,22 @@ Model::Mesh::Mesh(const aiMesh *aiMesh, GLuint progId) {
        glVertexAttribPointer(boneWeightLoc, 4, GL_FLOAT, GL_FALSE, sizeof(VertBones), (const GLvoid *)sizeof(VertBones::ids));
 }
 
-Model::Node::Node(const aiNode &node, GLuint progId, AnimMap *am): ai(node), progId(progId), animMap(am) {
+void Model::Mesh::updatePosBuffer() const {
+       GLuint posLoc = glGetAttribLocation(progId, "pos");
+       GLuint posVbo = vbos[0];
+       glBindBuffer(GL_ARRAY_BUFFER, posVbo);
+       glBufferData(GL_ARRAY_BUFFER, ai.mNumVertices * sizeof(aiVector3D), ai.mVertices, GL_STATIC_DRAW);
+       glEnableVertexAttribArray(posLoc);
+       glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
+}
+
+Model::Node::Node(aiNode &node, GLuint progId, AnimMap *am, std::set<std::string> allBones, Node *p): ai(node), parent(p), progId(progId), animMap(am), isBone(allBones.count(std::string(node.mName.C_Str())) > 0) {
        for (int i = 0; i < node.mNumMeshes; i++) {
                meshIndices.push_back(node.mMeshes[i]);
        }
        for (int i = 0; i < node.mNumChildren; i++) {
-               const aiNode *child = node.mChildren[i];
-               children.push_back(new Node(*child, progId, am));
+               aiNode *child = node.mChildren[i];
+               children.push_back(new Node(*child, progId, am, allBones, this));
        }
 }
 
@@ -224,6 +231,14 @@ glm::mat4 Model::Node::totalTrans(const glm::mat4 parentTrans, const float tick)
        return m;
 }
 
+const Model::Node &Model::Node::getRoot() const {
+       const Model::Node *rootPtr = this;
+       while (rootPtr->parent != nullptr)
+               rootPtr = rootPtr->parent;
+       const Model::Node &root = *rootPtr;
+       return root;
+}
+
 void Model::Node::draw(        const std::vector<Mesh> &meshes,
                                                const std::vector<Material> &materials,
                                                const Skybox skybox,
@@ -235,6 +250,9 @@ void Model::Node::draw(     const std::vector<Mesh> &meshes,
        glm::mat4 m = totalTrans(parentTrans, tick);
 
 #ifdef DEBUG_NODES
+       if (isBone)
+               drawDebugNode(m, {0, 0.5, 1, 1});
+       else
                drawDebugNode(m);
 #endif
 
@@ -291,13 +309,6 @@ void Model::Node::draw(    const std::vector<Mesh> &meshes,
        for (Node *child: children) child->draw(meshes, materials, skybox, tick, boneTransforms, m);
 }
 
-void printMatrix4x4(aiMatrix4x4 m) {
-       fprintf(stderr, "%f, %f, %f, %f\n", m.a1, m.a2, m.a3, m.a4);
-       fprintf(stderr, "%f, %f, %f, %f\n", m.b1, m.b2, m.b3, m.b4);
-       fprintf(stderr, "%f, %f, %f, %f\n", m.c1, m.c2, m.c3, m.c4);
-       fprintf(stderr, "%f, %f, %f, %f\n", m.d1, m.d2, m.d3, m.d4);
-}
-
 void printHierarchy(aiNode *n, int indent = 0) {
        for (int i = 0; i < indent; i++)
                fprintf(stderr, "\t");
@@ -310,9 +321,12 @@ void printHierarchy(aiNode *n, int indent = 0) {
 Model::Model(const aiScene *scene, Program p): program(p) {
        glUseProgram(p.progId);
 
+       std::set<std::string> allBones;
        for (int i = 0; i < scene->mNumMeshes; i++) {
                const aiMesh *mesh = scene->mMeshes[i];
                meshes.push_back(Mesh(mesh, p.progId));
+               for (int j = 0; j < mesh->mNumBones; j++)
+                       allBones.insert(std::string(mesh->mBones[j]->mName.C_Str()));
        }
 
        for (unsigned int i = 0; i < scene->mNumMaterials; i++) {
@@ -342,7 +356,7 @@ Model::Model(const aiScene *scene, Program p): program(p) {
                }
        }
 
-       root = new Node(*(scene->mRootNode), p.progId, &animMap);
+       root = new Node(*(scene->mRootNode), p.progId, &animMap, allBones, nullptr);
 }
 
 
@@ -393,3 +407,46 @@ Model::Node* Model::Node::findNode(const aiNode &aiNode) {
        }
        return nullptr;
 }
+
+bool Model::Node::operator==(const Model::Node &rhs) const {
+       return &ai == &rhs.ai;
+}
+
+// Returns closest vertex in world space and distance
+// a and b define the line in 3d space
+Model::VertexLookup Model::closestVertex(Model::Node &n, glm::vec3 a, glm::vec3 b, glm::mat4 parentTrans) const {
+       Model::VertexLookup closest;
+       closest.distance = FLT_MAX;
+
+       for (int i = 0; i < n.ai.mNumMeshes; i++) {
+               int meshIdx = n.ai.mMeshes[i];
+               const aiMesh &mesh = meshes[meshIdx].ai;
+
+               for (int j = 0; j < mesh.mNumVertices; j++) {
+                       if (mesh.HasNormals()) {
+                               auto n = aiVector3DToVec3(mesh.mNormals[j]);
+                               if (glm::dot(n, glm::normalize(b - a)) > 0)
+                                       continue;
+                       }
+                       glm::vec4 vPos = glm::vec4(aiVector3DToVec3(mesh.mVertices[j]), 1);
+                       // Move from model space -> world space
+                       vPos = parentTrans * aiMatrixToMat4(n.ai.mTransformation) * vPos;
+                       float dist = glm::distance(glm::vec3(vPos),
+                                                       glm::closestPointOnLine(glm::vec3(vPos), a, b));
+                       if (dist < closest.distance) {
+                               closest.pos = glm::vec3(vPos);
+                               closest.distance = dist;
+                               closest.meshIdx = i;
+                               closest.vertIdx = j;
+                       }
+               }
+       }
+       
+       for (auto child: n.getChildren()) {
+               auto childRes = closestVertex(*child, a, b, parentTrans * aiMatrixToMat4(n.ai.mTransformation));
+               if (childRes.distance < closest.distance) 
+                       closest = childRes;
+       }
+
+       return closest;
+}