dungeon_crawler: d0e93b4d9ec9 prototype/src/main.cc

dungeon_crawler

view prototype/src/main.cc @ 35:d0e93b4d9ec9

normal mapping

author	John Tsiombikas <nuclear@member.fsf.org>
date	Tue, 28 Aug 2012 06:28:22 +0300
parents	2fc004802739
children	862461b686f4

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <assert.h>

4 #include <unistd.h>

5 #include "opengl.h"

6 #include "level.h"

7 #include "camera.h"

8 #include "datapath.h"

9 #include "tileset.h"

10 #include "renderer.h"

11 #include "cmdcon.h"

12 #include "cfg.h"

14 bool init(int xsz, int ysz);

15 void cleanup();

16 void idle();

17 void disp();

18 void draw();

19 void view_matrix(int eye);

20 void proj_matrix(int eye);

21 void update(unsigned long msec);

22 void reshape(int x, int y);

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

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

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

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

27 void motion(int x, int y);

29 static TileSet *tileset;

30 static Level *level;

32 static FpsCamera cam;

33 static bool keystate[256];

35 static float stereo_focus_dist = 0.25;

36 static float stereo_eye_sep = stereo_focus_dist / 30.0;

38 static bool show_con;

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

41 {

42 glutInit(&argc, argv);

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

45 return 1;

46 }

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

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

50 glutCreateWindow("dungeon crawler prototype");

52 glutIdleFunc(idle);

53 glutDisplayFunc(disp);

54 glutReshapeFunc(reshape);

55 glutKeyboardFunc(keyb);

56 glutKeyboardUpFunc(key_release);

57 glutMouseFunc(mouse);

58 glutMotionFunc(motion);

60 glewInit();

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

63 return 1;

64 }

66 glutMainLoop();

67 }

69 bool init(int xsz, int ysz)

70 {

71 glEnable(GL_LIGHTING);

72 glEnable(GL_LIGHT0);

73 float ldir[] = {-1, 1, 2, 0};

74 glLightfv(GL_LIGHT0, GL_POSITION, ldir);

75 glEnable(GL_NORMALIZE);

77 glEnable(GL_DEPTH_TEST);

78 glEnable(GL_CULL_FACE);

79 glEnable(GL_MULTISAMPLE);

81 add_data_path(".");

82 add_data_path("data");

83 add_data_path("sdr");

85 if(!init_renderer(xsz, ysz)) {

86 return false;

87 }

89 if(!init_cmdcon()) {

90 return false;

91 }

93 // load a tileset

94 tileset = new TileSet;

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

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

97 return false;

98 }

99 set_active_tileset(tileset);

100

101 level = new Level;

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

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

104 return false;

105 }

106

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

108

109 return true;

110 }

111

112 void cleanup()

113 {

114 delete level;

115 delete tileset;

116

117 destroy_renderer();

118

119 cleanup_cmdcon();

120 }

121

122 void idle()

123 {

124 glutPostRedisplay();

125 }

126

127 void disp()

128 {

129 update(glutGet(GLUT_ELAPSED_TIME));

130

131 if(cfg.stereo) {

132 glDrawBuffer(GL_BACK_LEFT);

133

134 glMatrixMode(GL_PROJECTION);

135 glLoadIdentity();

136 proj_matrix(-1);

137 glMatrixMode(GL_MODELVIEW);

138 glLoadIdentity();

139 view_matrix(-1);

140

141 draw();

142

143 glDrawBuffer(GL_BACK_RIGHT);

144

145 glMatrixMode(GL_PROJECTION);

146 glLoadIdentity();

147 proj_matrix(1);

148 glMatrixMode(GL_MODELVIEW);

149 glLoadIdentity();

150 view_matrix(1);

151

152 draw();

153 } else {

154 glMatrixMode(GL_PROJECTION);

155 glLoadIdentity();

156 proj_matrix(0);

157 glMatrixMode(GL_MODELVIEW);

158 glLoadIdentity();

159 view_matrix(0);

160

161 draw();

162 }

163

164 glutSwapBuffers();

165 assert(glGetError() == GL_NO_ERROR);

166

167 usleep(10000);

168 }

169

170 void draw()

171 {

172 glClear(GL_COLOR_BUFFER_BIT);

173

174 render_deferred(level);

175

176 if(show_con) {

177 draw_cmdcon();

178 }

179 }

180

181 void view_matrix(int eye)

182 {

183 float offs = stereo_eye_sep * eye * 0.5;

184 glTranslatef(-offs, 0, 0);

185 cam.use_inverse();

186 }

187

188 void proj_matrix(int eye)

189 {

190 static const float fov = M_PI / 4.0;

191 static const float near_clip = 0.1;

192 static const float far_clip = 100.0;

193

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

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

196

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

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

199 }

200

201

202 void update(unsigned long msec)

203 {

204 static unsigned long last_upd;

205

206 if(last_upd == 0) {

207 last_upd = msec;

208 }

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

210

211 float offs = 2.5 * dt;

212 float dx = 0, dy = 0;

213

214 // handle key input

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

216 dy -= offs;

217 }

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

219 dy += offs;

220 }

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

222 dx += offs;

223 }

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

225 dx -= offs;

226 }

227

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

229

230 last_upd = msec;

231 }

232

233 void reshape(int x, int y)

234 {

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

236 cfg.width = x;

237 cfg.height = y;

238

239 resize_renderer(x, y);

240 }

241

242 static bool stereo_shift_pressed;

243

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

245 {

246 switch(key) {

247 case 27:

248 exit(0);

249

250 case '`':

251 show_con = true;

252 glutKeyboardFunc(keyb_con);

253 glutKeyboardUpFunc(0);

254 glutPostRedisplay();

255 break;

256

257 case 'z':

258 stereo_shift_pressed = true;

259 break;

260

261 case '\n':

262 case '\r':

263 {

264 static bool fullscr;

265 if(glutGetModifiers() & GLUT_ACTIVE_ALT) {

266 fullscr = !fullscr;

267 if(fullscr) {

268 glutFullScreen();

269 } else {

270 glutPositionWindow(20, 20);

271 }

272 }

273 }

274 break;

275

276 default:

277 break;

278 }

279

280 keystate[key] = true;

281 }

282

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

284 {

285 switch(key) {

286 case 'z':

287 stereo_shift_pressed = false;

288 break;

289

290 default:

291 break;

292 }

293

294 keystate[key] = false;

295 }

296

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

298 {

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

300 show_con = false;

301 glutKeyboardFunc(keyb);

302 glutKeyboardUpFunc(key_release);

303 glutPostRedisplay();

304 } else {

305 cmdcon_keypress(key);

306 }

307 }

308

309 static int prev_x, prev_y;

310 static bool bnstate[32];

311

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

313 {

314 prev_x = x;

315 prev_y = y;

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

317 }

318

319 void motion(int x, int y)

320 {

321 int dx = x - prev_x;

322 int dy = y - prev_y;

323 prev_x = x;

324 prev_y = y;

325

326 if(stereo_shift_pressed) {

327 if(dy != 0) {

328 stereo_focus_dist += dy * 0.01;

329 stereo_eye_sep = stereo_focus_dist / 30.0;

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

331 glutPostRedisplay();

332 }

333 return;

334 }

335

336 if(bnstate[0]) {

337 cam.input_rotate(dy * 0.01, dx * 0.01, 0);

338 glutPostRedisplay();

339 }

340 if(bnstate[2]) {

341 cam.input_zoom(dy * 0.1);

342 glutPostRedisplay();

343 }

344 }