istereo2: ea928c313344 src/istereo.c

istereo2

view src/istereo.c @ 13:ea928c313344

foo

author	John Tsiombikas <nuclear@member.fsf.org>
date	Mon, 28 Sep 2015 19:04:50 +0300
parents	661bf09db398
children	7bd4264bf74a

line source

1 /*

2 Stereoscopic tunnel for iOS.

5 This program is free software: you can redistribute it and/or modify

6 it under the terms of the GNU General Public License as published by

7 the Free Software Foundation, either version 3 of the License, or

8 (at your option) any later version.

10 This program is distributed in the hope that it will be useful,

11 but WITHOUT ANY WARRANTY; without even the implied warranty of

12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

13 GNU General Public License for more details.

15 You should have received a copy of the GNU General Public License

16 along with this program. If not, see <http://www.gnu.org/licenses/>.

17 */

20 #include <stdio.h>

21 #include <math.h>

22 #include <assert.h>

23 #include <unistd.h>

24 #include "opengl.h"

25 #include "istereo.h"

26 #include "sanegl.h"

27 #include "sdr.h"

28 #include "respath.h"

29 #include "tex.h"

30 #include "cam.h"

31 #include "vmath.h"

32 #include "config.h"

33 #include "ui.h"

34 #include "drawtext.h"

35 #include "timer.h"

37 static void render(float t);

38 static void draw_tunnel(float t);

39 static void tunnel_vertex(float u, float v, float du, float dv, int tang_loc, float t);

40 static vec3_t calc_text_pos(float sec);

41 static void draw_text(float idx, vec3_t tpos, float alpha);

42 static void worm(float t, float z, float *tx, float *ty);

43 static unsigned int get_shader_program(const char *vfile, const char *pfile);

45 unsigned int prog, prog_simple, prog_tunnel, prog_text, prog_color, prog_ui, prog_font;

46 unsigned int tex, tex_stones, tex_normal, tex_text;

47 struct dtx_font *font;

49 int view_xsz, view_ysz;

50 float view_aspect;

52 int stereo = 0;

53 int use_bump = 0;

54 int show_opt = 1;

56 /* construction parameters */

57 int sides = 24;

58 int segm = 20;

59 float tunnel_speed = 0.75;

60 float ring_height = 0.5;

61 float text_period = 13.0;

62 float text_speed = 2.2;

64 float split = 0.5275;

66 int init(void)

67 {

68 add_resource_path("sdr");

69 add_resource_path("data");

71 if(!(prog_simple = get_shader_program("test.v.glsl", "test.p.glsl"))) {

72 return -1;

73 }

74 if(!(prog_tunnel = get_shader_program("tunnel.v.glsl", "tunnel.p.glsl"))) {

75 return -1;

76 }

77 if(!(prog_text = get_shader_program("text.v.glsl", "text.p.glsl"))) {

78 return -1;

79 }

80 if(!(prog_color = get_shader_program("color.v.glsl", "color.p.glsl"))) {

81 return -1;

82 }

83 if(!(prog_ui = get_shader_program("ui.v.glsl", "ui.p.glsl"))) {

84 return -1;

85 }

86 if(!(prog_font = get_shader_program("ui.v.glsl", "font.p.glsl"))) {

87 return -1;

88 }

90 if(!(tex = load_texture(find_resource("tiles.jpg", 0, 0)))) {

91 return -1;

92 }

93 if(!(tex_stones = load_texture(find_resource("stonewall.jpg", 0, 0)))) {

94 return -1;

95 }

96 if(!(tex_normal = load_texture(find_resource("stonewall_normal.jpg", 0, 0)))) {

97 return -1;

98 }

99 if(!(tex_text = load_texture(find_resource("text.png", 0, 0)))) {

100 return -1;

101 }

102

103 if(!(font = dtx_open_font_glyphmap(find_resource("linux-libertine_s24.glyphmap", 0, 0)))) {

104 fprintf(stderr, "failed to load font\n");

105 return -1;

106 }

107 dtx_vertex_attribs(get_attrib_loc(prog_ui, "attr_vertex"), get_attrib_loc(prog_ui, "attr_texcoord"));

108 dtx_use_font(font, 24);

109

110 glEnable(GL_DEPTH_TEST);

111 glEnable(GL_CULL_FACE);

112

113 if(ui_init() == -1) {

114 return -1;

115 }

116

117 cam_fov(42.5);

118 cam_clip(0.5, 250.0);

119

120 return 0;

121 }

