dungeon_crawler: 5981917093ff prototype/src/main.cc

dungeon_crawler

view prototype/src/main.cc @ 74:5981917093ff

color grading palette output done, all is left is the input

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sun, 21 Oct 2012 15:56:47 +0300
parents	a27528035e20
children	b05ab29cd17d

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <assert.h>

4 #include "opengl.h"

5 #include "psys/psys.h"

6 #include "level.h"

7 #include "texture.h"

8 #include "camera.h"

9 #include "datapath.h"

10 #include "tileset.h"

11 #include "renderer.h"

12 #include "renderer_deferred.h"

13 #include "cmdcon.h"

14 #include "cfg.h"

15 #include "timer.h"

16 #include "audio/audio.h"

17 #include "audio/source.h"

18 #include "audio/ovstream.h"

20 bool init(int xsz, int ysz);

21 void cleanup();

22 void idle();

23 void disp();

24 void draw();

25 void view_matrix(int eye);

26 void proj_matrix(int eye);

27 void update(unsigned long msec);

28 void reshape(int x, int y);

29 void keyb(unsigned char key, int x, int y);

30 void key_release(unsigned char key, int x, int y);

31 void keyb_con(unsigned char key, int x, int y);

32 void mouse(int bn, int state, int x, int y);

33 void motion(int x, int y);

34 unsigned int load_psys_tex(const char *fname, void *cls);

36 static TileSet *tileset;

37 static Level *level;

39 static FpsCamera cam;

40 static bool keystate[256];

42 static float stereo_focus_dist = 0.25;

43 static float stereo_eye_sep = stereo_focus_dist / 30.0;

45 static bool show_con;

46 static bool save_grade_shot;

48 static AudioSource *move_sound;

49 static OggVorbisStream *music;

51 int main(int argc, char **argv)

52 {

53 glutInit(&argc, argv);

55 if(!cfg.parse_args(argc, argv)) {

56 return 1;

57 }

59 glutInitWindowSize(cfg.width, cfg.height);

60 glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | (cfg.stereo ? GLUT_STEREO : 0));

61 glutCreateWindow("dungeon crawler prototype");

63 glutIdleFunc(idle);

64 glutDisplayFunc(disp);

65 glutReshapeFunc(reshape);

66 glutKeyboardFunc(keyb);

67 glutKeyboardUpFunc(key_release);

68 glutMouseFunc(mouse);

69 glutMotionFunc(motion);

71 glewInit();

73 if(!init(cfg.width, cfg.height)) {

74 return 1;

75 }

76 atexit(cleanup);

78 glutMainLoop();

79 }

81 bool init(int xsz, int ysz)

82 {

83 // backup light for the forward crappy renderer

84 glEnable(GL_LIGHTING);

85 glEnable(GL_LIGHT0);

87 float ldir[] = {0, 0, -0.5, 1};

88 glLightfv(GL_LIGHT0, GL_POSITION, ldir);

89 float lcol[] = {1, 1, 1, 1};

90 glLightfv(GL_LIGHT0, GL_DIFFUSE, lcol);

91 glLightfv(GL_LIGHT0, GL_SPECULAR, lcol);

93 glEnable(GL_DEPTH_TEST);

94 glEnable(GL_CULL_FACE);

95 glEnable(GL_MULTISAMPLE);

97 add_data_path(".");

98 add_data_path("data");

99 add_data_path("data/audio");

100 add_data_path("sdr");

101

102 if(cfg.sound && !init_audio()) {

103 fprintf(stderr, "failed to initialize audio, continuing silently\n");

104 cfg.sound = false;

105 }

106 if(cfg.sound) {

107 move_sound = new AudioSource;

108 move_sound->set_volume(0.4);

109

110 music = new OggVorbisStream;

111 if(music->open(datafile_path("bgtrack.ogg").c_str())) {

112 music->set_volume(0.6);

113 music->play(PlayMode::loop);

114 } else {

115 delete music;

116 music = 0;

117 }

118 }

119

120 switch(cfg.rend) {

121 case Config::Renderer::mrt:

122 rend = new DeferredRenderer;

123 if(!rend->init(xsz, ysz)) {

124 fprintf(stderr, "failed to initialize deferred mrt renderer\n");

125 delete rend;

126 return false;

127 }

128 break;

129

130 case Config::Renderer::fwd:

131 rend = new FwdRenderer;

132 if(!rend->init(xsz, ysz)) {

133 fprintf(stderr, "failed to initialize forward renderer\n");

134 delete rend;

135 return false;

136 }

137 break;

138

139 default:

140 // try each in turn falling back to progressively worse renderers

141 rend = new DeferredRenderer;

142 if(!rend->init(xsz, ysz)) {

143 printf("falling back to multipass renderer...\n");

144

145 delete rend;

146 rend = new FwdRenderer();

147 if(!rend->init(xsz, ysz)) {

148 fprintf(stderr, "failed to create renderer\n");

149 return false;

150 }

151 }

152 }

153

154 if(!init_cmdcon()) {

155 return false;

156 }

157

158 psys_texture_loader(load_psys_tex, 0, 0);

159

160 // load a tileset

161 tileset = new TileSet;

162 printf("loading tileset: %s\n", cfg.tileset_file);

163 if(!tileset->load(datafile_path(cfg.tileset_file).c_str())) {

164 return false;

165 }

166 set_active_tileset(tileset);

167

168 level = new Level;

169 printf("loading level: %s\n", cfg.level_file);

170 if(!level->load(datafile_path(cfg.level_file).c_str())) {

171 return false;

172 }

173

174 cam.input_move(0, 0.5, 0);

175

176 return true;

177 }

