Finished shader; split to targets cpu, opengl and vulkan

shaders/ComputeShader.glsl

@@ -1,64 +0,0 @@
-#version 460 core
-#extension GL_ARB_compute_shader : enable
-#extension GL_ARB_shader_storage_buffer_object : enable
-
-struct particle
-{
-    vec3  pos;
-    vec3  vel;
-    vec3  col;
-    float age;
-};
-
-layout(std430, binding = 0) buffer particles
-{
-    particle p[];
-};
-
-uniform float dt;
-uniform vec3 resetPos;
-uniform uint seed;
-
-layout (local_size_x = 256, local_size_y = 1, local_size_z = 1) in;
-
-float rand()
-{
-    uint seedR;
-    seedR = (seed * 1103515245u + 12345u);
-    return float(seed) / 4294967296.0;
-}
-
-vec3 rand3() {
-    vec3 result;
-    uint seedR;
-    seedR = (seed * 1103515245u + 12345u);
-    result.x = float(seed);
-    seedR = (seed * 1103515245u + 12345u);
-    result.y = float(seed);
-    seedR = (seed * 1103515245u + 12345u);
-    result.z = float(seed);
-    return (result / 2147483648.0) - vec3(1,1,1);
-}
-
-void main()
-{
-    uint gid = gl_GlobalInvocationID.x;
-    particle part = p[gid];
-
-    if (part.age < 0 || part.pos.x > 1 || part.pos.y > 1 || part.pos.z > 1
-        || part.pos.x < -1 || part.pos.y < -1 || part.pos.z < -1 )
-    {
-        part.pos = resetPos;
-        part.vel = rand3();
-        part.col = vec3(rand(), rand(), rand());
-        part.age = rand() * 0x7fff * 0.01f;
-
-    }
-    else
-    {
-        part.pos += part.vel * dt;
-        part.age -= 0.01f;
-    }
-
-    p[gid] = part;
-}

shaders/FragmentShader.glsl

@@ -1,9 +0,0 @@
-#version 460 core
-
-in vec3 colV;
-out vec4 colOut;
-
-void main(void)
-{
-    colOut = vec4(colV, 1);
-}

shaders/GeometryShader.glsl

@@ -1,12 +0,0 @@
-#version 460 core
-
-layout(points) in;
-layout(points, max_vertices = 256) out;
-
-in vec3 colV;
-out vec3 colG;
-
-void main(void)
-{
-    colG = colV;
-}

shaders/RenderShader.glsl

@@ -1,30 +0,0 @@
-#version 460 core
-
-layout (points) in;
-layout (points) out;
-layout (max_vertices = 40) out;
-
-in vec3 pos0[];
-in vec3 vel0[];
-in vec3 col0[];
-in float age0[];
-
-out vec3 posOut;
-out vec3 velOut;
-out vec3 colOut;
-out float ageOut;
-
-void main()
-{
-    if (age0[0] < 0)
-    {
-        posOut = vec3(0, 0, 0);
-    }
-    else
-    {
-        posOut = pos0[0];
-        velOut = vel0[0];
-        colOut = col0[0];
-        ageOut = age0[0] - 0.01f;
-    }
-}

shaders/UpdateShader.glsl

@@ -1,19 +0,0 @@
-#version 460 core
-
-layout (location = 0) in vec3 pos;   // the position variable has attribute position 0
-layout (location = 1) in vec3 vel; // the velocity variable has attribute position 1
-layout (location = 2) in vec3 col; // the color variable has attribute position 2
-layout (location = 3) in float age; // the age variable has attribute position 3
-
-out vec3 pos0;
-out vec3 vel0;
-out vec3 col0;
-out float age0;
-
-void main()
-{
-    pos0 = pos;
-    vel0 = vel;
-    col0 = col;
-    age0 = age;
-}

shaders/opengl/ComputeShader.glsl