122

123 void cleanup(void)

124 {

125 ui_shutdown();

126 free_program(prog_simple);

127 free_program(prog_tunnel);

128 free_program(prog_color);

129 free_program(prog_ui);

130 free_program(prog_font);

131 dtx_close_font(font);

132 }

133

134 void redraw(void)

135 {

136 float pan_x, pan_y, z;

137 float tsec = get_time_sec();

138

139 z = ring_height * segm;

140 worm(tsec, z, &pan_x, &pan_y);

141

142 if(use_bump) {

143 glClearColor(0.01, 0.01, 0.01, 1.0);

144 tunnel_speed = 0.5;

145 } else {

146 glClearColor(0.6, 0.6, 0.6, 1.0);

147 tunnel_speed = 0.75;

148 }

149 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

150

151 if(stereo) {

152 int split_pt = (int)((float)view_xsz * split);

153

154 /* right eye */

155 glViewport(0, 0, split_pt, view_ysz);

156 cam_aspect((float)split_pt / (float)view_ysz);

157

158 gl_matrix_mode(GL_PROJECTION);

159 gl_load_identity();

160 cam_stereo_proj_matrix(CAM_RIGHT);

161 //gl_rotatef(-90, 0, 0, 1);

162

163 gl_matrix_mode(GL_MODELVIEW);

164 gl_load_identity();

165 cam_stereo_view_matrix(CAM_RIGHT);

166 gl_translatef(-pan_x, -pan_y, -1.1 * ring_height * segm);

167

168 render(tsec);

169

170 /* left eye */

171 glViewport(split_pt, 0, view_xsz - split_pt, view_ysz);

172 cam_aspect((float)(view_xsz - split_pt) / (float)view_ysz);

173

174 gl_matrix_mode(GL_PROJECTION);

175 gl_load_identity();

176 cam_stereo_proj_matrix(CAM_LEFT);

177 //gl_rotatef(-90, 0, 0, 1);

178

179 gl_matrix_mode(GL_MODELVIEW);

180 gl_load_identity();

181 cam_stereo_view_matrix(CAM_LEFT);

182 gl_translatef(-pan_x, -pan_y, -1.1 * ring_height * segm);

183

184 render(tsec);

185 } else {

186 glViewport(0, 0, view_xsz, view_ysz);

187 cam_aspect((float)view_xsz / (float)view_ysz);

188

189 gl_matrix_mode(GL_PROJECTION);

190 gl_load_identity();

191 //gl_rotatef(-90, 0, 0, 1);

192 cam_proj_matrix();

193

194 gl_matrix_mode(GL_MODELVIEW);

195 gl_load_identity();

196 cam_view_matrix();

197 gl_translatef(-pan_x, -pan_y, -1.1 * ring_height * segm);

198

199 render(tsec);

200 }

201

202 /* TEST */

203 /*bind_program(prog_ui);

204

205 gl_matrix_mode(GL_PROJECTION);

206 gl_load_identity();

207 gl_ortho(0, view_xsz, 0, view_ysz, -1, 1);

208 gl_matrix_mode(GL_MODELVIEW);

209 gl_load_identity();

210 gl_apply_xform(prog_ui);

211

212 glDisable(GL_DEPTH_TEST);

213 dtx_printf("hello world\n");

214 glEnable(GL_DEPTH_TEST);*/

215

216 assert(glGetError() == GL_NO_ERROR);

217 }