178

179 void cleanup()

180 {

181 delete level;

182 delete tileset;

183 delete rend;

184

185 cleanup_cmdcon();

186

187 if(cfg.sound) {

188 delete music;

189 delete move_sound;

190 destroy_audio();

191 }

192 }

193

194 void idle()

195 {

196 glutPostRedisplay();

197 }

198

199 void disp()

200 {

201 update(get_time_msec());

202

203 if(cfg.stereo) {

204 glDrawBuffer(GL_BACK_LEFT);

205

206 glMatrixMode(GL_PROJECTION);

207 glLoadIdentity();

208 proj_matrix(-1);

209 glMatrixMode(GL_MODELVIEW);

210 glLoadIdentity();

211 view_matrix(-1);

212

213 draw();

214

215 glDrawBuffer(GL_BACK_RIGHT);

216

217 glMatrixMode(GL_PROJECTION);

218 glLoadIdentity();

219 proj_matrix(1);

220 glMatrixMode(GL_MODELVIEW);

221 glLoadIdentity();

222 view_matrix(1);

223

224 draw();

225 } else {

226 glMatrixMode(GL_PROJECTION);

227 glLoadIdentity();

228 proj_matrix(0);

229 glMatrixMode(GL_MODELVIEW);

230 glLoadIdentity();

231 view_matrix(0);

232

233 draw();

234 }

235

236 glutSwapBuffers();

237 assert(glGetError() == GL_NO_ERROR);

238 }

239

240 void draw()

241 {

242 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

243

244 rend->render(level);

245

246 if(show_con) {

247 draw_cmdcon();

248 }

249

250 if(save_grade_shot) {

251 GradePalette *pal = rend->get_grade_palette();

252 if(!pal->save_shot("gradeshot.ppm")) {

253 fprintf(stderr, "failed to save color grading shot\n");

254 }

255 save_grade_shot = false;

256 }

257 }

258

259 void view_matrix(int eye)

260 {

261 float offs = stereo_eye_sep * eye * 0.5;

262 glTranslatef(-offs, 0, 0);

263 cam.use_inverse();

264 }

265

266 void proj_matrix(int eye)

267 {

268 static const float fov = M_PI / 4.0;

269 static const float near_clip = 0.1;

270 static const float far_clip = 100.0;

271

272 float top = near_clip * tan(fov * 0.5);

273 float right = top * (float)cfg.width / (float)cfg.height;

274

275 float frust_shift = -(float)eye * (stereo_eye_sep * 0.5 * near_clip / stereo_focus_dist);

276 glFrustum(-right + frust_shift, right + frust_shift, -top, top, near_clip, far_clip);

277 }

278

279

280 void update(unsigned long msec)

281 {

282 static unsigned long last_upd;

283

284 if(last_upd == 0) {

285 last_upd = msec;

286 }

287 float dt = (float)(msec - last_upd) / 1000.0;

288

289 float offs = 2.0 * dt;

290 float dx = 0, dy = 0;

291

292 // handle key input

293 bool did_move = false;

294 if(keystate['w'] || keystate['W']) {

295 dy -= offs;

296 did_move = true;

297 }

298 if(keystate['s'] || keystate['S']) {

299 dy += offs;

300 did_move = true;

301 }

302 if(keystate['d'] || keystate['D']) {

303 dx += offs;

304 did_move = true;

305 }

306 if(keystate['a'] || keystate['A']) {

307 dx -= offs;

308 did_move = true;

309 }

310

311 cam.input_move(dx, 0, dy);

312

313 tileset->update_tiles(msec);

314

315 level->set_player_position(cam.get_position());

316 level->update(msec, dt);

317

318 if(cfg.sound) {

319 // set the listener matrix

320 set_audio_listener(cam.matrix());

321

322 // play the walking sound if we're walking

323 int cellx, celly;

324 level->get_cell_coords_at(cam.get_position(), &cellx, &celly);

325

326 const AudioSample *move_sample;

327 if(did_move && (move_sample = level->get_sample(cellx, celly, TILE_SAMPLE_WALK))) {

328 if(move_sample != move_sound->get_sample()) {

329 move_sound->stop();

330 move_sound->set_sample(move_sample);

331 move_sound->play();

332 }

333 } else {

334 if(move_sound->get_sample()) {

335 move_sound->stop();

336 move_sound->set_sample(0);

337 }

338 }

339 }

340

341 last_upd = msec;

342 }

