OpenGL transform vertex array object during runtime - c++

Question

I have multiple objects but no idea how to move or rotate them separately. This would be a shorten version of the code I have so far:
const GLchar* vertexSource = "#version 150 core\n"
"in vec3 position;"
"uniform mat4 model;"
"uniform mat4 view;"
"uniform mat4 proj;"
"void main() {"
" gl_Position = proj * view * model * vec4(position, 1.0);"
"}";
struct Object {
// here are the constructors
vector<Triangle> polys; // Triangle is a struct containing vertex data
GLuint vao, vbo, ebo;
// somne other variables and functions
// ...
};
void ShaderProgram::AddObject(const vector<Triangle>& polys) {
objects.push_back(Object(polys));
Object& obj = objects[objects.size()-1];
glGenVertexArrays(1, &obj.vao);
glBindVertexArray(obj.vao);
// set up vertices and a vertex buffer object for them
// ...
glGenBuffers(1, &obj.vbo);
glBindBuffer(GL_ARRAY_BUFFER, obj.vbo);
glBufferData(GL_ARRAY_BUFFER, obj.polys.size()*polySize*sizeof(float), vertices, GL_STATIC_DRAW);
// 'polySize' is just a constant variable to healp me out and 'vertices' is a float array
// set up element buffer object
// ...
glGenBuffers(1, &obj.ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, obj.ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);
// elements is a float array
GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
glEnableVertexAttribArray(posAttrib);
glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, vertSize*sizeof(float), 0);
// 'vertSize' is also a constant variable
}
void ShaderProgram::Draw(float dSec) {
for (Object& it : objects) {
glBindVertexArray(it.vao);
// here's some texturing related stuff
glDrawElements(GL_TRIANGLES, it.vertexCount(), GL_UNSIGNED_INT, 0);
}
}
void ShaderProgram::Move(Object& obj, glm::vec3 vec) {/*move it somehw*/}
void ShaderProgram::Rotate(Object& obj, glm::vec3 rotPoint, glm::vec3 rot) {/*rotate obj around rotPoint*/}
If I run this code everything displays perfectly but I couldn't figure out a clean way to change the positions of the vertices of one specific object during runtime.
Also, this doesn't have anything to do with the initial question but I've noticed that whenever I run the exact same code on my laptop, the program crash when calling glBindFragDataLocation() (it doesn't matter whether I run it on Linux or Windows).

Answer 1

In many rendering applications, several different coordinate systems are used:
Object space: This is the space where vertices are defined. Each model has it's own object coordinates with it's own model origin.
World space: This is the space where all the models in a scene are positioned relative to each other. This is (in general) done by specifying a model-matrix based on the desired location in the scene.
In your case, I would add an additional vec3 member to the Object struct that stores the location.
struct Object {
//Things you already have
glm::vec3 loc;
}
You can then update the model matrix uniform directly before calling glDrawElements. Since the draw call is already issued, changing the model matrix in this place will always influence the correct object:
void ShaderProgram::Draw(float dSec) {
for (Object& it : objects) {
glBindVertexArray(it.vao);
// here's some texturing related stuff
glm::mat4 model_matrix(1.0f);
glm::translate(model_matrix, it.loc);
glUniformMatrix4fv(model_uniform_location, 1, GL_FALSE, model_matrix);
glDrawElements(GL_TRIANGLES, it.vertexCount(), GL_UNSIGNED_INT, 0);
}
}
Another option would be to store a matrix directly in the Object class, which would increase the data size (and might be less intuitive to use), but might reduce runtime costs.

Answer 2

The current state of the Draw function looks like this:
void ShaderProgram::Draw(float dSec) {
objects[0].location.x += dSec;
GLint uniModel = glGetUniformLocation(shaderProgram, "model");
for (Object& it : objects) {
glBindVertexArray(it.vao);
glm::mat4 model;
model = glm::translate(model, it.location);
glUniformMatrix4fv(uniModel, 1, GL_FALSE, glm::value_ptr(model));
glDrawElements(GL_TRIANGLES, it.vertexCount(), GL_UNSIGNED_INT, 0);
}
}