218

219 static void render(float t)

220 {

221 int i;

222 float text_line;

223

224 draw_tunnel(t);

225

226 if(use_bump) {

227 glDepthMask(0);

228 text_line = floor((text_speed * t) / text_period);

229 for(i=0; i<8; i++) {

230 vec3_t tpos = calc_text_pos(t - (float)i * 0.011);

231 draw_text(text_line, tpos, 1.5 / (float)i);

232 }

233 glDepthMask(1);

234 }

235

236 if(show_opt) {

237 ui_draw();

238 }

239 }

240

241 static void draw_tunnel(float t)

242 {

243 static const float uoffs[] = {0.0, 0.0, 1.0, 1.0};

244 static const float voffs[] = {0.0, 1.0, 1.0, 0.0};

245 int i, j, k, tang_loc = -1;

246 float du, dv;

247

248 prog = use_bump ? prog_tunnel : prog_simple;

249

250 bind_program(prog);

251 set_uniform_float(prog, "t", t);

252

253 if(use_bump) {

254 vec3_t ltpos = calc_text_pos(t);

255

256 bind_texture(tex_normal, 1);

257 set_uniform_int(prog, "tex_norm", 1);

258 bind_texture(tex_stones, 0);

259 set_uniform_int(prog, "tex", 0);

260

261 set_uniform_float4(prog, "light_pos", ltpos.x, ltpos.y, ltpos.z, 1.0);

262 tang_loc = get_attrib_loc(prog, "attr_tangent");

263 } else {

264 bind_texture(tex, 0);

265 set_uniform_int(prog, "tex", 0);

266 }

267

268 gl_matrix_mode(GL_TEXTURE);

269 gl_load_identity();

270 gl_translatef(0, -fmod(t * tunnel_speed, 1.0), 0);

271

272 gl_begin(GL_QUADS);

273 gl_color3f(1.0, 1.0, 1.0);

274

275 du = 1.0 / sides;

276 dv = 1.0 / segm;

277

278 for(i=0; i<segm; i++) {

279 float trans_zp[2], trans_z0[2], trans_z1[2];

280

281 float zp = ring_height * (i - 1);

282 float z0 = ring_height * i;

283 float z1 = ring_height * (i + 1);

284

285 worm(t, zp, trans_zp, trans_zp + 1);

286 worm(t, z0, trans_z0, trans_z0 + 1);

287 worm(t, z1, trans_z1, trans_z1 + 1);

288

289 for(j=0; j<sides; j++) {

290 for(k=0; k<4; k++) {

291 float u = (j + uoffs[k]) * du;

292 float v = (i + voffs[k]) * dv;

293

294 tunnel_vertex(u, v, du, dv, tang_loc, t);

295 }

296 }

297 }

298 gl_end();

299

300 bind_texture(0, 1);

301 bind_texture(0, 0);

302 }

303

304 static void tunnel_vertex(float u, float v, float du, float dv, int tang_loc, float t)

305 {

306 vec3_t pos, norm;

307 vec3_t dfdu, dfdv, pos_du, pos_dv;

308

309 float theta = 2.0 * M_PI * u;

310 float theta1 = 2.0 * M_PI * (u + du);

311

312 float x = cos(theta);

313 float y = sin(theta);

314 float x1 = cos(theta1);

315 float y1 = sin(theta1);

316 float z = v / dv * ring_height;

317 float z1 = (v + dv) / dv * ring_height;

318

319 float trans_z[2], trans_z1[2];

320

321 worm(t, z, trans_z, trans_z + 1);

322 worm(t, z1, trans_z1, trans_z1 + 1);

323

324 pos = v3_cons(x + trans_z[0], y + trans_z[1], z);

325 pos_du = v3_cons(x1 + trans_z[0], y1 + trans_z[1], z);

326 pos_dv = v3_cons(x + trans_z1[0], y + trans_z1[1], z1);

327

328 dfdu = v3_sub(pos_du, pos);

329 dfdv = v3_sub(pos_dv, pos);

330 norm = v3_cross(dfdv, dfdu);

331

332 gl_vertex_attrib3f(tang_loc, dfdu.x, -dfdu.y, dfdu.z);

333 gl_normal3f(norm.x, norm.y, norm.z);

334 gl_texcoord2f(u * 2.0, v * 4.0);

335 gl_vertex3f(pos.x, pos.y, pos.z);

336 }

