In this Python Modern Opengl article i want to show you Rotating The Cube. before starting our main topic about Opengl Rotating Cube,  you can check the previous articles.

 

 

 

Read more article on Python Opengl Programming

1:  Python Opengl Introduction And Creating Window

2: Python Opengl Drawing Teapot

3: Python Modern Opengl Drawing Rectangle

4: Python Modern Opengl GLFW Window

5: Python Modern Opengl Triangle With GLFW Window

6: Python Modern Opengl Coloring Triangle

7: Python Modern Opengl Drawing Rectangle

Also for math you need to install a library in python

 

 

 

 

So now this is the complete code for Python Modern Opengl Rotating The Cube

So if you have followed my previous articles on Python Modern Opengl Programming, most of these codes will be familiar to you.but i will explain again some of them.

 

 

 

 

These are the cube values and also different color for the values, also we have converted the values to 32bit value.

 

 

 

 

Because we are working with EBO (Element Buffer Object) we need to create indices for our cube, also we have converted to 32bit int

 

 

 

 

These are the vertex and fragment shaders.

 

In the vertex shader at the top we have the version of shader, after that we have two input values for our position and color. also we have an output value for our color that we will use that in the fragment shader. we have a new value in our vertex shader that is called uniform. OK now in the fragment shader we have the same shader version and we are going to take the input value of new color in our fragment shader.

 

 

 

What is Uniform Variable ?

So a uniform is a global Shader variable declared with the “uniform” storage qualifier. These act as parameters that the user of a shader program can pass to that program. Their values are stored in a program object.

Uniforms are so named because they do not change from one shader invocation to the next within a particular rendering call. This makes them unlike shader stage inputs and outputs, which are often different for each invocation of a shader stage.

 

 

 

What Are Shaders ?

Shaders are little programs that rest on the GPU. These programs are run for each specific section of the graphics pipeline. so In a basic sense, shaders are nothing more than programs transforming inputs to outputs. Shaders are also very isolated programs.

 

 

 

Vertex Shader

The vertex shader is a program on the graphics card that processes each vertex and its attributes as they appear in the vertex array. Its duty is to output the final vertex position in device coordinates and to output any data the fragment shader requires. That’s why the 3D transformation should take place here. The fragment shader depends on attributes like the color and texture coordinates, which will usually be passed from input to output without any calculations. Remember that our vertex position is already specified as device coordinates and no other attributes exist, so the vertex shader will be fairly bare bones.

 

 

 

Fragment Shader 

the output from the vertex shader is interpolated over all the pixels on the screen covered by a primitive. These pixels are called fragments and this is what the fragment shader operates on. Just like the vertex shader it has one mandatory output, the final color of a fragment. It’s up to you to write the code for computing this color from vertex colors, texture coordinates and any other data coming from the vertex shader.

 

 

 

 

compile the program and shaders

The next step is to upload this vertex data to the graphics card. This is important because the memory on your graphics card is much faster and you won’t have to send the data again every time your scene needs to be rendered (about 60 times per second).

 

 

This is done by creating a Vertex Buffer Object (VBO):

 

 

 

Now it is time to create EBO

 

 

 

What is EBO ?

To explain how element buffer objects work it’s best to give an example: suppose we want to draw a rectangle instead of a triangle.

We can draw a rectangle using two triangles (OpenGL mainly works with triangles). This will generate the following set of vertices:

 

As you can see, there is some overlap on the vertices specified. We specify bottom right and top left twice! This is an overhead of 50% since the same rectangle could also be specified with only 4 vertices, instead of 6. This will only get worse as soon as we have

 

more complex models that have over 1000s of triangles where there will be large chunks that overlap. What would be a better solution is to store only the unique vertices and then specify the order at which we want to draw these vertices in. In that case we would only have to store 4 vertices for the rectangle, and then just specify at which order we’d like to draw them.

Wouldn’t it be great if OpenGL provided us with a feature like that?

Thankfully, element buffer objects work exactly like that. An EBO is a buffer, just like a vertex buffer object, that stores indices that OpenGL uses to decide what vertices to draw. This so called indexed drawing is exactly the solution to our problem. To get started we first have to specify the (unique) vertices and the indices to draw them as a rectangle:

 

 

 

 

Also these lines of codes are for cube rotation in x and y positions

 

 

 

 

So run the code and this will be the result also i must say that right now it is s static image but when you run the code in your IDE you will see cube is rotating.