{"id":22,"date":"2025-05-30T20:57:37","date_gmt":"2025-05-30T20:57:37","guid":{"rendered":"https:\/\/blog.metu.edu.tr\/e252135\/?p=22"},"modified":"2025-05-30T20:57:39","modified_gmt":"2025-05-30T20:57:39","slug":"particle-simulation","status":"publish","type":"post","link":"https:\/\/blog.metu.edu.tr\/e252135\/2025\/05\/30\/particle-simulation\/","title":{"rendered":"Particle Simulation"},"content":{"rendered":"

Introduction<\/strong><\/h2>\n

In this blog, I will share my experience completing the third assigment for course Ceng469 Computer Graphics 2.<\/p>\n

For this assigment, I implemented a particle system with attractors ,using OpenGL and compute shaders.<\/p>\n

Initializing Window and Buffers<\/strong><\/h2>\n

I first set up the OpenGL context and window\u00a0 using GLFW. I configured opengl to use version 4.3 for the modern features like compute shaders.<\/p>\n

Creating Buffers and TBOS<\/strong><\/h2>\n\n\n

After setting up the OpenGL context, I created GPU buffers for the particle system\u2014one for positions and one for velocities. Each particle is represented as a vec4<\/code>, where the xyz<\/code> components store the 3d position, and the w<\/code> is used for age of the particle,which will be colored accordingly. I also created a vec4 buffer for attractors ,but for their w<\/strong> component is used as mass. <\/p>\n\n\n\n

In initComputeBuffers()<\/code>, I allocated and filled the position buffer with random 3D vectors using random_vector()<\/code>, and assigned a random mass (stored in the w<\/code> component). Velocities were initialized with small random values in xyz<\/code>, while the w<\/code> component was set to zero.<\/p>\n\n\n\n

To make these buffers accessible to compute shaders, I created texture buffer objects (TBOs) in initTBOs()<\/code>. Each TBO binds its corresponding buffer and exposes it to the shader as a samplerBuffer<\/code> using glTexBuffer()<\/code>.<\/p>\n\n\n\n

Rendering Points<\/strong><\/h2>\n\n\n\n

Before running any physics simulation, I started by rendering the particles as simple GL points to confirm everything was set up correctly. The vertex shader takes each particle\u2019s position (vec4<\/code>), transforms it using the mvp<\/code> matrix, and assigns a gl_PointSize<\/code> for rendering.<\/p>\n\n\n\n

#vertex shader\n#version 430\n\nlayout(location = 0) in vec4 in_position;\n\nuniform float pointSize;\nuniform mat4 mvp;\n\nvoid main()\n{\n    gl_Position = mvp * vec4(in_position.xyz, 1.0);\n    gl_PointSize = pointSize;\n}\n<\/code><\/pre>\n\n\n\n
#fragment shader\n#version 430\n\nlayout(location = 0) out vec4 color;\n\nvoid main() {\n    color = vec4(0.0, 0.8, 1.0, 1.0);\n}\n<\/code><\/pre>\n\n\n\n
At first, I couldn’t see anything on the screen. It looked like rendering was broken. After checking everything, I realized I was missing a memory barrier after the compute shader had written to the position buffer.<\/p>\n\n\n\n
Adding this line between the rendering and computing solved the problem:<\/p>\n\n\n\n
glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);<\/code><\/code><\/pre>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Simulating Particles<\/strong><\/h2>\n\n\n\n
For the particle simulation, I modified a sample compute shader from the course slides to make it fit my project\u2019s setup. The idea is simple: each particle moves under the influence of multiple attractors, and its velocity gets updated every frame. If a particle \u201cdies\u201d (based on age or going out of bounds), it respawns at the origin with a new random velocity.<\/p>\n\n\n\n
#version 430\n\nlayout(std140, binding = 0) uniform AttractorBlock {\n    vec4 attractor[12];\n};\n\nuniform int numAttractors;\nuniform vec3 origin;\n\nlayout(local_size_x = 100) in;\n\nlayout(rgba32f, binding = 0) uniform imageBuffer velocityBuffer;\nlayout(rgba32f, binding = 1) uniform imageBuffer positionBuffer;\n\nuniform float dt;\nfloat rand(vec2 co) {\n    return fract(sin(dot(co, vec2(14.9898, 78.23))) * 4378.5453);\n}\n\n\nvoid main() {\n    uint index = gl_GlobalInvocationID.x;\n\n    vec4 vel = imageLoad(velocityBuffer, int(index));\n    vec4 pos = imageLoad(positionBuffer, int(index));\n\n    pos.xyz += vel.xyz * dt;\n    pos.w -= 0.005 * dt;\n\n    for (int i = 0; i < numAttractors; i++) {\n        vec3 dist = attractor[i].xyz - pos.xyz;\n        vel.xyz += dt * dt * attractor[i].w * normalize(dist) \/ (dot(dist, dist) + 10.0);\n    }\n\n    if (pos.w <= 0.0 || pos.x < -4.0 || pos.x > 4.0 || pos.y < -2.0 || pos.y > 2.0 || pos.z < -2.0 || pos.z > 2.0) {\n        vec2 seed = vec2(float(gl_GlobalInvocationID.x), pos.w);\n        float r1 = rand(seed);\n        float r2 = rand(seed + 1.0);\n        float r3 = rand(seed + 2.0);\n\n        vel.xyz = vec3(r1, r2, r3) * 2.0 - 1.0;\n        vel.xyz *= 0.01;\n\n        pos.xyz = origin;\n        pos.w = 1.0;\n    }\n\n    imageStore(positionBuffer, int(index), pos);\n    imageStore(velocityBuffer, int(index), vel); \n}<\/code><\/pre>\n\n\n\n
Age-Based Rendering<\/strong><\/h2>\n\n\n\n
To visualize the particle \u201clifespan,\u201d I used the w<\/code> component of the position (which I treat as age) to interpolate color. As particles get older, they fade from green to red.<\/p>\n\n\n\n
#version 430\n\nlayout(location = 0) out vec4 color;\n\nin float intensity;\nvoid main() {\n   color = mix(vec4(0.0f,0.8f,0.2f,1.0f),vec4(0.8f,0.f,0.2f,1.0f),\n    intensity);\n}<\/code><\/pre>\n\n\n\n