Простая система частиц. Пример.

#include <iostream>
#include <math.h>
#include <vector>
#include <SFML\Graphics.hpp>
#include "Particle.h"
#include "const.h"
#include <SFML\OpenGL.hpp>
 
 
using namespace std;
 
float modOfVector(sf::Vector2f & v) { // Находим модуль вектора
	return sqrt(v.x*v.x + v.y*v.y); 
}
float getDistance(sf::Vector2f && v1, sf::Vector2f && v2) noexcept { // Растояние между двумя точками
	return sqrt(pow((v2.x - v1.x), 2) + pow((v2.y - v1.y), 2));
}
 
void particleTransform(vector <Particle>const & part, float ** & i_vec){ // Функция переписывает координаты частиц из вектора, в двумерный массив
	for (int i = 0; i < NUMB_OF_BLOCK; ++i) {
		for (int j = 0; j < PART_IN_BLOCK; ++j) {
			i_vec[i][j * 2] = part[j + i*PART_IN_BLOCK].getPosition().x;
			i_vec[i][j * 2 + 1] = part[j + i*PART_IN_BLOCK].getPosition().y;
		}
	}
}
 
int main() {
	sf::ContextSettings set;
	set.antialiasingLevel = 8; // Устанавливаем уровень сглаживания, хотя можно и без него обойтись
 
	sf::RenderWindow window(sf::VideoMode(winW, winH), "PS", sf::Style::Default, set); // Создаем окно, в котором будем рисовать. winW & winH - константы из const.h
 
	vector <Particle> all_part; // Вектор частиц
 
	float ** coords = new float * [NUMB_OF_BLOCK]; // Двумерный динамический массив координат точек, используется 
 
	for (int i = 0; i < NUMB_OF_BLOCK; ++i)
		coords[i] = new float[PART_IN_BLOCK * 2];
 
	unsigned char ** colors = new unsigned char *[NUMB_OF_BLOCK]; // Аналогичный массив, хранящий информацию о цвете каждой точки
	for (int i = 0; i < NUMB_OF_BLOCK; ++i)
		colors[i] = new unsigned char[PART_IN_BLOCK * 3];
 
	for (int i = 0; i < NUMB_OF_BLOCK; i++) {
		for (int j = 0; j < PART_IN_BLOCK; j++) {// sf::Vector2f(200, 100) - смешение для точек 
			srand(time(0));
			int mass = 10 + rand() %  70; // Выбираем случайую массу в диапазоне от 10 до 79
			Particle tmp(mass, sf::Vector2f(20, 100) + sf::Vector2f(j*0.6, i*3)); // Создаем новую частицу
			all_part.push_back(tmp);
			coords[i][2*j] = tmp.getPosition().x; // Добавляем координаты частицы в массив
			coords[i][2*j +1] = tmp.getPosition().y;
		}
	}
 
	////////////////// OpenGL settings
	glEnable(GL_POINT_SMOOTH); //Три функции приводят нашу квадратную точку к круглой
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
	glPointSize(1); // Размер точки - 1 пиксель
	glOrtho(0, winW, winH, 0, 1, -1); // Ориентирование нашей сцены
	//////////////////////////////////
 
	bool LB_press = 0;
 
	sf::Clock clock; // Часы, чтобы замерять сколько времени уходит на обработку каждого кадра
	float frame_time = 0.1f;
 
	sf::Event event;
	while (window.isOpen()) {
		while (window.pollEvent(event)) {
			if (event.type == sf::Event::Closed)
				window.close();
		}
		if (sf::Mouse::isButtonPressed(sf::Mouse::Left))// Тригер для нажатия ЛКМ
			LB_press = 1;
		else
			LB_press = 0;
 
		glClear(GL_COLOR_BUFFER_BIT); // Очистка буфера
 
		for (auto it = 0; it < all_part.size(); ++it) {
			if (LB_press) { // Если нажата ЛКМ, то добавляем силы к частицам
				sf::Vector2f mouse = sf::Vector2f(sf::Mouse::getPosition(window)); // Записываем координаты мышки относительно нашего окна
				all_part[it].addForce((mouse - all_part[it].getPosition()) * (G / pow(getDistance(move(mouse), all_part[it].getPosition()) + 5, 2)));
				all_part[it].addForce(-all_part[it].getSpeed()*100.0f); // Тормозящая сила (сила сопротивления), вместе 100*f можно подставить любую магическую константу, чем больше - тем меньшее ускорение у частиц.
			}
			//Обновляем частицу
			all_part[it].update(move(frame_time)); // Передает в update информацию о том, сколько времени ушло для вычисления всей информации на предыдущем кадре
			if (LB_press) all_part[it].cler_force(); // Очищаем вектор скоростей
 
		}
 
		glPushMatrix();
 
		particleTransform(all_part, coords); // Переносим обновленные данные из вектора в массив
 
		glEnableClientState(GL_VERTEX_ARRAY);
		glEnableClientState(GL_COLOR_ARRAY);
 
 
		for (int i = 0; i < NUMB_OF_BLOCK; ++i) {
			for (int j = 0; j < PART_IN_BLOCK; ++j) { // Цвета подобраны почти случайно, каждый может менять как горазд
				colors[i][3 * j] = 152;
				colors[i][3 * j + 1] =  50 + static_cast <int> (modOfVector(all_part[j + i*PART_IN_BLOCK].getSpeed())); // Находим модуль вектора скорости
				colors[i][3 * j + 2] = 10 + static_cast <int> (modOfVector(all_part[j + i*PART_IN_BLOCK].getSpeed())) ;
			}
		}
 
		for (int i = 0; i < NUMB_OF_BLOCK; ++i) {
			glVertexPointer(2, GL_FLOAT, 0, coords[i]); // Передаем кол-во координат точки, формат координат и указатель на массив координат
			glColorPointer(3, GL_UNSIGNED_BYTE, 0, colors[i]); // Тоже самое, только для цвета.
			glDrawArrays(GL_POINTS, 0, PART_IN_BLOCK); // Функция отображения массива элементов. Передаем тип отображаемого объекта, смещение до следующего элемента (у нас 0, т.к. массив линейный) и размер массива.
 
		}
 
		glDisableClientState(GL_VERTEX_ARRAY);
		glDisableClientState(GL_COLOR_ARRAY);
 
		glPopMatrix();
 
		glFlush();
		window.display(); // Отображаем кадр.
		frame_time = clock.restart().asSeconds(); // Записываем прошедшее время и перезапускаем часы.
 
	}
	for (int i = 0; i < NUMB_OF_BLOCK; ++i) // Освобождаем динамическую память.
		delete[] coords[i];
	for (int i = 0; i < NUMB_OF_BLOCK; ++i) // Освобождаем динамическую память.
		delete[] colors[i];
	return 0;
}

