tavli: c3fbf9616dbd src/game.cc

tavli

view src/game.cc @ 21:c3fbf9616dbd

slot bounds, and ray testing

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 02 Jul 2015 00:01:39 +0300
parents	111c1a9bca29
children	c2a2069a49ec

line source

1 #include <stdio.h>

2 #include <assert.h>

3 #include "opengl.h"

4 #include "game.h"

5 #include "board.h"

6 #include "scenery.h"

7 #include "sdr.h"

8 #include "shadow.h"

9 #include "opt.h"

11 static void draw_scene();

12 static void draw_backdrop();

14 int win_width, win_height;

15 unsigned long cur_time;

16 unsigned int sdr_phong, sdr_phong_notex;

17 unsigned int sdr_shadow, sdr_shadow_notex;

18 unsigned int sdr_unlit;

19 bool wireframe;

20 int dbg_int;

22 static Board board;

24 static float cam_theta, cam_phi = 45, cam_dist = 3;

25 static bool bnstate[8];

26 static int prev_x, prev_y;

28 static bool dbg_busyloop, dbg_show_shadowmap;

30 bool game_init()

31 {

32 if(init_opengl() == -1) {

33 return false;

34 }

36 glEnable(GL_DEPTH_TEST);

37 glEnable(GL_CULL_FACE);

38 glEnable(GL_NORMALIZE);

39 glEnable(GL_LIGHTING);

40 glEnable(GL_LIGHT0);

42 float amb[] = {0.3, 0.3, 0.3, 1.0};

43 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, amb);

45 if(glcaps.sep_spec) {

46 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);

47 }

49 if(glcaps.fsaa) {

50 glEnable(GL_MULTISAMPLE);

51 }

53 if(glcaps.shaders) {

54 Mesh::use_custom_sdr_attr = false;

55 if(!(sdr_phong = create_program_load("sdr/phong.v.glsl", "sdr/phong.p.glsl"))) {

56 return false;

57 }

58 if(!(sdr_phong_notex = create_program_load("sdr/phong.v.glsl", "sdr/phong-notex.p.glsl"))) {

59 return false;

60 }

62 if(glcaps.fbo) {

63 init_shadow(2048);

65 if(!(sdr_shadow = create_program_load("sdr/shadow.v.glsl", "sdr/shadow.p.glsl"))) {

66 return false;

67 }

68 set_uniform_int(sdr_shadow, "tex", 0);

69 set_uniform_int(sdr_shadow, "shadowmap", 1);

71 if(!(sdr_shadow_notex = create_program_load("sdr/shadow.v.glsl", "sdr/shadow-notex.p.glsl"))) {

72 return false;

73 }

74 set_uniform_int(sdr_shadow_notex, "shadowmap", 1);

75 }

76 }

78 if(!board.init()) {

79 return false;

80 }

81 board.setup();

83 if(!init_scenery()) {

84 return false;

85 }

87 assert(glGetError() == GL_NO_ERROR);

88 return true;

89 }

91 void game_cleanup()

92 {

93 board.destroy();

94 destroy_scenery();

95 destroy_shadow();

96 }

98 void game_update(unsigned long time_msec)

99 {

100 cur_time = time_msec;

101 }

102

103 void game_display()

104 {

105 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

106

107 glMatrixMode(GL_MODELVIEW);

108 glLoadIdentity();

109 glTranslatef(0, 0.1, -cam_dist);

110 glRotatef(cam_phi, 1, 0, 0);

111 glRotatef(cam_theta, 0, 1, 0);

112

113 float lpos[] = {-10, 20, 10, 1};

114 glLightfv(GL_LIGHT0, GL_POSITION, lpos);

115

116 if(opt.shadows && sdr_shadow) {

117 begin_shadow_pass(Vector3(lpos[0], lpos[1], lpos[2]), Vector3(0, 0, 0), 4.5);

118 draw_scene();

119 end_shadow_pass();

120

121 glActiveTexture(GL_TEXTURE1);

122 glBindTexture(GL_TEXTURE_2D, get_shadow_tex());

123

124 glMatrixMode(GL_TEXTURE);

125 Matrix4x4 shadow_matrix = get_shadow_matrix();

126 glLoadTransposeMatrixf(shadow_matrix[0]);

127

128 glActiveTexture(GL_TEXTURE0);

129 glMatrixMode(GL_MODELVIEW);

130

131 draw_scene();

132

133 glActiveTexture(GL_TEXTURE1);

134 glBindTexture(GL_TEXTURE_2D, 0);

135 glActiveTexture(GL_TEXTURE0);

136 glBindTexture(GL_TEXTURE_2D, 0);

137 } else {

138 draw_scene();

139 }

140

141 if(dbg_show_shadowmap) {

142 glMatrixMode(GL_PROJECTION);

143 glPushMatrix();

144 glLoadIdentity();

145 glMatrixMode(GL_MODELVIEW);

146 glPushMatrix();

147 glLoadIdentity();

148 glMatrixMode(GL_TEXTURE);

149 glLoadIdentity();

150

151 glPushAttrib(GL_ENABLE_BIT);

152 glUseProgram(0);

153 glBindTexture(GL_TEXTURE_2D, get_shadow_tex());

154 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);

155 glEnable(GL_TEXTURE_2D);

156 glDisable(GL_DEPTH_TEST);

157 glDisable(GL_LIGHTING);

158 glDisable(GL_BLEND);

159

160 glBegin(GL_QUADS);

161 glColor4f(1, 1, 1, 1);

162 glTexCoord2f(0, 0); glVertex2f(-1, -1);

163 glTexCoord2f(1, 0); glVertex2f(1, -1);

164 glTexCoord2f(1, 1); glVertex2f(1, 1);

165 glTexCoord2f(0, 1); glVertex2f(-1, 1);

166 glEnd();

167

168 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);