343

344 void reshape(int x, int y)

345 {

346 glViewport(0, 0, x, y);

347 cfg.width = x;

348 cfg.height = y;

349

350 rend->resize(x, y);

351 }

352

353 static bool stereo_shift_pressed;

354

355 void keyb(unsigned char key, int x, int y)

356 {

357 switch(key) {

358 case 27:

359 exit(0);

360

361 case '`':

362 show_con = true;

363 glutKeyboardFunc(keyb_con);

364 glutKeyboardUpFunc(0);

365 glutPostRedisplay();

366 break;

367

368 case 'z':

369 stereo_shift_pressed = true;

370 break;

371

372 case 'p':

373 {

374 Vector3 pos = cam.get_position();

375 int cell_x, cell_y;

376 level->get_cell_coords_at(pos, &cell_x, &cell_y);

377 printf("Current position: [%.2f %.2f %.2f] cell: [%d %d]\n", pos.x, pos.y, pos.z,

378 cell_x, cell_y);

379 }

380 break;

381

382 case 'P':

383 {

384 Vector3 pos = cam.get_position();

385 int cell_x, cell_y;

386 level->get_cell_coords_at(pos, &cell_x, &cell_y);

387 AudioSample *sample = level->get_sample(cell_x, cell_y, TILE_SAMPLE_WALK);

388 printf("walk sample: %p\n", (void*)sample);

389 }

390 break;

391

392

393 case '\n':

394 case '\r':

395 {

396 static bool fullscr;

397 if(glutGetModifiers() & GLUT_ACTIVE_ALT) {

398 fullscr = !fullscr;

399 if(fullscr) {

400 glutFullScreen();

401 } else {

402 glutPositionWindow(20, 20);

403 }

404 }

405 }

406 break;

407

408 case 'g':

409 save_grade_shot = true;

410 break;

411

412 default:

413 break;

414 }

415

416 keystate[key] = true;

417 }

418

419 void key_release(unsigned char key, int x, int y)

420 {

421 switch(key) {

422 case 'z':

423 stereo_shift_pressed = false;

424 break;

425

426 default:

427 break;

428 }

429

430 keystate[key] = false;

431 }

432

433 void keyb_con(unsigned char key, int x, int y)

434 {

435 if(key == '`' || key == 27) {

436 show_con = false;

437 glutKeyboardFunc(keyb);

438 glutKeyboardUpFunc(key_release);

439 glutPostRedisplay();

440 } else {

441 cmdcon_keypress(key);

442 }

443 }

444

445 static int prev_x, prev_y;

446 static bool bnstate[32];

447

448 void mouse(int bn, int state, int x, int y)

449 {

450 prev_x = x;

451 prev_y = y;

452 bnstate[bn - GLUT_LEFT_BUTTON] = state == GLUT_DOWN;

453 }

454

455 void motion(int x, int y)

456 {

457 int dx = x - prev_x;

458 int dy = y - prev_y;

459 prev_x = x;

460 prev_y = y;

461

462 if(stereo_shift_pressed) {

463 if(dy != 0) {

464 stereo_focus_dist += dy * 0.01;

465 stereo_eye_sep = stereo_focus_dist / 30.0;

466 printf("foc: %f, sep: %f\n", stereo_focus_dist, stereo_eye_sep);

467 glutPostRedisplay();

468 }

469 return;

470 }

471

472 if(bnstate[0]) {

473 cam.input_rotate(dy * 0.0075, dx * 0.0075, 0);

474 glutPostRedisplay();

475 }

476 if(bnstate[2]) {

477 cam.input_zoom(dy * 0.1);

478 glutPostRedisplay();

479 }

480 }

481

482 unsigned int load_psys_tex(const char *fname, void *cls)

483 {

484 TextureSet *texset = tileset->get_textures();

485 return texset->get(fname);

486 }