Create animation

Hi guys, I’m new here!
I’m coding with C, and I want to do a gravitational particles simulator.

I want to plot cartesian points and update their coordinates continuously, creating a animation.
I have no idea how to do this, I just know how to plot point with GL_POINTS, and have that:

~include things~

void display (void) { 

int main (int argc, char **argv) {

        ~code things~

        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(100, 100);
	glutCreateWindow("Particles simulator");

        return 0;

I tried to write each frame of the animation as:

        int i;
	glMatrixMode (GL_MODELVIEW);
	glBegin (GL_POINTS);
		for (i=0; i<n; i++) {
			glVertex2f(prtcl->coord[0], prtcl->coord[1]);
			prtcl = prtcl->next;

I hope u guys can help me :smiley:

Use double buffer, this will improve things a bit.

Here is a tutorial about particle systems, but focused on newer OpenGL functionalities.

Here is another one.

And another one involving transform feedback.

Finally, this one is a bit old, but might be interesting for you since it uses glVertex and so on. It also uses textures so that you can make your particles don’t look like only like colored pixels… For this one don’t pay attention on how it sets the windowing, keep using glut.

get familliar with “vertex array object” and “buffer object” if you want a efficient way to render things (like particles)
to update / animate the particle system, there are different ways to do that:
– you update each particle in your c-application, which is not efficient
– you update the particles in your openGL shader code, thats the approach i would recommend

here is an good example:

… I just know how to plot point with GL_POINTS, …

This implies that you can currently open a GL window and display a scene with a bunch of points on the screen. Is that right?

no, updating the particles using the graphics card is much faster than doing it on the CPU
rendering and updating are 2 separate steps:
– use a “compute shader” to calculate the new particle attributes (position/velocity/color/lifetime/etc.)
– use a simple vertex/fragment shader to render colored points

Or if you want to target earlier versions of OpenGL (compute shaders were added in 4.3), you can achieve the same result with a vertex shader and transform feedback.

Or, if you’re animating points along a fixed trajectory, you can just compute the position in the vertex shader during rendering. Transform feedback just allows you to save the updated state for use in the next frame.

Separating update from rendering is useful mainly if you’re updating incrementally and there are relatively complex interactions between particles requiring multiple steps and intermediate data structures.