169 glBindTexture(GL_TEXTURE_2D, 0);

170

171 glPopAttrib();

172

173 glMatrixMode(GL_PROJECTION);

174 glPopMatrix();

175 glMatrixMode(GL_MODELVIEW);

176 glPopMatrix();

177 }

178

179 if(dbg_busyloop) {

180 redisplay();

181 }

182 }

183

184 static void draw_scene()

185 {

186 draw_backdrop();

187 draw_scenery();

188 board.draw();

189 }

190

191 static void draw_backdrop()

192 {

193 glPushAttrib(GL_ENABLE_BIT);

194 glDisable(GL_LIGHTING);

195 glDisable(GL_DEPTH_TEST);

196

197 glMatrixMode(GL_PROJECTION);

198 glPushMatrix();

199 glLoadIdentity();

200 glMatrixMode(GL_MODELVIEW);

201 glPushMatrix();

202 glLoadIdentity();

203

204 glBegin(GL_QUADS);

205 glColor3f(0.9, 0.8, 0.6);

206 glVertex2f(-1, -1);

207 glVertex2f(1, -1);

208 glColor3f(0.4, 0.5, 0.8);

209 glVertex2f(1, 1);

210 glVertex2f(-1, 1);

211 glEnd();

212

213 glMatrixMode(GL_PROJECTION);

214 glPopMatrix();

215 glMatrixMode(GL_MODELVIEW);

216 glPopMatrix();

217

218 glPopAttrib();

219 }

220

221 void game_reshape(int x, int y)

222 {

223 glMatrixMode(GL_PROJECTION);

224 glLoadIdentity();

225 gluPerspective(45, (float)x / (float)y, 0.2, 200.0);

226

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

228 }

229

230 void game_keyboard(int bn, bool press)

231 {

232 if(press) {

233 switch(bn) {

234 case 27:

235 quit();

236

237 case 'w':

238 wireframe = !wireframe;

239 redisplay();

240 break;

241

242 case 'd':

243 dbg_busyloop = !dbg_busyloop;

244 redisplay();

245 break;

246

247 case 'D':

248 dbg_show_shadowmap = !dbg_show_shadowmap;

249 redisplay();

250 break;

251

252 case 's':

253 opt.shadows = !opt.shadows;

254 redisplay();

255 break;

256

257 case '=':

258 dbg_int++;

259 printf("dbg_int: %d\n", dbg_int);

260 redisplay();

261 break;

262

263 case '-':

264 dbg_int--;

265 printf("dbg_int: %d\n", dbg_int);

266 redisplay();

267 break;

268 }

269 }

270 }

271

272 void game_mbutton(int bn, bool press, int x, int y)

273 {

274 bnstate[bn] = press;

275 prev_x = x;

276 prev_y = y;

277 }

278

279 void game_mmotion(int x, int y)

280 {

281 int dx = x - prev_x;

282 int dy = y - prev_y;

283 prev_x = x;

284 prev_y = y;

285

286 if(bnstate[0]) {

287 cam_theta += dx * 0.5;

288 cam_phi += dy * 0.5;

289

290 if(cam_phi < -90) cam_phi = -90;

291 if(cam_phi > 90) cam_phi = 90;

292

293 redisplay();

294 }

295 if(bnstate[2]) {

296 cam_dist += dy * 0.1;

297 if(cam_dist < 0.0) cam_dist = 0.0;

298

299 redisplay();

300 }

301 }