c++ opengl I am working on a small game engine. I have a problem regarding rendering 3D models. Models can consist of multiple meshes and meshes consist of multiple verticies. I want to be able to load in a model using Assimp from a file and store the modesl data for each mesh and each vertex, so that we only have to load it once. Later I want to draw the model using a class called Renderer3D which will store the various buffers related to the model's meshes. Below is the code I have for loading a model, what is missing from it to store the relevant data for later binding and drawing?

#include "solpch.h"
#include "OpenGL_Model.h"

#include "GalaxyDraw/Platform/OpenGL/GLMacros.h"
#include 
#include 
#include 
#include 

namespace GalaxyDraw
{


	struct Vertex {
		glm::vec3 Position;
		glm::vec3 Normal;
		glm::vec2 TexCoords;
	};

	struct Mesh {
	public:
		std::vector Vertices;
		std::vector Indices;
		std::vector&gt;  Textures;//TODO replace with material struct
	
		Mesh(std::vector vertices, std::vector indices, std::vector&gt; textures):
			Vertices(vertices), Indices(indices), Textures(textures)
		{}

	};
    OpenGL_Model::OpenGL_Model(const std::string&amp; modelpath)
    {
        LoadModel(modelpath);
    }

    void OpenGL_Model::SetData(const std::string&amp; path)
    {
        LoadModel(path);
    }

    bool OpenGL_Model::operator==(const Model&amp; other) const
    {
        return m_RendererID == ((OpenGL_Model&amp;)other).m_RendererID;
    }

    void OpenGL_Model::LoadModel(const std::string&amp; modelpath)
    {
        Assimp::Importer import;
        const aiScene* scene = import.ReadFile(modelpath, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_GenNormals | aiProcess_JoinIdenticalVertices);

        if (!scene || scene-&gt;mFlags &amp; AI_SCENE_FLAGS_INCOMPLETE || !scene-&gt;mRootNode)
        {
            std::cout &lt;&lt; "ERROR::ASSIMP::" &lt;&lt; import.GetErrorString() &lt;&lt; std::endl;
            return;
        }
        m_ModelDirectory = modelpath.substr(0, modelpath.find_last_of('/'));

        ProcessNode(scene-&gt;mRootNode, scene);
    }

    void OpenGL_Model::ProcessNode(aiNode* node, const aiScene* scene)
    {
        // process all the node's meshes (if any)
        for (unsigned int i = 0; i &lt; node-&gt;mNumMeshes; i++)
        {
            aiMesh* mesh = scene-&gt;mMeshes[node-&gt;mMeshes[i]];
            m_Meshes.push_back(ProcessMesh(mesh, scene));
        }
        // then do the same for each of its children
        for (unsigned int i = 0; i &lt; node-&gt;mNumChildren; i++)
        {
            ProcessNode(node-&gt;mChildren[i], scene);
        }
    }

    Mesh OpenGL_Model::ProcessMesh(aiMesh* mesh, const aiScene* scene)
    {
		std::vector vertices;
		std::vector indices;
		std::vector&gt; textures;

		for (unsigned int i = 0; i &lt; mesh-&gt;mNumVertices; i++)
		{
			Vertex vertex;

			glm::vec3 vector;
			vector.x = mesh-&gt;mVertices[i].x;
			vector.y = mesh-&gt;mVertices[i].y;
			vector.z = mesh-&gt;mVertices[i].z;
			vertex.Position = vector;

			vector.x = mesh-&gt;mNormals[i].x;
			vector.y = mesh-&gt;mNormals[i].y;
			vector.z = mesh-&gt;mNormals[i].z;
			vertex.Normal = vector;

			// does the mesh contain texture coordinates?
			if (mesh-&gt;mTextureCoords[0])
			{
				glm::vec2 vec;
				vec.x = mesh-&gt;mTextureCoords[0][i].x;
				vec.y = mesh-&gt;mTextureCoords[0][i].y;
				vertex.TexCoords = vec;
			}
			else
			{
				vertex.TexCoords = glm::vec2(0.0f, 0.0f);
			}

			vertices.push_back(vertex);
		}

		// LMAO, I wish C# procedural shit went like this
		for (unsigned int i = 0; i &lt; mesh-&gt;mNumFaces; i++)
		{
			aiFace face = mesh-&gt;mFaces[i];
			for (unsigned int j = 0; j &lt; face.mNumIndices; j++)
			{
				indices.push_back(face.mIndices[j]);
			}
		}

		// Checks if any material exists at all
		//if (mesh-&gt;mMaterialIndex &gt;= 0)
		//{
		//	// gets the material cached within that specific index
		//	aiMaterial* material = scene-&gt;mMaterials[mesh-&gt;mMaterialIndex];

		//	std::vector diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse");
		//	textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());

		//	std::vector specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular");
		//	textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
		//}

		return Mesh(vertices, indices, textures);
    }

}

