MauriceGit/Partikel_accelleration_on_GPU

Stars
253
Rank 160,424 (Top 4 %)
Language
C
License
ISC License
Created over 9 years ago
Updated over 8 years ago

MauriceGit/Partikel_accelleration_on_GPU

MauriceGit

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Particle accelleration with OpenGL 4.3, using the compute shader to calculate particle movement on graphics hardware.

Particle-Simulation using the GPU via the OpenGL Compute-Shader

This particle simulation is more like a proof of concept for myself or others, to show and understand how compute shaders in OpenGL work. Using the knowledge I gathered from this project, more complex, fascinating and fast projects are possible, which use the power of the graphics hardware for computations.

The final result looks like that:

Animation

Each particle has a life span in which it fades from red (new born) to blue (about dying). When a particle dies, it respawnes in its negated (x,y,z) position.

The movement itself is computed using an Euler integration method for each particle.

There are several global randomly moving attraction points. Particles are attracted and accelerated by these points.

Example screenshots:

Install && Run

I tested an ran this simulation on a debian-based Linux OS (Ubuntu, Mint, ...). It should run on other machines as well but is not tested.

System Requirements

The following system attributes are required for running this simulation:

A graphics card supporting OpenGL version 4.3 (For the compute-shader!).
Unix-Libraries: xorg-dev and mesa-common-dev

Both GLEW (The OpenGL Extension Wrangler Library) and GLFW (Window-Manager) are now included locally, so no system wide installation is necessary!

For a system wide installation, further information is available under the following links:

GLFW: http://www.glfw.org/.
GLEW (with install instructions): http://glew.sourceforge.net/build.html.

Running

Compiling and running should work under windows. OSX is not supported as the available OpenGL version does not reach 4.3. In the root directory, execute:

cmake .
make
cd bin/
./particleSim

While the simulation runs, you can move around (always looking to the center!) with your mouse (left-klick and move) and zoom in/out with your mouse (right click and move up/down).

More Screenshots

So, here are some more screenshots, because screenshots are awesome :)

You can find some more screenshots in the screenshot-folder: More Screenshots :).

Delaunay_Triangulation

My own implementation of a Delaunay triangulation and Voronoi partition in Python applied to images.

skiplist

A Go library for an efficient implementation of a skip list: https://godoc.org/github.com/MauriceGit/skiplist

compiler

Compiler for a small language into x86-64 Assembly

Simple_GLSL_Shader_Example

A very simple example of how shaders in OpenGL can be used, to color Objects or map a texture on some triangles.

Voronoi_Image_Manipulation

A system independent tool for interactive image manipulation with Voronoi and Delaunay data structures.

Water_Simulation

Water-Simulation with real time specular reflection on the waters surface. The reflection is implemented in GLSL and runs on the GPU and in screen space. The water itself is implemented using a pressure based approach for the surface calculation.

XBox_Controller_Linux_Interface

An interface that interacts with an XBox One controller via the usb stream. With simple methods for object or camera control (i.e. for OpenGL contexts).

Cloth_Simulation

Cloth-Visualization via particle-simulation.

Advanced_Algorithms

Quick implementations of some advanced algorithms for searching, sorting and trees

Screen_Space_Ambient_Occlusion

Giving a scene a depth-dependent shading, completely irregarding the scene complexity, in screen-space.

Quaternion_Library

A small library that capsulates most commonly used operations on Quaternions. Also a small sample implementation, that rotates an object around an axis, using Quaternions.

Energy-Dome_Terrain

A visually appealing terrain visualization from real-world data with some extras, such as an animated energy dome, LOD tessellation and multisampling

advsearch

A Go library for advanced searching in sorted data structures

Repeat_History

A small but useful command for a linux shell. It makes the bash history more easily accessible than cmd+r.

Marching_Cubes_on_GPU

A marching cube algorithm, that is executed in parallel on the GPU, using compute shaders. This will later enable a highly parallel creation of advanced landscape/terrain structures in potentially real-time (next project).

tree23

An implementation of a balanced 2,3-tree that allows accessing next/previous elements in O(1) at all times.

Vector_Library

Small vector library in C, containing all basic vector operations.

2D_Bin_Packing

several parallel solutions for a 2D bin packing problem for a programming contest.

Variance_Shadow_Maps

Small example of a project, that uses variance shadow maps with hardware Multisampling.

Voronoi_DivideAndConquer

A Go implementation of a voronoi tessellation with the divide and conquer algorithm. It is still work in progress and not yet working properly!

mtVector

A short vector library with all necessary operations for a Delaunay triangulation, including optimized matrix multiplication

game

Agar_Clone_Joystick_Client

A C++ client for our programming challenge (2016) supporting an X-BOX-Controller.

FastDelaunayImages

AdventOfCode

My solutions for the advent of code puzzles (AOC)

Artificial_Neural_Network_Character_Classification

Implementation of an artificial neural network with backpropagation for classification of characters.

Bachelor_Thesis_Arimaa

Implementation of the practical part of my bachelor thesis for the FH-Wedel. The thesis has been awarded with the "Wedeler Hochschulpreis" for innovation. The code implements an artificial intelligence which plays the game of Arimaa.