Help me understand this vbo/rotation, and how its done opengl c++

Question

Im pretty new to opengl, and I just cant figure out how to rotate this vbo/vao in 2d space. This is how I bind my coordinates:

float points[] =
{
    0.0f,  0.10f,  0.0f,
    -0.10f, -0.10f,  0.0f,
    0.10f, -0.10f,  0.0f
};

glGenBuffers(1, &points_vbo);
glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(float), points, GL_STATIC_DRAW);

I place the vbo at vao[0]

glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

And I enable the array

glEnableVertexAttribArray(0);

and call to draw in the cpu, with

glDrawArrays(GL_TRIANGLES, 0, 3);

In my shader, I load the array by:

//glsl shader
layout ( location = 0 ) in vec3 vertex_position ;
void main()
{
 gl_Position = vec4(vertex_position, 1.0);
}

Ive edited out the coloring/fragment to save space, but this is my problem: I can make a uniform to move my triangle around, but idk how to apply a transformation matrix to a vec4.

It seems the shader reads my vertex_position VAO one vec/element at a time, and trying to apply any matrix just gives an error.

How do you make or apply a rotation matrix on vao, am I inputting it wrong? All the uniforms I apply seem to only stretch, zoom, or move the overall triangle.

Sorry if the question is bad, or partially confused, shading is new to me overall, so thanks in advance.'

my shader:

#version 410 core
layout ( location = 0 ) in vec3 vertex_position ;
layout ( location = 1 ) in vec3 vertex_colour ;

out vec3 colour;
uniform vec3 fade=vec3(0.0,0.0,0.0); //fade
uniform float zoom=1.0;
uniform mat4 transform = mat4(vec4(1.0,0.0,0.0,0.0),
vec4(0.0,1.0,0.0,0.0), vec4(0.0,0.0,1.0,0.0), vec4(0.0,0.0,0.0,1.0));

void main()
{
colour=vertex_colour+fade;
gl_Position=transform*vec4(vertex_position,1.0);
}

this example https://open.gl/transformations and the answer made it doable.

Answer 1

Alright, so transformations in general are best done with matrices. Translation, Rotation, and Scaling can all be done using a **single matrix*. *Since you will be working with vector 3's and 4's, what you end up using is a 4x4 matrix.

There are several libraries out there such as GLM for handling the mathematics generally used in opengl, but whatever library you're using may already have the appropriate vector and matrix related operations.

Secondly, the technique you may use really depends on what you are trying to do. For instance, in 3D software, the position, rotation, and scale of an object is held within a single "Model Matrix", instead of modifying the entire object's vertices. However, when the model gets rendered it's underlying vertices then get transformed by that matrix every frame. It is much better to do it like this as GPU's are incredibly fast and are optimized for doing it like this, rather than doing this CPU side.

---

To rotate a vector

• the order of operations is:

  vector4 newVector4 = TransformationMatrix * oldVector4;

To prepare the matrix

• most libraries have functions for their matrices such as the "lookAt()" function for rotating the matrix to look at a particular point in space. This can sometimes be problematic as Euler rotations can lead to gimbal locking, but are a much easier starting point.

• Additionally, Quaternions may be supported in the library used for rotating a matrix. Even if no class exists, one can still write in the functionality themselves, however the math can be very off-putting to some.

In your shader, you want to provide it with a uniform mat4. You will need to bind the correct data to it in your application, but the implementation may vary if you have a library which aids you with shader logic. The implementation will look something like this:

layout ( location = 0 ) in vec3 vertex_position ;
uniform mat4 ModelMatrix;

void main()
{
   gl_Position = ModelMatrix * vec4(vertex_position, 1.0);
}