the universe is fucked

diff --git a/sdr/field.p.glsl b/sdr/field.p.glsl
index e14ba6f..b021a55 100644 (file)
--- a/sdr/field.p.glsl
+++ b/sdr/field.p.glsl
@@ -1,13 +1,15 @@
 #version 410 compatibility
 
-uniform sampler2D gvis_tex;
+uniform sampler2D gvis_tex, field_tex;
 uniform float gvis_scale;
 
 void main()
 {
-       vec2 uv = gl_TexCoord[0].st * vec2(gvis_scale, gvis_scale);
+       vec2 uv = gl_TexCoord[0].st * vec2(gvis_scale, gvis_scale) * 10.0;
        vec3 gridcol = texture2D(gvis_tex, uv).rgb;
 
-       gl_FragColor.rgb = gridcol.rgb;
+       float foo = texture2D(field_tex, gl_TexCoord[0].st).x;
+
+       gl_FragColor.rgb = gridcol.rgb + vec3(0.0, foo, 0.0);
        gl_FragColor.a = 1.0;
 }

diff --git a/src/gamescr.cc b/src/gamescr.cc
index d0fae08..abd7865 100644 (file)
--- a/src/gamescr.cc
+++ b/src/gamescr.cc
@@ -22,6 +22,8 @@ struct Particle {
        Vec2 pos;
        Vec2 vel;
 
+       float vis_height;
+
        Particle *next, *prev;
 };
 
@@ -72,13 +74,15 @@ static Vec2 grid_to_pos(int gx, int gy);
 static void calc_contrib_bounds(const Vec2 &pos, float mass, Rect *rect);
 static void add_influence(const Vec2 &pos, float mass, float radius, const Rect &cbox);
 
+static Vec2 calc_field_grad(int gidx);
+
 static void destroy_quadmesh(QuadMesh *m);
 static void draw_quadmesh(const QuadMesh *m, unsigned int prim = GL_QUADS);
 static void gen_quad_plane(QuadMesh *mesh, float width, float height, int usub, int vsub);
 
 static void spawn_particle(const Vec2 &pos, const Vec2 &vel, float mass);
-static void add_particle(Particle *p, int grid_idx);
-static void remove_particle(Particle *p, int grid_idx);
+static void add_particle(Particle *p);
+static void remove_particle(Particle *p);
 static Particle *alloc_particle();
 void free_particle(Particle *p);
 
@@ -86,15 +90,13 @@ static float grid[GRID_SIZE * GRID_SIZE];
 static Particle *grid_part[GRID_SIZE * GRID_SIZE];
 static Texture *grid_tex;
 
-#define NUM_PARTICLE_LISTS     16
-static Particle *plist[NUM_PARTICLE_LISTS];
-#define GRID_IDX_PLIST(idx)    ((idx) * NUM_PARTICLE_LISTS / (GRID_SIZE * GRID_SIZE))
+static Particle *plist;
 
 static std::vector<Emitter*> emitters;
 
 static Texture *gvis_tex;      // texture tile for visualizing a grid
 static unsigned int field_sdr;
-static int tess_level = 32;
+static int tess_level = 64;
 static float field_scale = 16.0f;
 
 static QuadMesh field_mesh;
@@ -170,6 +172,52 @@ void GameScreen::destroy()
 
 static void simstep()
 {
+       // move existing particles
+       Particle *p = plist;
+       while(p) {
+               // calculate the field gradient at the particle position
+               int gidx = pos_to_grid(p->pos.x, p->pos.y);
+               Vec2 grad = calc_field_grad(gidx);
+
+               p->vel += grad * SIM_DT;
+               p->pos += p->vel * SIM_DT;
+
+               // find the grid cell it's moving to
+               int gidx_next = pos_to_grid(p->pos.x, p->pos.y);
+               p->vis_height = 0.0f;//-grid[gidx_next] * field_scale;
+
+               if(gidx_next == gidx) {
+                       p = p->next;
+                       continue;
+               }
+
+               Particle *destp = grid_part[gidx_next];
+               if(destp) {
+                       assert(destp != p);
+                       // another particle at the destination, merge them
+                       destp->vel += p->vel;
+                       destp->mass += p->mass;
+                       destp->radius = MASS_TO_RADIUS(destp->mass);
+
+                       // ... and remove it
+                       grid_part[gidx] = 0;
+                       Particle *next = p->next;
+                       remove_particle(p);
+                       free_particle(p);
+                       p = next;
+               } else {
+                       // destination is empty, go there
+                       if(gidx != gidx_next) {
+                               grid_part[gidx] = 0;
+                               grid_part[gidx_next] = p;
+                       }
+
+                       p = p->next;
+               }
+       }
+
+       // TODO destroy particles which left the simulation field
+
        // spawn particles
        int num_emitters = emitters.size();
        for(int i=0; i<num_emitters; i++) {
@@ -205,7 +253,6 @@ static void simstep()
        }
 
        // calculate gravitational field - assume field within radius constant: m / r^2
-
        // first clear the field, and then add contributions
        memset(grid, 0, sizeof grid);
 
@@ -220,14 +267,12 @@ static void simstep()
        }
 
        // contribution of particles