337

338 static vec3_t calc_text_pos(float sec)

339 {

340 float t = text_speed * sec;

341 float z = fmod(t, text_period);

342 float pan[2];

343

344 worm(sec, z, pan, pan + 1);

345 return v3_cons(pan[0], pan[1], z + ring_height);

346 }

347

348 static void draw_text(float idx, vec3_t tpos, float alpha)

349 {

350 gl_matrix_mode(GL_MODELVIEW);

351 gl_push_matrix();

352 gl_translatef(tpos.x, tpos.y, tpos.z);

353

354 glEnable(GL_BLEND);

355 glBlendFunc(GL_SRC_ALPHA, GL_ONE);

356

357 bind_program(prog_text);

358 set_uniform_float(prog_text, "idx", idx);

359

360 bind_texture(tex_text, 0);

361

362 gl_begin(GL_QUADS);

363 gl_color4f(1.0, 1.0, 1.0, alpha > 1.0 ? 1.0 : alpha);

364

365 gl_texcoord2f(0, 1);

366 gl_vertex3f(-1, -0.2, 0);

367

368 gl_texcoord2f(1, 1);

369 gl_vertex3f(1, -0.2, 0);

370

371 gl_texcoord2f(1, 0);

372 gl_vertex3f(1, 0.2, 0);

373

374 gl_texcoord2f(0, 0);

375 gl_vertex3f(-1, 0.2, 0);

376 gl_end();

377

378 bind_texture(0, 0);

379 glDisable(GL_BLEND);

380

381 gl_pop_matrix();

382 }

383

384

385 static void worm(float t, float z, float *tx, float *ty)

386 {

387 float x, y;

388 x = sin(t) + cos(t + z) + sin(t * 2.0 + z) / 2.0;

389 y = cos(t) + sin(t + z) + cos(t * 2.0 + z) / 2.0;

390

391 *tx = x * 0.5;

392 *ty = y * 0.5;

393 }

394

395

396 void reshape(int x, int y)

397 {

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

399

400 float aspect = (float)x / (float)y;

401 float maxfov = 40.0;

402 float vfov = aspect > 1.0 ? maxfov / aspect : maxfov;

403

404 cam_fov(vfov);

405

406 gl_matrix_mode(GL_PROJECTION);

407 gl_load_identity();

408 glu_perspective(vfov, aspect, 0.5, 500.0);

409

410 view_xsz = x;

411 view_ysz = y;

412 view_aspect = aspect;

413

414 ui_reshape(x, y);

415 }

416

417 void mouse_button(int bn, int press, int x, int y)

418 {

419 if(show_opt) {

420 ui_button(bn, press, x, y);

421 }

422 }

423

424 void mouse_motion(int x, int y)

425 {

426 if(show_opt) {

427 ui_motion(x, y);

428 }

429 }

430

431 static unsigned int get_shader_program(const char *vfile, const char *pfile)

432 {

433 unsigned int prog, vs, ps;

434

435 if(!(vs = get_vertex_shader(find_resource(vfile, 0, 0)))) {

436 return 0;

437 }

438 if(!(ps = get_pixel_shader(find_resource(pfile, 0, 0)))) {

439 return 0;

440 }

441

442 if(!(prog = create_program_link(vs, ps))) {

443 return 0;

444 }

445 return prog;

446 }