#include <iostream>
#include <SFML\Graphics.hpp>
#include <math.h>
#include <vector>
#pragma once
using namespace std;
 
class Particle
{
private: vector <sf::Vector2f> forces;
		 sf::Vector2f position;
		 sf::Vector2f main_force;
		 sf::Vector2f speed;
		 int mass;
public:
	Particle();
	Particle(int m, sf::Vector2f pos);
	sf::Vector2f getSpeed()  noexcept { return speed; };
	sf::Vector2f getPosition() const noexcept { return position; }
	sf::Vector2f getMainForce() noexcept;
	void cler_force () noexcept;
	void addForce(sf::Vector2f & n_force) noexcept;
	void update(float && t) noexcept;
	~Particle();
};

#include "Particle.h"
 
 
 
Particle::Particle() // Стандартный конструктор не имеет реализации, т.к. не пригодился
{
}
Particle::Particle(int m, sf::Vector2f pos) { // Конструктор инициализирует массу и начальное положение
	mass = m;
	position = pos;
	speed = sf::Vector2f(0,0); // Начальная скорость - 0
}
 
void Particle::cler_force() noexcept { // Очищает std::vector от векторов силы. Т.е. убирает все силы, которые действуют на точку
	forces.clear();
}
 
void Particle::addForce(sf::Vector2f & n_force) noexcept { // Добавляет вектор силы в std::vector. На точку теперь воздейтсвует новая сила
	forces.push_back(n_force);
}
sf::Vector2f Particle::getMainForce() noexcept {// Подсчитывает результирующую силу. Т.к. силу можно однозначно характеризовать вектором, мы просто складываем все вектора в std::vector 
	sf::Vector2f res(0, 0);
	for (auto it = forces.begin(); it != forces.end(); ++it)
		res += *it;
	return res;
}
void Particle::update(float && t) noexcept {
	sf::Vector2f prevPos = position; // Сохраняем текущую позицию точку
	sf::Vector2f res_force = getMainForce(); // Находим результирующую силу
 
	position += 0.5f*res_force*t*t / static_cast <float>(mass) + speed*t; // Обновляем позицию на текущем кадре
 
	// Оба варианта определения скорости корректны - но второй работает несколько быстрее
	//speed = (res_force / static_cast <float>(mass)) * t + speed; // Обновляем скорость
	speed = (position - prevPos) / t; // Обновляем скорость
 
}
 
 
Particle::~Particle()
{
}

#pragma once
 
const int winW = 800; // Ширина окна
const int winH = 500; // Высота окна
#ifdef DEBUG
const int NUMB_OF_BLOCK = 10;
const int PART_IN_BLOCK = 1000;
#endif // DEBUG
 
#ifdef RELEASE
const int NUMB_OF_BLOCK = 100;
const int PART_IN_BLOCK = 1000;
#endif // RELEASE
 
const float G = 300000;