@@ -0,0 +1,87 @@
+#version 460
+
+#define FLOAT_MAX 4294967296.0f
+
+struct particle
+{
+    float px, py, pz;
+    float vx, vy, vz;
+    float cx, cy, cz;
+    float age;
+};
+
+layout(std430, binding = 0) buffer particles
+{
+    particle p[];
+};
+
+layout(location = 0) uniform float dt;
+layout(location = 1) uniform vec3 resetPos;
+layout(location = 2) uniform uint maxParticles;
+
+layout (local_size_x = 256, local_size_y = 1, local_size_z = 1) in;
+
+uint hash(uvec3 seed)
+{
+    uint hash;
+    hash = (seed.x ^ 61u) ^ (seed.y >> 16u);
+    hash *= 9u;
+    hash = seed.z ^ (seed.x >> 4u);
+    hash *= 0x27d4eb2du;
+    hash = seed.y ^ (seed.z >> 15u);
+    return hash;
+}
+
+uint rand(uint seed)
+{
+    // Xorshift algorithm from George Marsaglia's paper
+    seed ^= (seed << 13u);
+    seed ^= (seed >> 17u);
+    seed ^= (seed << 5u);
+    return seed;
+}
+
+void main()
+{
+    uint gid = gl_GlobalInvocationID.x;
+
+    if (gid <= maxParticles)
+    {
+        particle part = p[gid];
+
+        uint hash1 = hash(uvec3(uint(part.px * FLOAT_MAX), uint(part.cy * FLOAT_MAX), uint(part.vz * FLOAT_MAX)));
+        uint hash2 = hash(uvec3(uint(part.vx * FLOAT_MAX), uint(part.py * FLOAT_MAX), uint(part.cz * FLOAT_MAX)));
+        uint hash3 = hash(uvec3(uint(part.cx * FLOAT_MAX), uint(part.vy * FLOAT_MAX), uint(part.pz * FLOAT_MAX)));
+
+        if (part.age < 0 || part.px > 1 || part.py > 1 || part.pz > 1 || part.px < -1 || part.py < -1 || part.pz < -1)
+        {
+            part.px = resetPos.x;
+            part.py = resetPos.y;
+            part.pz = resetPos.z;
+
+            part.age = rand(hash(uvec3(hash1, hash2, hash3))) % (250 - 60 + 1) + 60;
+
+            part.vx = (rand(hash1) % 2 == 0 ? 1 : -1) * float(rand(hash2)) * (1.0f / FLOAT_MAX);
+            part.vy = (rand(hash3) % 2 == 0 ? -1 : 1) * float(rand(hash1)) * (1.0f / FLOAT_MAX);
+            part.vz = (rand(hash2) % 2 == 0 ? 1 : -1) * float(rand(hash3)) * (1.0f / FLOAT_MAX);
+
+            part.cx = float(rand(hash1)) * (1.0f / FLOAT_MAX);
+            part.cy = float(rand(hash1)) * (1.0f / FLOAT_MAX);
+            part.cz = float(rand(hash1)) * (1.0f / FLOAT_MAX);
+        }
+        else
+        {
+            part.px += part.vx * dt;
+            part.py += part.vy * dt;
+            part.pz += part.vz * dt;
+
+            part.cx = float(rand(hash1)) * (1.0f / FLOAT_MAX);
+            part.cy = float(rand(hash1)) * (1.0f / FLOAT_MAX);
+            part.cz = float(rand(hash1)) * (1.0f / FLOAT_MAX);
+
+            part.age -= 0.01f;
+        }
+
+        p[gid] = part;
+    }
+}

shaders/opengl/VertexShader.glsl

@@ -1,9 +1,9 @@
-#version 460 core
+#version 460
 
 layout(location = 0) in vec3 pos;
 layout(location = 1) in vec3 colIn;
 
-out vec3 colV;
+layout(location = 0) out vec3 colV;
 
 void main(void)
 {