X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?p=ld42_outofspace;a=blobdiff_plain;f=src%2Fgamescr.cc;h=d0fae08c0a0b769f94f688193200644e1fac0776;hp=26afe4224d8ef1453fa1a79c7ee2f395e810b7cc;hb=061bf9f7e4836820fe3dd3a57d0ef19abb5c7e46;hpb=b8200afc389ccca3e86463eb48c0563c0e093552 diff --git a/src/gamescr.cc b/src/gamescr.cc index 26afe42..d0fae08 100644 --- a/src/gamescr.cc +++ b/src/gamescr.cc @@ -1,20 +1,28 @@ +#include #include #include #include "game.h" #include "screen.h" #include "opengl.h" #include "texture.h" +#include "sdr.h" +#include "mesh.h" +#include "meshgen.h" /* NOTES: * - whistle hhgg music * - colliding particles merge * - select objects and center camera on them + * - tesselate only where necessary */ struct Particle { + float radius; float mass; Vec2 pos; Vec2 vel; + + Particle *next, *prev; }; struct Emitter { @@ -22,63 +30,240 @@ struct Emitter { float mass; float rate, chunk; float angle, spread; + + float spawn_pending; }; +struct Rect { + int x, y; + int width, height; +}; + +struct QuadMesh { + Vec3 *v; + Vec2 *uv; + uint16_t *idx; + + int num_verts, num_idx, num_quads; + + unsigned int vbo_v, vbo_uv, ibo; +}; #define SIM_DT 0.016 -#define GRID_SIZE 4096 -#define GRID_BITS 12 +#define GRID_SIZE 2048 +#define GRID_BITS 11 #define GRID_X(idx) (((idx) >> GRID_BITS) & (GRID_SIZE - 1)) #define GRID_Y(idx) ((idx) & (GRID_SIZE - 1)) +#define GRID_DELTA ((float)FIELD_SIZE / (float)GRID_SIZE) #define FIELD_SIZE 2048 #define MIN_CAM_DIST 1.0f #define MAX_CAM_DIST 350.0f +#define MASS_TO_RADIUS(m) log((m) + 1.0) + +#define CONTRIB_THRES 0.005 +#define CONTRIB_RANGE(m) sqrt((m) / CONTRIB_THRES) + static int pos_to_grid(float x, float y); +static Vec2 grid_to_pos(int gx, int gy); -static float grid[GRID_SIZE * GRID_SIZE]; -static Particle grid_part[GRID_SIZE * GRID_SIZE]; +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 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 std::vector emitters; +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 Particle *alloc_particle(); +void free_particle(Particle *p); +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 std::vector emitters; + +static Texture *gvis_tex; // texture tile for visualizing a grid +static unsigned int field_sdr; +static int tess_level = 32; +static float field_scale = 16.0f; + +static QuadMesh field_mesh; + +static Mesh *pmesh; +static unsigned int particle_sdr; + static float cam_theta; static float cam_dist = 100.0f; static Vec2 *targ_pos; static Mat4 view_matrix, proj_matrix; +// emitter placement data (filled by event handlers, completed in update) +static bool emit_place_pending; +static Vec2 emit_place_pos; + bool GameScreen::init() { grid_tex = new Texture; - if(!grid_tex->load("data/purple_grid.png")) { + grid_tex->create(GRID_SIZE, GRID_SIZE, TEX_2D, GL_LUMINANCE32F_ARB); + grid_tex->set_anisotropy(glcaps.max_aniso); + + gvis_tex = new Texture; + if(!gvis_tex->load("data/purple_grid.png")) { return false; } - grid_tex->set_anisotropy(glcaps.max_aniso); + gvis_tex->set_anisotropy(glcaps.max_aniso); + + unsigned int vsdr, tcsdr, tesdr, psdr; + + if(!(vsdr = load_vertex_shader("sdr/field.v.glsl")) || + !(tcsdr = load_tessctl_shader("sdr/field.tc.glsl")) || + !(tesdr = load_tesseval_shader("sdr/field.te.glsl")) || + !(psdr = load_pixel_shader("sdr/field.p.glsl"))) { + return false; + } + + if(!(field_sdr = create_program_link(vsdr, tcsdr, tesdr, psdr, 0))) { + return false; + } + set_uniform_int(field_sdr, "gvis_tex", 0); + set_uniform_int(field_sdr, "field_tex", 1); + set_uniform_float(field_sdr, "gvis_scale", FIELD_SIZE / 32.0f); + set_uniform_int(field_sdr, "tess_level", tess_level); + set_uniform_float(field_sdr, "field_scale", field_scale); + + gen_quad_plane(&field_mesh, FIELD_SIZE, FIELD_SIZE, 32, 32); + + pmesh = new Mesh; + gen_geosphere(pmesh, 1.0, 2); + + if(!(particle_sdr = create_program_load("sdr/sph.v.glsl", "sdr/sph.p.glsl"))) { + return false; + } + + // XXX DBG + emit_place_pos = Vec2(0, 0); + emit_place_pending = true; + assert(glGetError() == GL_NO_ERROR); return true; } void GameScreen::destroy() { + free_program(field_sdr); + delete gvis_tex; delete grid_tex; + destroy_quadmesh(&field_mesh); + delete pmesh; } static void simstep() { + // spawn particles + int num_emitters = emitters.size(); + for(int i=0; ispawn_pending += em->rate * SIM_DT; + while(em->spawn_pending >= 1.0f && em->mass > 0.0f) { + Vec2 pvel; // XXX calc eject velocity + + float angle = (float)rand() / (float)RAND_MAX * (M_PI * 2.0); + float emradius = MASS_TO_RADIUS(em->mass); + Vec2 ppos = em->pos + Vec2(cos(angle), sin(angle)) * emradius * 1.00001; + + float pmass = em->chunk > em->mass ? em->mass : em->chunk; + spawn_particle(ppos, pvel, pmass); + em->mass -= pmass; + + em->spawn_pending -= 1.0f; + } + } + + // remove dead emitters + std::vector::iterator it = emitters.begin(); + while(it != emitters.end()) { + Emitter *em = *it; + + if(em->mass <= 0.0f) { + printf("emitter depleted\n"); + it = emitters.erase(it); + delete em; + } else { + it++; + } + } + + // calculate gravitational field - assume field within radius constant: m / r^2 + + // first clear the field, and then add contributions + memset(grid, 0, sizeof grid); + + // contribution of emitters + for(int i=0; ipos, em->mass, &cbox); + float emradius = MASS_TO_RADIUS(em->mass); + + add_influence(em->pos, -em->mass, emradius, cbox); + } + + // contribution of particles + for(int i=0; ipos, p->mass, &cbox); + add_influence(p->pos, p->mass, p->radius, cbox); + p = p->next; + } + } + + // update texture + assert(glGetError() == GL_NO_ERROR); + grid_tex->bind(); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, GRID_SIZE, GRID_SIZE, GL_LUMINANCE, + GL_FLOAT, grid); + assert(glGetError() == GL_NO_ERROR); } static void update() { - static float interval; + if(emit_place_pending) { + emit_place_pending = false; + Emitter *em = new Emitter; + em->pos = emit_place_pos; + em->mass = 100; + em->rate = 1; + em->chunk = 0.05 * em->mass; + em->angle = -1; + em->spread = 0; + em->spawn_pending = 0; + emitters.push_back(em); + + Rect cbox; + calc_contrib_bounds(em->pos, em->mass, &cbox); + printf("bounds: %d,%d %dx%d\n", cbox.x, cbox.y, cbox.width, cbox.height); + } + // update simulation + static float interval; interval += frame_dt; if(interval >= SIM_DT) { interval -= SIM_DT; simstep(); + assert(glGetError() == GL_NO_ERROR); } // update projection matrix @@ -111,29 +296,41 @@ void GameScreen::draw() glLoadMatrixf(view_matrix[0]); glPushAttrib(GL_ENABLE_BIT); - glDisable(GL_LIGHTING); glDisable(GL_CULL_FACE); + // draw gravitational field glEnable(GL_TEXTURE_2D); - bind_texture(grid_tex); - - float maxu = FIELD_SIZE / 32.0f; - float maxv = FIELD_SIZE / 32.0f; - float hsz = FIELD_SIZE * 0.5f; - - glBegin(GL_QUADS); - glColor3f(1, 1, 1); - glTexCoord2f(0, 0); - glVertex3f(-hsz, 0, -hsz); - glTexCoord2f(maxu, 0); - glVertex3f(hsz, 0, -hsz); - glTexCoord2f(maxu, maxv); - glVertex3f(hsz, 0, hsz); - glTexCoord2f(0, maxv); - glVertex3f(-hsz, 0, hsz); - glEnd(); + bind_texture(gvis_tex, 0); + bind_texture(grid_tex, 1); + + glUseProgram(field_sdr); + glPatchParameteri(GL_PATCH_VERTICES, 4); + draw_quadmesh(&field_mesh, GL_PATCHES); + + // draw particles + glUseProgram(particle_sdr); + + for(int i=0; ipos.x, p->pos.y); + + glPushMatrix(); + glTranslatef(p->pos.x, -grid[gidx] * field_scale, p->pos.y); + glScalef(p->radius, p->radius, p->radius); + + pmesh->draw(); + + glPopMatrix(); + p = p->next; + } + } + + glUseProgram(0); glPopAttrib(); + + assert(glGetError() == GL_NO_ERROR); } void GameScreen::reshape(int x, int y) @@ -150,6 +347,39 @@ void GameScreen::keyboard(int key, bool pressed) pop_screen(); break; + case ']': + if(tess_level < glcaps.max_tess_level) { + tess_level++; + printf("tessellation level: %d\n", tess_level); + set_uniform_int(field_sdr, "tess_level", tess_level); + glUseProgram(0); + } + break; + + case '[': + if(tess_level > 1) { + tess_level--; + printf("tessellation level: %d\n", tess_level); + set_uniform_int(field_sdr, "tess_level", tess_level); + glUseProgram(0); + } + break; + + case '=': + field_scale += 0.5; + printf("field scale: %f\n", field_scale); + set_uniform_float(field_sdr, "field_scale", field_scale); + break; + + case '-': + field_scale -= 0.5; + if(field_scale < 0.0f) { + field_scale = 0.0f; + } + printf("field scale: %f\n", field_scale); + set_uniform_float(field_sdr, "field_scale", field_scale); + break; + default: break; } @@ -182,3 +412,241 @@ void GameScreen::mwheel(int dir, int x, int y) if(cam_dist <= MIN_CAM_DIST) cam_dist = MIN_CAM_DIST; if(cam_dist > MAX_CAM_DIST) cam_dist = MAX_CAM_DIST; } + + +static int pos_to_grid(float x, float y) +{ + int gx = ((x / (float)FIELD_SIZE) + 0.5f) * (float)GRID_SIZE; + int gy = ((y / (float)FIELD_SIZE) + 0.5f) * (float)GRID_SIZE; + + if(gx < 0) gx = 0; + if(gx >= GRID_SIZE) gx = GRID_SIZE - 1; + if(gy < 0) gy = 0; + if(gy >= GRID_SIZE) gy = GRID_SIZE - 1; + + return (gx << GRID_BITS) | gy; +} + +static Vec2 grid_to_pos(int gx, int gy) +{ + float x = (((float)gx / (float)GRID_SIZE) - 0.5f) * (float)FIELD_SIZE; + float y = (((float)gy / (float)GRID_SIZE) - 0.5f) * (float)FIELD_SIZE; + + return Vec2(x, y); +} + +static void calc_contrib_bounds(const Vec2 &pos, float mass, Rect *rect) +{ + int gidx = pos_to_grid(pos.x, pos.y); + int gx = GRID_X(gidx); + int gy = GRID_Y(gidx); + int maxrange = (int)ceil(CONTRIB_RANGE(mass)); + + int sx = gx - maxrange; + int sy = gy - maxrange; + int ex = gx + maxrange; + int ey = gy + maxrange; + + if(ex > GRID_SIZE) ex = GRID_SIZE; + if(ey > GRID_SIZE) ey = GRID_SIZE; + + rect->x = sx < 0 ? 0 : sx; + rect->y = sy < 0 ? 0 : sy; + rect->width = ex - sx; + rect->height = ey - sy; +} + +static void add_influence(const Vec2 &pos, float mass, float radius, const Rect &cbox) +{ + float *gptr = grid + cbox.y * GRID_SIZE + cbox.x; + Vec2 startpos = grid_to_pos(cbox.x, cbox.y); + + for(int y=0; yvbo_v); + glDeleteBuffers(1, &m->vbo_uv); + glDeleteBuffers(1, &m->ibo); + + delete [] m->v; + delete [] m->uv; + delete [] m->idx; +} + +static void draw_quadmesh(const QuadMesh *m, unsigned int prim) +{ + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + + glBindBuffer(GL_ARRAY_BUFFER, m->vbo_v); + glVertexPointer(3, GL_FLOAT, 0, 0); + + glBindBuffer(GL_ARRAY_BUFFER, m->vbo_uv); + glTexCoordPointer(2, GL_FLOAT, 0, 0); + + glBindBuffer(GL_ARRAY_BUFFER, 0); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->ibo); + glDrawElements(prim, m->num_idx, GL_UNSIGNED_SHORT, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + + glDisableClientState(GL_VERTEX_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); +} + +static void gen_quad_plane(QuadMesh *m, float width, float height, int usub, int vsub) +{ + Vec3 *vptr; + Vec2 *uvptr; + uint16_t *iptr; + + if(usub < 1) usub = 1; + if(vsub < 1) vsub = 1; + + int uverts = usub + 1; + int vverts = vsub + 1; + m->num_verts = uverts * vverts; + m->num_quads = usub * vsub; + m->num_idx = m->num_quads * 4; + + vptr = m->v = new Vec3[m->num_verts]; + uvptr = m->uv = new Vec2[m->num_verts]; + iptr = m->idx = new uint16_t[m->num_idx]; + + float du = 1.0f / (float)usub; + float dv = 1.0f / (float)vsub; + + float u = 0.0f; + for(int i=0; ivbo_v); + glBindBuffer(GL_ARRAY_BUFFER, m->vbo_v); + glBufferData(GL_ARRAY_BUFFER, m->num_verts * 3 * sizeof(float), m->v, GL_STATIC_DRAW); + + glGenBuffers(1, &m->vbo_uv); + glBindBuffer(GL_ARRAY_BUFFER, m->vbo_uv); + glBufferData(GL_ARRAY_BUFFER, m->num_verts * 2 * sizeof(float), m->uv, GL_STATIC_DRAW); + + glGenBuffers(1, &m->ibo); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->ibo); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, m->num_idx * sizeof(uint16_t), m->idx, GL_STATIC_DRAW); + + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); +} + +static void spawn_particle(const Vec2 &pos, const Vec2 &vel, float mass) +{ + int gidx = pos_to_grid(pos.x, pos.y); + + if(grid_part[gidx]) { + // merge with existing + Particle *p = grid_part[gidx]; + p->vel += vel; + p->mass += mass; + p->radius = MASS_TO_RADIUS(p->mass); + + } else { + Particle *p = alloc_particle(); + p->pos = pos; + p->vel = vel; + p->mass = mass; + p->radius = MASS_TO_RADIUS(mass); + grid_part[gidx] = p; + + add_particle(p, gidx); + } +} + +static void add_particle(Particle *p, int grid_idx) +{ + int listidx = GRID_IDX_PLIST(grid_idx); + p->next = plist[listidx]; + p->prev = 0; + plist[listidx] = p; +} + +static void remove_particle(Particle *p, int grid_idx) +{ + Particle *prev = p->prev; + Particle *next = p->next; + + p->prev = p->next = 0; + if(next) next->prev = prev; + + if(prev) { + prev->next = next; + } else { + int listidx = GRID_IDX_PLIST(grid_idx); + plist[listidx] = next; + } +} + +// particle allocator +#define MAX_PFREE_SIZE 256 +static Particle *pfree_list; +static int pfree_size; + +static Particle *alloc_particle() +{ + if(pfree_list) { + Particle *p = pfree_list; + pfree_list = pfree_list->next; + pfree_size--; + return p; + } + + return new Particle; +} + +void free_particle(Particle *p) +{ + if(pfree_size < MAX_PFREE_SIZE) { + p->next = pfree_list; + p->prev = 0; + pfree_list = p; + pfree_size++; + } else { + delete p; + } +}