X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?p=ld42_outofspace;a=blobdiff_plain;f=src%2Fgamescr.cc;h=4bac184a9f8fe7fa8cbeee8d00f9ece739c9ed67;hp=d0fae08c0a0b769f94f688193200644e1fac0776;hb=d0367d9119f81afd77045481b9e53d5a17b89a73;hpb=061bf9f7e4836820fe3dd3a57d0ef19abb5c7e46 diff --git a/src/gamescr.cc b/src/gamescr.cc index d0fae08..4bac184 100644 --- a/src/gamescr.cc +++ b/src/gamescr.cc @@ -8,12 +8,12 @@ #include "sdr.h" #include "mesh.h" #include "meshgen.h" +#include "goatkit/goatkit.h" /* NOTES: * - whistle hhgg music - * - colliding particles merge * - select objects and center camera on them - * - tesselate only where necessary + * - we need to rely on actual collisions instead of grid occupancy */ struct Particle { @@ -22,6 +22,8 @@ struct Particle { Vec2 pos; Vec2 vel; + float vis_height; + Particle *next, *prev; }; @@ -66,35 +68,45 @@ struct QuadMesh { #define CONTRIB_THRES 0.005 #define CONTRIB_RANGE(m) sqrt((m) / CONTRIB_THRES) +/* gravitational strength */ +#define GRAV_STR 16.0f + +#define INIT_MASS_BUDGET 600.0f +#define EM_MASS_DEFAULT 100.0f + +static int pos_to_grid_x_noclamp(float x); +static int pos_to_grid_y_noclamp(float y); static int pos_to_grid(float x, float y); 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); +static bool pause; + 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 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; @@ -102,15 +114,32 @@ static QuadMesh field_mesh; static Mesh *pmesh; static unsigned int particle_sdr; +static Vec2 cam_pos; static float cam_theta; static float cam_dist = 100.0f; -static Vec2 *targ_pos; +static Vec2 *targ_pos = &cam_pos; static Mat4 view_matrix, proj_matrix; +static bool wireframe; +static int mouse_x, mouse_y; + // emitter placement data (filled by event handlers, completed in update) static bool emit_place_pending; static Vec2 emit_place_pos; +static bool placing_emitter; + +static float mass_left; + +// UI +static void ui_handler(goatkit::Widget *w, const goatkit::Event &ev, void *cls); +static int ui_virt_width = 800; +static int ui_virt_height = 600; +static goatkit::Screen *ui; +static goatkit::Button *bn_emitter; +static goatkit::Slider *slider_mass; +static bool mouse_over_ui; + bool GameScreen::init() { @@ -151,9 +180,28 @@ bool GameScreen::init() return false; } - // XXX DBG - emit_place_pos = Vec2(0, 0); - emit_place_pending = true; + mass_left = INIT_MASS_BUDGET; + + ui = new goatkit::Screen; + ui->hide(); + + bn_emitter = new goatkit::Button; + bn_emitter->set_position(5, 5); + bn_emitter->set_size(250, 30); + bn_emitter->set_text("new white hole"); + bn_emitter->set_callback(goatkit::EV_CLICK, ui_handler); + ui->add_widget(bn_emitter); + + slider_mass = new goatkit::Slider; + slider_mass->set_position(300, 5); + slider_mass->set_size(400, 30); + slider_mass->set_continuous_change(false); + slider_mass->set_range(0, mass_left); + slider_mass->set_value(EM_MASS_DEFAULT); + slider_mass->set_callback(goatkit::EV_CHANGE, ui_handler); + ui->add_widget(slider_mass); + + ui->set_visibility_transition(300); assert(glGetError() == GL_NO_ERROR); return true; @@ -166,10 +214,104 @@ void GameScreen::destroy() delete grid_tex; destroy_quadmesh(&field_mesh); delete pmesh; + + delete bn_emitter; +} + +void GameScreen::start() +{ + ui->show(); + slider_mass->hide(); +} + +void GameScreen::stop() +{ } static void simstep() { + if(pause) return; + + // distribute forces + Particle *p = plist; + while(p) { + int num_emitters = emitters.size(); + for(int i=0; ipos - em->pos; + p->vel += dir * em->mass * GRAV_STR * 0.01 / dot(dir, dir) * SIM_DT; + } + + Particle *q = plist; + while(q) { + if(p != q) { + Vec2 dir = q->pos - p->pos; + float accel = GRAV_STR * q->mass / dot(dir, dir); + p->vel += dir * accel * SIM_DT; + } + q = q->next; + } + p = p->next; + } + + // move existing particles + 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) * GRAV_STR; + + //p->vel += grad * SIM_DT; + p->pos += p->vel * SIM_DT; + + // if it moved outside of the simulation field, remove it + int gx = pos_to_grid_x_noclamp(p->pos.x); + int gy = pos_to_grid_y_noclamp(p->pos.y); + if(gx < 0 || gx >= GRID_SIZE || gy < 0 || gy >= GRID_SIZE) { + Particle *next = p->next; + grid_part[gidx] = 0; + remove_particle(p); + free_particle(p); + p = next; + continue; + } + + // 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; ipos, 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 @@ -240,18 +379,41 @@ static void simstep() static void update() { + if(placing_emitter) { + float x = (float)mouse_x / (float)win_width; + float y = 1.0f - (float)mouse_y / (float)win_height; + Ray pick_ray = mouse_pick_ray(x, y, view_matrix, proj_matrix); + + float ndotdir = pick_ray.dir.y; + if(fabs(ndotdir) > 1e-6f) { + float ndotpdir = -pick_ray.origin.y; + float t = ndotpdir / ndotdir; + + x = pick_ray.origin.x + pick_ray.dir.x * t; + y = pick_ray.origin.z + pick_ray.dir.z * t; + + if(x >= -FIELD_SIZE / 2 && x < FIELD_SIZE / 2 && + y >= -FIELD_SIZE / 2 && y < FIELD_SIZE / 2) { + emit_place_pos = Vec2(x, y); + } + } + } + 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->mass = slider_mass->get_value(); + em->rate = 10; + em->chunk = 0.001 * em->mass; em->angle = -1; em->spread = 0; em->spawn_pending = 0; emitters.push_back(em); + mass_left -= em->mass; + if(mass_left < 0.0f) mass_left = 0.0f; + 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); @@ -295,11 +457,17 @@ void GameScreen::draw() glMatrixMode(GL_MODELVIEW); glLoadMatrixf(view_matrix[0]); - glPushAttrib(GL_ENABLE_BIT); - glDisable(GL_CULL_FACE); - // draw gravitational field - glEnable(GL_TEXTURE_2D); + if(wireframe) { + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + + float amb[] = {0.5, 0.5, 0.5, 1.0}; + glLightModelfv(GL_LIGHT_MODEL_AMBIENT, amb); + } else { + float amb[] = {0.01, 0.01, 0.01, 1.0}; + glLightModelfv(GL_LIGHT_MODEL_AMBIENT, amb); + } + bind_texture(gvis_tex, 0); bind_texture(grid_tex, 1); @@ -307,34 +475,70 @@ void GameScreen::draw() glPatchParameteri(GL_PATCH_VERTICES, 4); draw_quadmesh(&field_mesh, GL_PATCHES); + if(wireframe) { + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + } + // draw particles glUseProgram(particle_sdr); - for(int i=0; ipos.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); - glPopAttrib(); + // draw emitter placement marker if we are in placement mode + if(placing_emitter && !mouse_over_ui) { + glPushMatrix(); + glTranslatef(emit_place_pos.x, 0, emit_place_pos.y); + + glBegin(GL_LINES); + glColor3f(0, 1, 0); + glVertex3f(0, -1000, 0); + glVertex3f(0, 1000, 0); + glEnd(); + + float s = MASS_TO_RADIUS(slider_mass->get_value()); + if(s < 0.1) s = 0.1; + glScalef(s, s, s); + + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + pmesh->draw(); + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + + glPopMatrix(); + } + + // draw the UI + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, ui_virt_width, ui_virt_height, 0, -1, 1); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + ui->draw(); + assert(glGetError() == GL_NO_ERROR); } void GameScreen::reshape(int x, int y) { + ui_virt_width = x; + ui_virt_height = y; + ui->set_size(ui_virt_width, ui_virt_height); } @@ -380,26 +584,59 @@ void GameScreen::keyboard(int key, bool pressed) set_uniform_float(field_sdr, "field_scale", field_scale); break; + case 'w': + wireframe = !wireframe; + break; + + case ' ': + pause = !pause; + break; + default: break; } } } -static int prev_x, prev_y; +#define UI_HEIGHT 50 void GameScreen::mbutton(int bn, bool pressed, int x, int y) { - prev_x = x; - prev_y = y; + mouse_x = x; + mouse_y = y; + + mouse_over_ui = y < UI_HEIGHT; + + ui->sysev_mouse_button(bn, pressed, x * ui_virt_width / win_width, + y * ui_virt_height / win_height); + + if(placing_emitter && bn == 0 && pressed && !mouse_over_ui) { + emit_place_pending = true; + placing_emitter = false; + slider_mass->hide(); + } } void GameScreen::mmotion(int x, int y) { - int dx = x - prev_x; - int dy = y - prev_y; - prev_x = x; - prev_y = y; + int dx = x - mouse_x; + int dy = y - mouse_y; + mouse_x = x; + mouse_y = y; + + mouse_over_ui = y < UI_HEIGHT; + + ui->sysev_mouse_motion(x * ui_virt_width / win_width, y * ui_virt_height / win_height); + if(ui->get_mouse_grab()) { + return; + } + + if(game_bnstate(0)) { + float pan_speed = pow(cam_dist, 1.5) * 0.00035; // magic + Vec2 dir = rotate(Vec2(dx, dy) * pan_speed, deg_to_rad(cam_theta)); + cam_pos.x -= dir.x; + cam_pos.y -= dir.y; + } if(game_bnstate(2)) { cam_theta += dx * 0.5; @@ -413,11 +650,42 @@ void GameScreen::mwheel(int dir, int x, int y) if(cam_dist > MAX_CAM_DIST) cam_dist = MAX_CAM_DIST; } +static void ui_handler(goatkit::Widget *w, const goatkit::Event &ev, void *cls) +{ + if(w == bn_emitter) { + if(placing_emitter) { + placing_emitter = false; + slider_mass->hide(); + } else { + if(mass_left > 0.0f) { + placing_emitter = true; + slider_mass->set_range(0, mass_left); + slider_mass->set_value(mass_left >= EM_MASS_DEFAULT ? EM_MASS_DEFAULT : mass_left); + slider_mass->show(); + } + } + return; + } + + if(w == slider_mass) { + printf("foo: %f\n", slider_mass->get_value()); + } +} + +static int pos_to_grid_x_noclamp(float x) +{ + return ((x / (float)FIELD_SIZE) + 0.5f) * (float)GRID_SIZE; +} + +static int pos_to_grid_y_noclamp(float y) +{ + return ((y / (float)FIELD_SIZE) + 0.5f) * (float)GRID_SIZE; +} 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; + int gx = pos_to_grid_x_noclamp(x); + int gy = pos_to_grid_y_noclamp(y); if(gx < 0) gx = 0; if(gx >= GRID_SIZE) gx = GRID_SIZE - 1; @@ -480,6 +748,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) { @@ -549,9 +835,9 @@ static void gen_quad_plane(QuadMesh *m, float width, float height, int usub, int int idx = i * vverts + j; *iptr++ = idx; - *iptr++ = idx + vverts; - *iptr++ = idx + vverts + 1; *iptr++ = idx + 1; + *iptr++ = idx + vverts + 1; + *iptr++ = idx + vverts; } v += dv; @@ -594,32 +880,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