initial commit

HydraEngine/source/mesh/HydraMesh.h

@@ -0,0 +1,13 @@
+#ifndef HYDRAMESH
+#define HYDRAMESH
+#include "../HydraDefines.h"
+#include "StandardVertex.h"
+
+struct HydraMesh
+{
+    HydraID mesh_id = INVALID_HYDRA_ID;
+    std::vector<StandardVertex> vertexes;
+    std::vector<uint32_t> indexes;
+};
+
+#endif /* HYDRAMESH */

HydraEngine/source/mesh/HydraMeshManager.cpp

@@ -0,0 +1,106 @@
+#include "HydraMeshManager.h"
+#include <GLMIncludes.h>
+
+void HydraMeshManager::Initialise()
+{
+    m_meshes.resize(MAX_ACTORS);
+    for(uint32_t mesh_idx = 0; mesh_idx < MAX_ACTORS; mesh_idx++)
+    {
+        m_available_mesh_ids.push(mesh_idx);
+    }
+}
+
+void HydraMeshManager::Shutdown()
+{
+    for(uint32_t mesh_idx = 0; mesh_idx < MAX_ACTORS; mesh_idx++)
+    {
+        if(m_meshes[mesh_idx].mesh_id != INVALID_HYDRA_ID)
+        {
+            DeleteMesh(m_meshes[mesh_idx].mesh_id);
+        }
+    }
+    m_meshes.clear();
+}
+
+HydraID HydraMeshManager::CreateMesh()
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(m_available_mesh_ids.size() > 0)
+    {
+        HydraID mesh_id = m_available_mesh_ids.front();
+        m_available_mesh_ids.pop();
+        m_meshes[mesh_id].mesh_id = mesh_id;
+        return mesh_id;
+    }
+    return INVALID_HYDRA_ID;
+}
+
+HydraMesh * const HydraMeshManager::GetMesh(HydraID mesh_id)
+{
+    // TODO: insert return statement here
+    if(mesh_id < m_meshes.size())
+    {
+        return &m_meshes[mesh_id];
+    }
+    return nullptr;
+}
+
+void HydraMeshManager::DeleteMesh(HydraID mesh_id)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(mesh_id < m_meshes.size())
+    {
+        m_meshes[mesh_id].vertexes.clear();
+        m_meshes[mesh_id].mesh_id = INVALID_HYDRA_ID;
+    }
+}
+
+void HydraMeshManager::CalculateNormals(HydraID mesh_id)
+{
+
+    HydraMesh mesh = m_meshes[mesh_id];
+	for (int i = 0; i < mesh.indexes.size(); i += 3)
+	{
+        uint32_t idx0 = mesh.indexes[i+0];
+        uint32_t idx1 = mesh.indexes[i+1];
+        uint32_t idx2 = mesh.indexes[i+2];
+
+        glm::vec3 vec0 = glm::normalize(glm::vec3(mesh.vertexes[idx0].position[0], mesh.vertexes[idx0].position[1], mesh.vertexes[idx0].position[2]));
+        glm::vec3 vec1 = glm::normalize(glm::vec3(mesh.vertexes[idx1].position[0], mesh.vertexes[idx1].position[1], mesh.vertexes[idx1].position[2]));
+        glm::vec3 vec2 = glm::normalize(glm::vec3(mesh.vertexes[idx2].position[0], mesh.vertexes[idx2].position[1], mesh.vertexes[idx2].position[2]));
+
+        glm::vec3 normal = glm::triangleNormal(vec0, vec1, vec2);
+
+        m_meshes[mesh_id].vertexes[idx0].normal[0] = normal[0];
+        m_meshes[mesh_id].vertexes[idx0].normal[1] = normal[1];
+        m_meshes[mesh_id].vertexes[idx0].normal[2] = normal[2];
+
+        m_meshes[mesh_id].vertexes[idx1].normal[0] = normal[0];
+        m_meshes[mesh_id].vertexes[idx1].normal[1] = normal[1];
+        m_meshes[mesh_id].vertexes[idx1].normal[2] = normal[2];
+
+        m_meshes[mesh_id].vertexes[idx2].normal[0] = normal[0];
+        m_meshes[mesh_id].vertexes[idx2].normal[1] = normal[1];
+        m_meshes[mesh_id].vertexes[idx2].normal[2] = normal[2];
+		// glm::vec3 vec0 = glm::vec3(mesh.vertexes[mesh.indexes[i]], mesh.vertexes[mesh.indexes[i] + 1], mesh.vertexes[mesh.indexes[i] + 2]);
+		// glm::vec3 vec1 = glm::vec3(Vertexes[Indexes[i+1]], Vertexes[Indexes[i+1] + 1], Vertexes[Indexes[i+1] + 2]);
+		// glm::vec3 vec2 = glm::vec3(Vertexes[Indexes[i+2]], Vertexes[Indexes[i+2] + 1], Vertexes[Indexes[i+2] + 2]);
+
+		// glm::vec3 normal = glm::triangleNormal(vec0, vec1, vec2);
+
+		// Normals[Indexes[i]] = normal.x;
+		// Normals[Indexes[i]+1] = normal.y; 
+		// Normals[Indexes[i]+2] = normal.z;
+
+		// Normals[Indexes[i+1]] = normal.x;
+		// Normals[Indexes[i+1] + 1] = normal.y;
+		// Normals[Indexes[i+1] + 2] = normal.z;
+
+		// Normals[Indexes[i + 2]] = normal.x;
+		// Normals[Indexes[i + 2] + 1] = normal.y;
+		// Normals[Indexes[i + 2] + 2] = normal.z;
+
+	}
+
+}
+

HydraEngine/source/mesh/HydraMeshManager.h

@@ -0,0 +1,25 @@
+#ifndef HYDRAMESHMANAGER
+#define HYDRAMESHMANAGER
+#include "HydraMesh.h"
+#include "../engine/HydraObject.h"
+#include <queue>
+#include <vector>
+#include <mutex>
+
+class HydraMeshManager : public HydraObject
+{
+    public:
+        void Initialise();
+        void Shutdown();
+        HydraID CreateMesh();
+        HydraMesh* const GetMesh(HydraID mesh_id);
+        void DeleteMesh(HydraID mesh_id);
+        void CalculateNormals(HydraID mesh_id);
+    private:
+        std::mutex m_mutex;
+        std::vector<HydraMesh> m_meshes;
+        std::queue<HydraID> m_available_mesh_ids;
+        
+};
+
+#endif /* HYDRAMESHMANAGER */

HydraEngine/source/mesh/StandardVertex.h

@@ -0,0 +1,15 @@
+#ifndef STANDARDVERTEX
+#define STANDARDVERTEX
+
+#include <vector>
+struct StandardVertex
+{
+    float position[3];
+    float text_coord0[2]; 
+    uint32_t chunk_id[3];    
+    float normal[3];
+    float bitanget[3];
+    float tangent[3];
+
+};
+#endif /* STANDARDVERTEX */