Tukukkk

Alright, so first, the reason I'm posting this is because I've seen so many tutorials that conflict with each other, and I would like to get this all straightened out. (Ignore the lack of shaders/mvp matrices/etc.)

Here is my simple example code:
You can view it on pastebin here to make it easier to read.

#pragma once



#include <string>

#include <vector>

#include <glm.hpp>



#include "Logger.h"



#include "GL.h"



namespace engine {



    using Index = unsigned int;



    struct Vertex {

        glm::vec3  position;

        glm::vec2  texcoord;

    };



    struct Mesh {

        std::vector<Vertex> vertices;

        std::vector<Index> indices;

    };



    struct MeshRenderer {

        GLsizei count;

        GLuint vao;



        ~MeshRenderer() {

            // Is this the only call needed to clean up a vao?

            glDeleteVertexArrays(1, &vao);

        }

    };



    class Engine {

        Logger logger;

        MeshRenderer mr;



    public:

        Engine() :

            logger{"Engine"} {



            glEnable(GL_CULL_FACE);

            glCullFace(GL_BACK);



            glClearColor(0, 0, 0, 0);



            Mesh mesh;



            mesh.vertices.push_back({{ 0.5f,  0.5f, 0.0f}, {0.5f,  0.5f}});

            mesh.indices.push_back(0);



            mesh.vertices.push_back({{-0.5f,  0.5f, 0.0f}, {-0.5f,  0.5f}});

            mesh.indices.push_back(1);



            mesh.vertices.push_back({{-0.5f, -0.5f, 0.0f}, {-0.5f, -0.5f}});

            mesh.indices.push_back(2);



            mr.count = mesh.indices.size();



            // Only needed temp while binding to vao.

            GLuint vbo, ibo;



            glGenVertexArrays(1, &mr.vao); // Vertex  Array  Object

            glGenBuffers(1, &vbo); // Vertex  Buffer Object (temp)

            glGenBuffers(1, &ibo); // Element Buffer Object (temp)



            glBindVertexArray(mr.vao);



            glBindBuffer(GL_ARRAY_BUFFER, vbo);

            glBufferData(GL_ARRAY_BUFFER, mesh.vertices.size() * sizeof(Vertex), mesh.vertices.data(), GL_STATIC_DRAW);



            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

            glBufferData(GL_ELEMENT_ARRAY_BUFFER, mesh.indices.size() * sizeof(Index), mesh.indices.data(), GL_STATIC_DRAW);



            glEnableVertexAttribArray(0);

            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, position)));



            glEnableVertexAttribArray(1);

            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, texcoord)));



            glBindVertexArray(0);



            // Is there any reason not to clean these up now that they have been bound to the vao?

            glDeleteBuffers(1, &vbo);

            glDeleteBuffers(1, &ibo);

        }



        void onLoop(double time) {

            glClear(GL_COLOR_BUFFER_BIT);



            glBindVertexArray(mr.vao);

            glDrawElements(GL_TRIANGLES, mr.count, GL_UNSIGNED_INT, nullptr);

        }

    };

}

Basically, I want to know:

1. Is the VAO setup/initialization shown done correctly, or am I missing any steps or have I done anything sub optimally?


2. The way I delete the VAO (glDeleteVertexArrays(1, &vao);) is that the only call I need to do to fully delete it?


3. Is it safe/good practice to delete the VBO and IBO where I do (or should I save these in until the VAO is deleted)?


4. (Bonus points) What would be the best way to go about updating an existing mesh? For instance if I'm rendering a grid of tiles, but I want to update the texture UVs on specific vertices, what would be the best approach for something like this? (In the past I'd rebuild the mesh manually, and make a new VAO and pass it in again. Is there a way to just update specific vertex attributes of interest?)