From 0f0ff32f165f120e6dce0f657f02d7e29c496e3c Mon Sep 17 00:00:00 2001 From: Anselme Date: Tue, 5 Sep 2017 11:39:06 +0200 Subject: [PATCH] mesh is now partially serializable --- src/chunk.cpp | 8 +- src/forwardmodule.cpp | 4 +- src/mesh.cpp | 411 ++++++++++++----------------------------- src/mesh.h | 95 +++++----- src/parametricmesh.cpp | 16 +- 5 files changed, 181 insertions(+), 353 deletions(-) diff --git a/src/chunk.cpp b/src/chunk.cpp index 6e0c00c..2810459 100644 --- a/src/chunk.cpp +++ b/src/chunk.cpp @@ -82,7 +82,7 @@ void Chunk::generate(glm::vec3 pos) } delete[](top); for(int id : m_indiceList) - mesh->indices.push_back(m_vertexHashTable[id]); + mesh->m_indices.push_back(m_vertexHashTable[id]); m_indiceList.clear(); delete[] m_vertexHashTable; } @@ -197,11 +197,11 @@ glm::vec3 Chunk::createInterpolatedVertex(glm::vec3 p1, glm::vec3 p2, float valp p = p1 * (1-mu) + p2 * mu; // store vertice id in the hash table - m_vertexHashTable[hash] = mesh->positions3D.size(); + m_vertexHashTable[hash] = mesh->m_positions3D.size(); // vertex creation from position p (estimated position of the surface) - mesh->positions3D.push_back(p); - mesh->normals.push_back(m_generator->grad(m_position + p)); + mesh->m_positions3D.push_back(p); + mesh->m_normals.push_back(m_generator->grad(m_position + p)); } // constants : diff --git a/src/forwardmodule.cpp b/src/forwardmodule.cpp index b86041b..2aa32de 100644 --- a/src/forwardmodule.cpp +++ b/src/forwardmodule.cpp @@ -39,10 +39,10 @@ void ForwardModule::renderGL(Camera* myCamera, Scene* scene) for(GeometryNode *node : p.geometry) { shader->bindUnsignedInteger(shader->getLocation("object_identifier"), id); - if(node->mesh->instances_offsets.empty()) + if(node->mesh->m_instances_offsets.empty()) ++id; else - id += node->mesh->instances_offsets.size(); + id += node->mesh->m_instances_offsets.size(); // compute matrix attributes glm::mat4 modelViewMatrix = myCamera->getViewMatrix() * node->modelMatrix; glm::mat4 mvp = myCamera->getProjectionMatrix() * modelViewMatrix; diff --git a/src/mesh.cpp b/src/mesh.cpp index 9347929..64381f6 100644 --- a/src/mesh.cpp +++ b/src/mesh.cpp @@ -6,6 +6,8 @@ #include "material.h" #include "buffer.h" +INIT_SERIALIZABLE(Mesh) + const char* const Mesh::flagStr[Mesh::NB_FLAGS] = { "INDEXED", @@ -34,8 +36,8 @@ const char* const Mesh::flagStr[Mesh::NB_FLAGS] = "BUMP_MAP" }; -Mesh::Mesh(const std::string &name) : - m_name(name), +Mesh::Mesh() : + m_name("mesh"), material(NULL), isDoubleSided(false), isBillboard(false), @@ -49,6 +51,12 @@ Mesh::Mesh(const std::string &name) : clearBuffers(); } +Mesh::Mesh(const std::string &name) : + Mesh() +{ + m_name = name; +} + Mesh::~Mesh() { destroyGL(); @@ -73,18 +81,18 @@ unsigned int Mesh::updateFlags() { m_flags = 0; - if(!indices.empty()) + if(!m_indices.empty()) m_flags |= 1 << MESH_INDEXED; - if(!texCoords.empty()) + if(!m_texCoords.empty()) m_flags |= 1 << MESH_TEXTURABLE; - if(!instances_offsets.empty()) + if(!m_instances_offsets.empty()) m_flags |= 1 << MESH_INSTANCED; - if(!positions3D.empty()) + if(!m_positions3D.empty()) { m_flags |= 1 << MESH_3D; - if(!tangents.empty()) + if(!m_tangents.empty()) m_flags |= 1 << MESH_TANGENT_SPACE; if(isDoubleSided) m_flags |= 1 << MESH_DOUBLE_SIDED; @@ -111,31 +119,31 @@ void Mesh::initGL() glBindVertexArray(vao); // init positions VBO - if(!positions3D.empty()) + if(!m_positions3D.empty()) { - auto posBuffer = new TBuffer(positions3D, Buffer::VBO); + auto posBuffer = new TBuffer(m_positions3D, Buffer::VBO); posBuffer->setVertexAttrib(0, 3); addBuffer(posBuffer, POSITION3D_BUFFER); // init normals vbo - if(!normals.empty()) + if(!m_normals.empty()) { - auto normalsBuffer = new TBuffer(normals, Buffer::VBO); + auto normalsBuffer = new TBuffer(m_normals, Buffer::VBO); normalsBuffer->setVertexAttrib(1, 3); addBuffer(normalsBuffer, NORMAL_BUFFER); } // init tangents vbo - if(!tangents.empty()) + if(!m_tangents.empty()) { - auto tangentsBuffer = new TBuffer(tangents, Buffer::VBO); + auto tangentsBuffer = new TBuffer(m_tangents, Buffer::VBO); tangentsBuffer->setVertexAttrib(3, 3, 0); tangentsBuffer->setVertexAttrib(4, 3, sizeof(glm::vec3)); addBuffer(tangentsBuffer, TANGENT_BUFFER); } } - else if(!positions2D.empty()) + else if(!m_positions2D.empty()) { - auto posBuffer = new TBuffer(positions2D, Buffer::VBO); + auto posBuffer = new TBuffer(m_positions2D, Buffer::VBO); posBuffer->setVertexAttrib(0, 2); addBuffer(posBuffer, POSITION2D_BUFFER); } @@ -145,25 +153,25 @@ void Mesh::initGL() return; } // init texCoords vbo - if(!texCoords.empty()) + if(!m_texCoords.empty()) { - auto texCoordBuffer = new TBuffer(texCoords, Buffer::VBO); + auto texCoordBuffer = new TBuffer(m_texCoords, Buffer::VBO); texCoordBuffer->setVertexAttrib(2, 2); addBuffer(texCoordBuffer, TEXCOORD_BUFFER); } // init instances vbo - if(!instances_offsets.empty()) + if(!m_instances_offsets.empty()) { - auto instancesBuffer = new TBuffer(instances_offsets, Buffer::VBO); + auto instancesBuffer = new TBuffer(m_instances_offsets, Buffer::VBO); instancesBuffer->setVertexAttrib(5, 3, 0, 1); addBuffer(instancesBuffer, INSTANCE_BUFFER); } // init EBO - if(!indices.empty()) + if(!m_indices.empty()) { - auto indicesBuffer = new TBuffer(indices, Buffer::EBO); + auto indicesBuffer = new TBuffer(m_indices, Buffer::EBO); addBuffer(indicesBuffer, INDICES_BUFFER); } @@ -183,12 +191,12 @@ void Mesh::draw(Shader* shader) material->bindAttributes(shader); glBindVertexArray(vao); - if(indices.empty()) + if(m_indices.empty()) { - int size = positions3D.empty() ? positions2D.size() : positions3D.size(); - if(!instances_offsets.empty()) + int size = m_positions3D.empty() ? m_positions2D.size() : m_positions3D.size(); + if(!m_instances_offsets.empty()) { - glDrawArraysInstanced(primitive_type, 0, size, instances_offsets.size()); + glDrawArraysInstanced(primitive_type, 0, size, m_instances_offsets.size()); } else { @@ -199,13 +207,13 @@ void Mesh::draw(Shader* shader) { Buffer *b = buffers[buffersId[INDICES_BUFFER]]; b->bind(); - if(!instances_offsets.empty()) + if(!m_instances_offsets.empty()) { - glDrawElementsInstanced(primitive_type, indices.size(), GL_UNSIGNED_INT, NULL, instances_offsets.size()); + glDrawElementsInstanced(primitive_type, m_indices.size(), GL_UNSIGNED_INT, NULL, m_instances_offsets.size()); } else { - glDrawElements(primitive_type, indices.size(), GL_UNSIGNED_INT, NULL); + glDrawElements(primitive_type, m_indices.size(), GL_UNSIGNED_INT, NULL); } b->unbind(); } @@ -227,13 +235,13 @@ void Mesh::destroyGL() void Mesh::clearData() { - positions3D.clear(); - normals.clear(); - tangents.clear(); - positions2D.clear(); - texCoords.clear(); - instances_offsets.clear(); - indices.clear(); + m_positions3D.clear(); + m_normals.clear(); + m_tangents.clear(); + m_positions2D.clear(); + m_texCoords.clear(); + m_instances_offsets.clear(); + m_indices.clear(); } unsigned int Mesh::getFlags() @@ -309,27 +317,27 @@ struct VertexComparator bool operator() (const int& vertId1, const int& vertId2) const { - if(mesh->positions3D[vertId1].x != mesh->positions3D[vertId2].x) - return (mesh->positions3D[vertId1].x < mesh->positions3D[vertId2].x); - if(mesh->positions3D[vertId1].y != mesh->positions3D[vertId2].y) - return (mesh->positions3D[vertId1].y < mesh->positions3D[vertId2].y); - if(mesh->positions3D[vertId1].z != mesh->positions3D[vertId2].z) - return (mesh->positions3D[vertId1].z < mesh->positions3D[vertId2].z); - if(!mesh->texCoords.empty()) + if(mesh->m_positions3D[vertId1].x != mesh->m_positions3D[vertId2].x) + return (mesh->m_positions3D[vertId1].x < mesh->m_positions3D[vertId2].x); + if(mesh->m_positions3D[vertId1].y != mesh->m_positions3D[vertId2].y) + return (mesh->m_positions3D[vertId1].y < mesh->m_positions3D[vertId2].y); + if(mesh->m_positions3D[vertId1].z != mesh->m_positions3D[vertId2].z) + return (mesh->m_positions3D[vertId1].z < mesh->m_positions3D[vertId2].z); + if(!mesh->m_texCoords.empty()) { - if(mesh->texCoords[vertId1].x - floor(mesh->texCoords[vertId1].x) != mesh->texCoords[vertId2].x - floor(mesh->texCoords[vertId2].x)) - return (mesh->texCoords[vertId1].x < mesh->texCoords[vertId2].x); - if(mesh->texCoords[vertId1].y - floor(mesh->texCoords[vertId1].y) != mesh->texCoords[vertId2].y - floor(mesh->texCoords[vertId2].y)) - return (mesh->texCoords[vertId1].y < mesh->texCoords[vertId2].y); + if(mesh->m_texCoords[vertId1].x - floor(mesh->m_texCoords[vertId1].x) != mesh->m_texCoords[vertId2].x - floor(mesh->m_texCoords[vertId2].x)) + return (mesh->m_texCoords[vertId1].x < mesh->m_texCoords[vertId2].x); + if(mesh->m_texCoords[vertId1].y - floor(mesh->m_texCoords[vertId1].y) != mesh->m_texCoords[vertId2].y - floor(mesh->m_texCoords[vertId2].y)) + return (mesh->m_texCoords[vertId1].y < mesh->m_texCoords[vertId2].y); } - if(!mesh->normals.empty()) + if(!mesh->m_normals.empty()) { - if(mesh->normals[vertId1].x != mesh->normals[vertId2].x) - return (mesh->normals[vertId1].x < mesh->normals[vertId2].x); - if(mesh->normals[vertId1].y != mesh->normals[vertId2].y) - return (mesh->normals[vertId1].y < mesh->normals[vertId2].y); - if(mesh->normals[vertId1].z != mesh->normals[vertId2].z) - return (mesh->normals[vertId1].z < mesh->normals[vertId2].z); + if(mesh->m_normals[vertId1].x != mesh->m_normals[vertId2].x) + return (mesh->m_normals[vertId1].x < mesh->m_normals[vertId2].x); + if(mesh->m_normals[vertId1].y != mesh->m_normals[vertId2].y) + return (mesh->m_normals[vertId1].y < mesh->m_normals[vertId2].y); + if(mesh->m_normals[vertId1].z != mesh->m_normals[vertId2].z) + return (mesh->m_normals[vertId1].z < mesh->m_normals[vertId2].z); } return false; } @@ -339,29 +347,29 @@ Mesh* VertexComparator::mesh = NULL; void Mesh::mergeVertices() { - if(positions3D.empty()) + if(m_positions3D.empty()) return; - bool *deleted = new bool[positions3D.size()]; - int *offsets = new int[positions3D.size()]; + bool *deleted = new bool[m_positions3D.size()]; + int *offsets = new int[m_positions3D.size()]; std::set vertexSet; VertexComparator::setMesh(this); - for(std::size_t i=0; i::iterator, bool> ret = vertexSet.insert(indices[i]); + std::pair::iterator, bool> ret = vertexSet.insert(m_indices[i]); std::set::iterator it = ret.first; bool success = ret.second; - deleted[indices[i]] = !success && *it != int(indices[i]); - if(deleted[indices[i]]) + deleted[m_indices[i]] = !success && *it != int(m_indices[i]); + if(deleted[m_indices[i]]) { - if(!tangents.empty()) - tangents[*it].tangent += tangents[indices[i]].tangent; - indices[i] = *it; + if(!m_tangents.empty()) + m_tangents[*it].tangent += m_tangents[m_indices[i]].tangent; + m_indices[i] = *it; } } int offset = 0; int pos = 0; - for(std::size_t i=0; i(positions3D.size()); + m_tangents = std::vector(m_positions3D.size()); - for (std::size_t j=0; j < indices.size(); j += 3) + for (std::size_t j=0; j < m_indices.size(); j += 3) { - int vertexId0 = indices[j]; - int vertexId1 = indices[j+1]; - int vertexId2 = indices[j+2]; + int vertexId0 = m_indices[j]; + int vertexId1 = m_indices[j+1]; + int vertexId2 = m_indices[j+2]; - const glm::vec3 &v1 = positions3D[vertexId0]; - glm::vec3 edge1 = positions3D[vertexId1] - v1; - glm::vec3 edge2 = positions3D[vertexId2] - v1; + const glm::vec3 &v1 = m_positions3D[vertexId0]; + glm::vec3 edge1 = m_positions3D[vertexId1] - v1; + glm::vec3 edge2 = m_positions3D[vertexId2] - v1; - const glm::vec2& w1 = texCoords[vertexId0]; - glm::vec2 deltaUV1 = texCoords[vertexId1] - w1; - glm::vec2 deltaUV2 = texCoords[vertexId2] - w1; + const glm::vec2& w1 = m_texCoords[vertexId0]; + glm::vec2 deltaUV1 = m_texCoords[vertexId1] - w1; + glm::vec2 deltaUV2 = m_texCoords[vertexId2] - w1; float f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y); @@ -458,19 +466,19 @@ void Mesh::computeTangents() glm::vec3 binormalDir = deltaUV1.x * edge2 - deltaUV2.x * edge1; binormalDir = glm::normalize(binormalDir*f); - if(glm::dot(glm::cross(normals[vertexId0], binormalDir), tangentDir) < 0.f) + if(glm::dot(glm::cross(m_normals[vertexId0], binormalDir), tangentDir) < 0.f) binormalDir = -binormalDir; - tangents[vertexId0] = {tangentDir, binormalDir}; - tangents[vertexId1] = {tangentDir, binormalDir}; - tangents[vertexId2] = {tangentDir, binormalDir}; + m_tangents[vertexId0] = {tangentDir, binormalDir}; + m_tangents[vertexId1] = {tangentDir, binormalDir}; + m_tangents[vertexId2] = {tangentDir, binormalDir}; } } void Mesh::computeBoundingBox(glm::vec3 &min, glm::vec3 &max) { - min = max = positions3D[0]; - for(const glm::vec3 &pos : positions3D) + min = max = m_positions3D[0]; + for(const glm::vec3 &pos : m_positions3D) { if(pos.x < min.x) min.x = pos.x; @@ -486,176 +494,3 @@ void Mesh::computeBoundingBox(glm::vec3 &min, glm::vec3 &max) max.z = pos.z; } } - -// serialisation methods - -struct MeshHeader -{ - unsigned int flags; - int nbPositions; - int depth; - int nbInstances_offsets; - int nbIndices; - int nameLength; -}; - -template -bool writeBuffer(const std::vector &vec, std::FILE *file) -{ - size_t nbWritten = std::fwrite(vec.data(), sizeof(T), vec.size(), file); - return (nbWritten == vec.size()); -} - -template -bool readBuffer(std::vector &vec, std::FILE *file) -{ - size_t nbRead = std::fread(vec.data(), sizeof(T), vec.size(), file); - return (nbRead == vec.size()); -} - -bool Mesh::serialize(Mesh* mesh, FILE *file) -{ - // creating header - MeshHeader header; - header.flags = mesh->getFlags(); - if(header.flags & (1 << Mesh::MESH_3D)) - header.nbPositions = mesh->positions3D.size(); - else - { - header.nbPositions = mesh->positions2D.size(); - header.depth = mesh->getDepth(); - } - header.nbIndices = mesh->indices.size(); - header.nbInstances_offsets = mesh->instances_offsets.size(); - header.nameLength = mesh->getName().size(); - - if(header.nbPositions == 0) - return false; - - // writing header - size_t nbWritten; - - nbWritten = std::fwrite(&header, sizeof(MeshHeader), 1, file); - if(nbWritten != 1) - return false; - - if(header.nameLength != 0) - { - nbWritten = std::fwrite(mesh->getName().data(), header.nameLength, 1, file); - if(nbWritten != 1) - return false; - } - - // writing buffers - if(header.flags & (1 << Mesh::MESH_3D)) - { - if(!writeBuffer(mesh->positions3D, file)) - return false; - if(mesh->normals.size() == 0) - mesh->computeNormals(); - if(!writeBuffer(mesh->normals, file)) - return false; - if(header.flags & (1 << Mesh::MESH_TANGENT_SPACE)) - { - if(!writeBuffer(mesh->tangents, file)) - return false; - } - } - else - { - if(!writeBuffer(mesh->positions2D, file)) - return false; - } - - if(header.nbInstances_offsets) - { - if(!writeBuffer(mesh->instances_offsets, file)) - return false; - } - - if(header.nbIndices) - { - if(!writeBuffer(mesh->indices, file)) - return false; - } - - if(header.flags & (1 << Mesh::MESH_TEXTURABLE)) - { - if(!writeBuffer(mesh->texCoords, file)) - return false; - } - - return true; -} - -Mesh* Mesh::deserialize(FILE *file) -{ - MeshHeader header; - size_t nbRead = std::fread(&header, sizeof(MeshHeader), 1, file); - - // deserializing mesh - Mesh *mesh = NULL; - if(nbRead == 1 && header.nbPositions != 0) - mesh = new Mesh(); - else - return NULL; - - std::string name = "mesh"; - if(header.nameLength != 0) - { - name.resize(header.nameLength); - if(!fread(&(name[0]), header.nameLength, 1, file)) - { delete(mesh); return NULL; } - } - mesh->setName(name); - - if(header.flags & (1 << Mesh::MESH_3D)) - { - mesh->positions3D.reserve(header.nbPositions); - if(!readBuffer(mesh->positions3D, file)) - { delete(mesh); return NULL; } - mesh->normals.reserve(header.nbPositions); - if(!readBuffer(mesh->normals, file)) - { delete(mesh); return NULL; } - if(header.flags & (1 << Mesh::MESH_TANGENT_SPACE)) - { - mesh->tangents.reserve(header.nbPositions); - if(!readBuffer(mesh->tangents, file)) - { delete(mesh); return NULL; } - } - } - else - { - mesh->positions2D.reserve(header.nbPositions); - if(!readBuffer(mesh->positions2D, file)) - { delete(mesh); return NULL; } - mesh->setDepth(header.depth); - } - - if(header.nbInstances_offsets) - { - mesh->instances_offsets.reserve(header.nbInstances_offsets); - if(!readBuffer(mesh->instances_offsets, file)) - { delete(mesh); return NULL; } - } - - if(header.nbIndices) - { - mesh->indices.reserve(header.nbIndices); - if(!readBuffer(mesh->indices, file)) - { delete(mesh); return NULL; } - } - - if(header.flags & (1 << Mesh::MESH_TEXTURABLE)) - { - mesh->texCoords.reserve(header.nbPositions); - if(!readBuffer(mesh->texCoords, file)) - { delete(mesh); return NULL; } - } - - mesh->setIsBillboard(header.flags & (1 << Mesh::MESH_BILLBOARD)); - mesh->setIsDoubleSided(header.flags & (1 << Mesh::MESH_DOUBLE_SIDED)); - mesh->setIsShadowCaster(header.flags & (1 << Mesh::MESH_SHADOWED)); - - return mesh; -} diff --git a/src/mesh.h b/src/mesh.h index 1e9dbb6..f274257 100644 --- a/src/mesh.h +++ b/src/mesh.h @@ -7,11 +7,13 @@ #include #include +#include + class Buffer; class Material; class Shader; -struct Mesh +struct Mesh : public Serializable { public: @@ -63,33 +65,42 @@ public: /*************************************************************/ // 3D public data - std::vector positions3D; - std::vector normals; + P_VECTOR_VEC3(m_positions3D) + P_VECTOR_VEC3(m_normals) typedef struct { glm::vec3 tangent; glm::vec3 binormal; } Tangents; - - std::vector tangents; + + std::vector m_tangents; // 2D public data - std::vector positions2D; + P_VECTOR_VEC2(m_positions2D) // public data common to 2D and 3D - std::vector texCoords; - std::vector instances_offsets; - std::vector indices; + P_VECTOR_VEC2(m_texCoords) + P_VECTOR_VEC3(m_instances_offsets) + P_VECTOR_UINT(m_indices) /*************************************************************/ /* MAIN METHODS */ /*************************************************************/ + SERIALIZABLE(Mesh, + CAST(m_positions3D), + CAST(m_normals), + CAST(m_positions2D), + CAST(m_texCoords), + CAST(m_instances_offsets), + CAST(m_indices)) + /** * @brief Mesh builds an empty mesh, to be renderable, a mesh must have vertices and a material. */ - Mesh(const std::string &name = "mesh"); + Mesh(); + Mesh(const std::string &name); ~Mesh(); void setName(const std::string &name) { m_name = name; } @@ -122,9 +133,9 @@ public: // add vertex void addVertex(float x, float y, float z) {addVertex(glm::vec3(x, y, z));} - void addVertex(const glm::vec3 &position) {positions3D.push_back(position);} + void addVertex(const glm::vec3 &position) {m_positions3D.push_back(position);} void addVertex(float x, float y) {addVertex(glm::vec2(x, y));} - void addVertex(const glm::vec2 &position) {positions2D.push_back(position);} + void addVertex(const glm::vec2 &position) {m_positions2D.push_back(position);} void addVertex(const glm::vec3 &position, const glm::vec2 &texCoord) {addVertex(position); addTexCoord(texCoord);} void addVertex(const glm::vec2 &position, const glm::vec2 &texCoord) {addVertex(position); addTexCoord(texCoord);} void addVertex(const glm::vec3 &position, const glm::vec3 &normal) {addVertex(position); addNormal(normal);} @@ -134,8 +145,8 @@ public: void addRectangle2D(float x, float y, float width, float height, bool indexed = false) {addRectangle2D(glm::vec2(x, y), glm::vec2(width, height), indexed);} // add indices - void addTriangle(int i1, int i2, int i3) {indices.push_back(i1), indices.push_back(i2), indices.push_back(i3);} - void addLine(int i1, int i2) {indices.push_back(i1), indices.push_back(i2);} + void addTriangle(int i1, int i2, int i3) {m_indices.push_back(i1), m_indices.push_back(i2), m_indices.push_back(i3);} + void addLine(int i1, int i2) {m_indices.push_back(i1), m_indices.push_back(i2);} // Material accessers void setMaterial(Material* mat) {material = mat;} @@ -143,9 +154,9 @@ public: // other accessers void addNormal(float x, float y, float z) {addNormal(glm::vec3(x, y, z));} - void addNormal(const glm::vec3 &normal) {normals.push_back(normal);} + void addNormal(const glm::vec3 &normal) {m_normals.push_back(normal);} void addTexCoord(float u, float v) {addTexCoord(glm::vec2(u, v));} - void addTexCoord(const glm::vec2 &texCoord) {texCoords.push_back(texCoord);} + void addTexCoord(const glm::vec2 &texCoord) {m_texCoords.push_back(texCoord);} /*************************************************************/ /* 2D MESH PROPERTIES */ @@ -196,43 +207,25 @@ public: void mergeVertices(); /** - * @brief computeNormals computes adjacency for a triangle mesh, the mesh type changes to GL_TRIANGLES_ADJACENCY + * @brief computeNeighbors computes adjacency for a triangle mesh, the mesh type changes to GL_TRIANGLES_ADJACENCY */ void computeNeighbors(); /** - * compute normals from an indexed mesh (positions + indices) + * @brief computeNormals computes normals from an indexed mesh (positions + indices) */ void computeNormals(); /** - * compute tangent space from a textured indexed mesh (positions + normals + texcoords + indices) + * @brief computeTangents computes tangent space from a textured indexed mesh (positions + normals + texcoords + indices) */ void computeTangents(); /** - * compute the bounding box of the mesh based on the 3D positions + * @brief computeBoundingBox computes the bounding box of the mesh based on the 3D positions */ void computeBoundingBox(glm::vec3 &min, glm::vec3 &max); - - /*************************************************************/ - /* SERIALISATION */ - /*************************************************************/ - - /** - * @brief serializeMesh can be used to save a mesh - * @return true if the mesh has succesfully been saved - */ - static bool serialize(Mesh* mesh, FILE *file); - - bool serialize(FILE *file) { return serialize(this, file); } - - /** - * @brief deserializeMesh can be used to load a mesh - * @return the loaded mesh of NULL if a reading error has occured - */ - static Mesh* deserialize(FILE *file); - + /*************************************************************/ /* ADVANCED CUSTOMISATION */ /*************************************************************/ @@ -253,19 +246,19 @@ public: unsigned int updateFlags(); protected: - std::string m_name; + std::string m_name; // yup - Material* material; - bool isDoubleSided; - bool isBillboard; - bool isWireframe; - bool isShadowCaster; - float depth; - unsigned int m_flags; + Material* material; // nop + bool isDoubleSided; // yup + bool isBillboard; // yup + bool isWireframe; // yup + bool isShadowCaster; // yup + float depth; // yup + unsigned int m_flags; // nop GL - GLenum primitive_type; + GLenum primitive_type; // yup - std::vector buffers; + std::vector buffers; // nop GL enum { // required buffer @@ -286,12 +279,12 @@ protected: NB_BUFFERS }; - int buffersId[NB_BUFFERS]; + int buffersId[NB_BUFFERS]; // nop GL void addBuffer(Buffer *b, int bufferType); void clearBuffers(); - GLuint vao; + GLuint vao; // nop GL }; #endif // MESH_H diff --git a/src/parametricmesh.cpp b/src/parametricmesh.cpp index 6711804..6489190 100644 --- a/src/parametricmesh.cpp +++ b/src/parametricmesh.cpp @@ -97,11 +97,11 @@ int MeshGenerator::getEdge(int a, int b) vid = current->vertex; else if(current->next == NULL) { - vid = m_mesh->positions3D.size(); + vid = m_mesh->m_positions3D.size(); // creating subdivision vertex // u/v sphériques, cohérents sur toute la sphère sauf des artefacts au niveau des u==0 - glm::vec3 pos = glm::normalize((m_mesh->positions3D[a] + m_mesh->positions3D[b]) / 2.f); + glm::vec3 pos = glm::normalize((m_mesh->m_positions3D[a] + m_mesh->m_positions3D[b]) / 2.f); float newU = (pos.x < 0 ? 1.5f : 1.f) + atan(pos.z/pos.x)/(2*M_PI); float newV = acos(pos.y)/M_PI; // alternative, u/v moyennés : @@ -126,25 +126,25 @@ int MeshGenerator::getEdge(int a, int b) void MeshGenerator::subdivide() { - edges = new Edge[m_mesh->positions3D.size()-1]; - int nb_triangles = m_mesh->indices.size()/3; + edges = new Edge[m_mesh->m_positions3D.size()-1]; + int nb_triangles = m_mesh->m_indices.size()/3; for(int j=0; jindices[j*3 + k]; - int idB = m_mesh->indices[j*3 + (k+1)%3]; + int idA = m_mesh->m_indices[j*3 + k]; + int idB = m_mesh->m_indices[j*3 + (k+1)%3]; int a = idA < idB ? idA : idB; int b = idA > idB ? idA : idB; vid[k] = getEdge(a, b); } for(int k=0; k<3; k++) - m_mesh->addTriangle(m_mesh->indices[j*3 + k], vid[k], vid[(k+2)%3]); + m_mesh->addTriangle(m_mesh->m_indices[j*3 + k], vid[k], vid[(k+2)%3]); m_mesh->addTriangle(vid[0], vid[1], vid[2]); } delete[](edges); - m_mesh->indices.erase(m_mesh->indices.begin(), m_mesh->indices.begin()+nb_triangles*3); + m_mesh->m_indices.erase(m_mesh->m_indices.begin(), m_mesh->m_indices.begin()+nb_triangles*3); } int MeshGenerator::getVertexId(int i, int j, int height)