-       for(int i=0; i<NUM_PARTICLE_LISTS; i++) {
-               Particle *p = plist[i];
-               while(p) {
-                       Rect cbox;
-                       calc_contrib_bounds(p->pos, p->mass, &cbox);
-                       add_influence(p->pos, p->mass, p->radius, cbox);
-                       p = p->next;
-               }
+       p = plist;
+       while(p) {
+               Rect cbox;
+               calc_contrib_bounds(p->pos, p->mass, &cbox);
+               add_influence(p->pos, p->mass, p->radius, cbox);
+               p = p->next;
        }
 
        // update texture
@@ -245,8 +290,8 @@ static void update()
                Emitter *em = new Emitter;
                em->pos = emit_place_pos;
                em->mass = 100;
-               em->rate = 1;
-               em->chunk = 0.05 * em->mass;
+               em->rate = 10;
+               em->chunk = 0.01 * em->mass;
                em->angle = -1;
                em->spread = 0;
                em->spawn_pending = 0;
@@ -310,20 +355,18 @@ void GameScreen::draw()
        // draw particles
        glUseProgram(particle_sdr);
 
-       for(int i=0; i<NUM_PARTICLE_LISTS; i++) {
-               Particle *p = plist[i];
-               while(p) {
-                       int gidx = pos_to_grid(p->pos.x, p->pos.y);
+       Particle *p = plist;
+       while(p) {
+               int gidx = pos_to_grid(p->pos.x, p->pos.y);
 
-                       glPushMatrix();
-                       glTranslatef(p->pos.x, -grid[gidx] * field_scale, p->pos.y);
-                       glScalef(p->radius, p->radius, p->radius);
+               glPushMatrix();
+               glTranslatef(p->pos.x, p->vis_height, p->pos.y);
+               glScalef(p->radius, p->radius, p->radius);
 
-                       pmesh->draw();
+               pmesh->draw();
 
-                       glPopMatrix();
-                       p = p->next;
-               }
+               glPopMatrix();
+               p = p->next;
        }
 
        glUseProgram(0);
@@ -480,6 +523,24 @@ static void add_influence(const Vec2 &pos, float mass, float radius, const Rect
        }
 }
 
+static Vec2 calc_field_grad(int gidx)
+{
+       int gx = GRID_X(gidx);
+       int gy = GRID_Y(gidx);
+
+       int nidx = ((gx + 1 >= GRID_SIZE ? gx : gx + 1) << GRID_BITS) | gy;
+       int pidx = ((gx > 0 ? gx - 1 : gx) << GRID_BITS) | gy;
+       float dfdx = grid[nidx] - grid[pidx];
+
+       nidx = (gx << GRID_BITS) | (gy + 1 >= GRID_SIZE ? gy : gy + 1);
+       pidx = (gx << GRID_BITS) | (gy > 0 ? gy - 1 : gy);
+       float dfdy = grid[nidx] - grid[pidx];
+
+       return Vec2(dfdx, dfdy);
+}
+
+
+// ---- quad mesh operations ----
 
 static void destroy_quadmesh(QuadMesh *m)
 {
@@ -594,32 +655,34 @@ static void spawn_particle(const Vec2 &pos, const Vec2 &vel, float mass)
                p->radius = MASS_TO_RADIUS(mass);
                grid_part[gidx] = p;
 
-               add_particle(p, gidx);
+               add_particle(p);
        }
 }
 
-static void add_particle(Particle *p, int grid_idx)
+static void add_particle(Particle *p)
 {
-       int listidx = GRID_IDX_PLIST(grid_idx);
-       p->next = plist[listidx];
+       if(plist) plist->prev = p;
+
+       p->next = plist;
        p->prev = 0;
-       plist[listidx] = p;
+       plist = p;
 }
 
-static void remove_particle(Particle *p, int grid_idx)
+static void remove_particle(Particle *p)
 {
-       Particle *prev = p->prev;
-       Particle *next = p->next;
-
-       p->prev = p->next = 0;
-       if(next) next->prev = prev;
+       assert(plist->prev == 0);
 
-       if(prev) {
-               prev->next = next;
-       } else {
-               int listidx = GRID_IDX_PLIST(grid_idx);
-               plist[listidx] = next;
+       if(plist == p) {
+               assert(p->prev == 0);
+               plist = p->next;
+       }
+       if(p->prev) {
+               p->prev->next = p->next;
        }
+       if(p->next) {
+               p->next->prev = p->prev;
+       }
+       p->prev = p->next = 0;
 }
 
 // particle allocator