3 #include <gmath/gmath.h>
11 * - whistle hhgg music
12 * - colliding particles merge
13 * - select objects and center camera on them
40 int num_verts, num_idx, num_quads;
42 unsigned int vbo_v, vbo_uv, ibo;
47 #define GRID_SIZE 2048
49 #define GRID_X(idx) (((idx) >> GRID_BITS) & (GRID_SIZE - 1))
50 #define GRID_Y(idx) ((idx) & (GRID_SIZE - 1))
51 #define GRID_DELTA ((float)FIELD_SIZE / (float)GRID_SIZE)
53 #define FIELD_SIZE 2048
54 #define MIN_CAM_DIST 1.0f
55 #define MAX_CAM_DIST 350.0f
57 #define MASS_TO_RAD(m) log((m) + 1.0)
59 #define CONTRIB_THRES 0.005
60 #define CONTRIB_RANGE(m) sqrt((m) / CONTRIB_THRES)
62 static int pos_to_grid(float x, float y);
63 static Vec2 grid_to_pos(int gx, int gy);
65 static void destroy_quadmesh(QuadMesh *m);
66 static void draw_quadmesh(const QuadMesh *m, unsigned int prim = GL_QUADS);
67 static void gen_quad_plane(QuadMesh *mesh, float width, float height, int usub, int vsub);
69 static float grid[GRID_SIZE * GRID_SIZE];
70 static Particle grid_part[GRID_SIZE * GRID_SIZE];
71 static Texture *grid_tex;
73 static std::vector<Emitter*> emitters;
75 static Texture *gvis_tex; // texture tile for visualizing a grid
76 static unsigned int field_sdr;
77 static int tess_level = 32;
78 static float field_scale = 16.0f;
80 static QuadMesh field_mesh;
82 static float cam_theta;
83 static float cam_dist = 100.0f;
84 static Vec2 *targ_pos;
85 static Mat4 view_matrix, proj_matrix;
87 // emitter placement data (filled by event handlers, completed in update)
88 static bool emit_place_pending;
89 static Vec2 emit_place_pos;
92 bool GameScreen::init()
94 grid_tex = new Texture;
95 grid_tex->create(GRID_SIZE, GRID_SIZE, TEX_2D, GL_LUMINANCE32F_ARB);
96 grid_tex->set_anisotropy(glcaps.max_aniso);
98 gvis_tex = new Texture;
99 if(!gvis_tex->load("data/purple_grid.png")) {
102 gvis_tex->set_anisotropy(glcaps.max_aniso);
104 unsigned int vsdr, tcsdr, tesdr, psdr;
106 if(!(vsdr = load_vertex_shader("sdr/field.v.glsl")) ||
107 !(tcsdr = load_tessctl_shader("sdr/field.tc.glsl")) ||
108 !(tesdr = load_tesseval_shader("sdr/field.te.glsl")) ||
109 !(psdr = load_pixel_shader("sdr/field.p.glsl"))) {
113 if(!(field_sdr = create_program_link(vsdr, tcsdr, tesdr, psdr, 0))) {
116 set_uniform_int(field_sdr, "gvis_tex", 0);
117 set_uniform_int(field_sdr, "field_tex", 1);
118 set_uniform_float(field_sdr, "gvis_scale", FIELD_SIZE / 32.0f);
119 set_uniform_int(field_sdr, "tess_level", tess_level);
120 set_uniform_float(field_sdr, "field_scale", field_scale);
122 gen_quad_plane(&field_mesh, FIELD_SIZE, FIELD_SIZE, 32, 32);
125 emit_place_pos = Vec2(0, 0);
126 emit_place_pending = true;
128 assert(glGetError() == GL_NO_ERROR);
132 void GameScreen::destroy()
134 free_program(field_sdr);
137 destroy_quadmesh(&field_mesh);
140 static void calc_contrib_bounds(const Emitter *em, Rect *rect)
142 int gidx = pos_to_grid(em->pos.x, em->pos.y);
143 int gx = GRID_X(gidx);
144 int gy = GRID_Y(gidx);
145 int maxrange = (int)ceil(CONTRIB_RANGE(em->mass));
147 int sx = gx - maxrange;
148 int sy = gy - maxrange;
149 int ex = gx + maxrange;
150 int ey = gy + maxrange;
152 if(ex > GRID_SIZE) ex = GRID_SIZE;
153 if(ey > GRID_SIZE) ey = GRID_SIZE;
155 rect->x = sx < 0 ? 0 : sx;
156 rect->y = sy < 0 ? 0 : sy;
157 rect->width = ex - sx;
158 rect->height = ey - sy;
161 static void simstep()
163 // calculate gravitational field - assume field within radius constant: m / r^2
165 // first clear the field, and then add contributions
166 memset(grid, 0, sizeof grid);
168 // contribution of emitters
169 int num_emitters = emitters.size();
170 for(int i=0; i<num_emitters; i++) {
171 Emitter *em = emitters[i];
173 calc_contrib_bounds(em, &cbox);
174 float emradius = MASS_TO_RAD(em->mass);
176 float *gptr = grid + cbox.y * GRID_SIZE + cbox.x;
177 Vec2 startpos = grid_to_pos(cbox.x, cbox.y);
179 for(int y=0; y<cbox.height; y++) {
180 for(int x=0; x<cbox.width; x++) {
181 Vec2 cellpos = Vec2(startpos.x + (float)x * GRID_DELTA, startpos.y);
183 Vec2 dir = cellpos - em->pos;
184 float dsq = dot(dir, dir);
185 float radsq = emradius * emradius;
190 gptr[x] -= em->mass / dsq;
193 startpos.y += GRID_DELTA;
199 assert(glGetError() == GL_NO_ERROR);
201 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, GRID_SIZE, GRID_SIZE, GL_LUMINANCE,
203 assert(glGetError() == GL_NO_ERROR);
208 if(emit_place_pending) {
209 emit_place_pending = false;
210 Emitter *em = new Emitter;
211 em->pos = emit_place_pos;
217 emitters.push_back(em);
220 calc_contrib_bounds(em, &cbox);
221 printf("bounds: %d,%d %dx%d\n", cbox.x, cbox.y, cbox.width, cbox.height);
225 static float interval;
226 interval += frame_dt;
227 if(interval >= SIM_DT) {
230 assert(glGetError() == GL_NO_ERROR);
233 // update projection matrix
234 proj_matrix.perspective(deg_to_rad(60.0f), win_aspect, 0.5, 5000.0);
236 // update view matrix
239 targ.x = targ_pos->x;
240 targ.z = targ_pos->y;
243 float theta = -deg_to_rad(cam_theta);
244 Vec3 camdir = Vec3(sin(theta) * cam_dist, pow(cam_dist * 0.1, 2.0) + 0.5, cos(theta) * cam_dist);
245 Vec3 campos = targ + camdir;
247 view_matrix.inv_lookat(campos, targ, Vec3(0, 1, 0));
250 void GameScreen::draw()
254 glClearColor(0.01, 0.01, 0.01, 1);
255 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
257 glMatrixMode(GL_PROJECTION);
258 glLoadMatrixf(proj_matrix[0]);
259 glMatrixMode(GL_MODELVIEW);
260 glLoadMatrixf(view_matrix[0]);
262 glPushAttrib(GL_ENABLE_BIT);
263 glDisable(GL_LIGHTING);
264 glDisable(GL_CULL_FACE);
266 glEnable(GL_TEXTURE_2D);
267 bind_texture(gvis_tex, 0);
268 bind_texture(grid_tex, 1);
270 glUseProgram(field_sdr);
271 assert(glGetError() == GL_NO_ERROR);
273 glPatchParameteri(GL_PATCH_VERTICES, 4);
274 draw_quadmesh(&field_mesh, GL_PATCHES);
280 assert(glGetError() == GL_NO_ERROR);
283 void GameScreen::reshape(int x, int y)
289 void GameScreen::keyboard(int key, bool pressed)
298 if(tess_level < glcaps.max_tess_level) {
300 printf("tessellation level: %d\n", tess_level);
301 set_uniform_int(field_sdr, "tess_level", tess_level);
309 printf("tessellation level: %d\n", tess_level);
310 set_uniform_int(field_sdr, "tess_level", tess_level);
317 printf("field scale: %f\n", field_scale);
318 set_uniform_float(field_sdr, "field_scale", field_scale);
323 if(field_scale < 0.0f) {
326 printf("field scale: %f\n", field_scale);
327 set_uniform_float(field_sdr, "field_scale", field_scale);
336 static int prev_x, prev_y;
338 void GameScreen::mbutton(int bn, bool pressed, int x, int y)
344 void GameScreen::mmotion(int x, int y)
351 if(game_bnstate(2)) {
352 cam_theta += dx * 0.5;
356 void GameScreen::mwheel(int dir, int x, int y)
358 cam_dist -= dir * cam_dist * 0.05f;
359 if(cam_dist <= MIN_CAM_DIST) cam_dist = MIN_CAM_DIST;
360 if(cam_dist > MAX_CAM_DIST) cam_dist = MAX_CAM_DIST;
364 static int pos_to_grid(float x, float y)
366 int gx = ((x / (float)FIELD_SIZE) + 0.5f) * (float)GRID_SIZE;
367 int gy = ((y / (float)FIELD_SIZE) + 0.5f) * (float)GRID_SIZE;
370 if(gx >= GRID_SIZE) gx = GRID_SIZE - 1;
372 if(gy >= GRID_SIZE) gy = GRID_SIZE - 1;
374 return (gx << GRID_BITS) | gy;
377 static Vec2 grid_to_pos(int gx, int gy)
379 float x = (((float)gx / (float)GRID_SIZE) - 0.5f) * (float)FIELD_SIZE;
380 float y = (((float)gy / (float)GRID_SIZE) - 0.5f) * (float)FIELD_SIZE;
385 static void destroy_quadmesh(QuadMesh *m)
387 glDeleteBuffers(1, &m->vbo_v);
388 glDeleteBuffers(1, &m->vbo_uv);
389 glDeleteBuffers(1, &m->ibo);
396 static void draw_quadmesh(const QuadMesh *m, unsigned int prim)
398 glEnableClientState(GL_VERTEX_ARRAY);
399 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
401 glBindBuffer(GL_ARRAY_BUFFER, m->vbo_v);
402 glVertexPointer(3, GL_FLOAT, 0, 0);
404 glBindBuffer(GL_ARRAY_BUFFER, m->vbo_uv);
405 glTexCoordPointer(2, GL_FLOAT, 0, 0);
407 glBindBuffer(GL_ARRAY_BUFFER, 0);
409 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->ibo);
410 glDrawElements(prim, m->num_idx, GL_UNSIGNED_SHORT, 0);
411 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
413 glDisableClientState(GL_VERTEX_ARRAY);
414 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
417 static void gen_quad_plane(QuadMesh *m, float width, float height, int usub, int vsub)
423 if(usub < 1) usub = 1;
424 if(vsub < 1) vsub = 1;
426 int uverts = usub + 1;
427 int vverts = vsub + 1;
428 m->num_verts = uverts * vverts;
429 m->num_quads = usub * vsub;
430 m->num_idx = m->num_quads * 4;
432 vptr = m->v = new Vec3[m->num_verts];
433 uvptr = m->uv = new Vec2[m->num_verts];
434 iptr = m->idx = new uint16_t[m->num_idx];
436 float du = 1.0f / (float)usub;
437 float dv = 1.0f / (float)vsub;
440 for(int i=0; i<uverts; i++) {
441 float x = (u - 0.5f) * width;
443 for(int j=0; j<vverts; j++) {
444 float y = (v - 0.5f) * height;
446 *vptr++ = Vec3(x, 0, y);
447 *uvptr++ = Vec2(u, v);
449 if(i < usub && j < vsub) {
450 int idx = i * vverts + j;
453 *iptr++ = idx + vverts;
454 *iptr++ = idx + vverts + 1;
463 glGenBuffers(1, &m->vbo_v);
464 glBindBuffer(GL_ARRAY_BUFFER, m->vbo_v);
465 glBufferData(GL_ARRAY_BUFFER, m->num_verts * 3 * sizeof(float), m->v, GL_STATIC_DRAW);
467 glGenBuffers(1, &m->vbo_uv);
468 glBindBuffer(GL_ARRAY_BUFFER, m->vbo_uv);
469 glBufferData(GL_ARRAY_BUFFER, m->num_verts * 2 * sizeof(float), m->uv, GL_STATIC_DRAW);
471 glGenBuffers(1, &m->ibo);
472 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->ibo);
473 glBufferData(GL_ELEMENT_ARRAY_BUFFER, m->num_idx * sizeof(uint16_t), m->idx, GL_STATIC_DRAW);
475 glBindBuffer(GL_ARRAY_BUFFER, 0);
476 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);