main.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404
  1. /*
  2. * OpenHMD - Free and Open Source API and drivers for immersive technology.
  3. * Copyright (C) 2013 Fredrik Hultin.
  4. * Copyright (C) 2013 Jakob Bornecrantz.
  5. * Distributed under the Boost 1.0 licence, see LICENSE for full text.
  6. */
  7. /* OpenGL Test - Main Implementation */
  8. #include <openhmd.h>
  9. #include <stdbool.h>
  10. #include <assert.h>
  11. #include <math.h>
  12. #include "gl.h"
  13. #define OVERSAMPLE_SCALE 2.0
  14. char* read_file(const char* filename)
  15. {
  16. FILE* f = fopen(filename, "rb");
  17. fseek(f, 0, SEEK_END);
  18. long len = ftell(f);
  19. fseek(f, 0, SEEK_SET);
  20. char* buffer = calloc(1, len + 1);
  21. assert(buffer);
  22. size_t ret = fread(buffer, len, 1, f);
  23. assert(ret);
  24. fclose(f);
  25. return buffer;
  26. }
  27. float randf()
  28. {
  29. return (float)rand() / (float)RAND_MAX;
  30. }
  31. GLuint gen_cubes()
  32. {
  33. GLuint list = glGenLists(1);
  34. // Set the random seed.
  35. srand(42);
  36. glNewList(list, GL_COMPILE);
  37. for(float a = 0.0f; a < 360.0f; a += 20.0f){
  38. glPushMatrix();
  39. glRotatef(a, 0, 1, 0);
  40. glTranslatef(0, 0, -1);
  41. glScalef(0.2, 0.2, 0.2);
  42. glRotatef(randf() * 360, randf(), randf(), randf());
  43. glColor4f(randf(), randf(), randf(), randf() * .5f + .5f);
  44. draw_cube();
  45. glPopMatrix();
  46. }
  47. // draw floor
  48. glColor4f(0, 1.0f, .25f, .25f);
  49. glTranslatef(0, -2.5f, 0);
  50. draw_cube();
  51. glEndList();
  52. return list;
  53. }
  54. void draw_crosshairs(float len, float cx, float cy)
  55. {
  56. glMatrixMode(GL_MODELVIEW);
  57. glPushMatrix();
  58. glLoadIdentity();
  59. glMatrixMode(GL_PROJECTION);
  60. glPushMatrix();
  61. glLoadIdentity();
  62. glBegin(GL_LINES);
  63. float l = len/2.0f;
  64. glVertex3f(cx - l, cy, 0.0);
  65. glVertex3f(cx + l, cy, 0.0);
  66. glVertex3f(cx, cy - l, 0.0);
  67. glVertex3f(cx, cy + l, 0.0);
  68. glEnd();
  69. glMatrixMode(GL_PROJECTION);
  70. glPopMatrix();
  71. glMatrixMode(GL_MODELVIEW);
  72. glPopMatrix();
  73. }
  74. void draw_scene(GLuint list)
  75. {
  76. // draw cubes
  77. glCallList(list);
  78. }
  79. static inline void
  80. print_matrix(float m[])
  81. {
  82. printf("[[%0.4f, %0.4f, %0.4f, %0.4f],\n"
  83. "[%0.4f, %0.4f, %0.4f, %0.4f],\n"
  84. "[%0.4f, %0.4f, %0.4f, %0.4f],\n"
  85. "[%0.4f, %0.4f, %0.4f, %0.4f]]\n",
  86. m[0], m[4], m[8], m[12],
  87. m[1], m[5], m[9], m[13],
  88. m[2], m[6], m[10], m[14],
  89. m[3], m[7], m[11], m[15]);
  90. }
  91. int main(int argc, char** argv)
  92. {
  93. int hmd_w, hmd_h;
  94. ohmd_context* ctx = ohmd_ctx_create();
  95. int num_devices = ohmd_ctx_probe(ctx);
  96. if(num_devices < 0){
  97. printf("failed to probe devices: %s\n", ohmd_ctx_get_error(ctx));
  98. return 1;
  99. }
  100. ohmd_device_settings* settings = ohmd_device_settings_create(ctx);
  101. // If OHMD_IDS_AUTOMATIC_UPDATE is set to 0, ohmd_ctx_update() must be called at least 10 times per second.
  102. // It is enabled by default.
  103. int auto_update = 1;
  104. ohmd_device_settings_seti(settings, OHMD_IDS_AUTOMATIC_UPDATE, &auto_update);
  105. ohmd_device* hmd = ohmd_list_open_device_s(ctx, 0, settings);
  106. ohmd_device_geti(hmd, OHMD_SCREEN_HORIZONTAL_RESOLUTION, &hmd_w);
  107. ohmd_device_geti(hmd, OHMD_SCREEN_VERTICAL_RESOLUTION, &hmd_h);
  108. float ipd;
  109. ohmd_device_getf(hmd, OHMD_EYE_IPD, &ipd);
  110. float viewport_scale[2];
  111. float distortion_coeffs[4];
  112. float aberr_scale[3];
  113. float sep;
  114. float left_lens_center[2];
  115. float right_lens_center[2];
  116. //viewport is half the screen
  117. ohmd_device_getf(hmd, OHMD_SCREEN_HORIZONTAL_SIZE, &(viewport_scale[0]));
  118. viewport_scale[0] /= 2.0f;
  119. ohmd_device_getf(hmd, OHMD_SCREEN_VERTICAL_SIZE, &(viewport_scale[1]));
  120. //distortion coefficients
  121. ohmd_device_getf(hmd, OHMD_UNIVERSAL_DISTORTION_K, &(distortion_coeffs[0]));
  122. ohmd_device_getf(hmd, OHMD_UNIVERSAL_ABERRATION_K, &(aberr_scale[0]));
  123. //calculate lens centers (assuming the eye separation is the distance between the lens centers)
  124. ohmd_device_getf(hmd, OHMD_LENS_HORIZONTAL_SEPARATION, &sep);
  125. ohmd_device_getf(hmd, OHMD_LENS_VERTICAL_POSITION, &(left_lens_center[1]));
  126. ohmd_device_getf(hmd, OHMD_LENS_VERTICAL_POSITION, &(right_lens_center[1]));
  127. left_lens_center[0] = viewport_scale[0] - sep/2.0f;
  128. right_lens_center[0] = sep/2.0f;
  129. //assume calibration was for lens view to which ever edge of screen is further away from lens center
  130. float warp_scale = (left_lens_center[0] > right_lens_center[0]) ? left_lens_center[0] : right_lens_center[0];
  131. float warp_adj = 1.0f;
  132. ohmd_device_settings_destroy(settings);
  133. if(!hmd){
  134. printf("failed to open device: %s\n", ohmd_ctx_get_error(ctx));
  135. return 1;
  136. }
  137. gl_ctx gl;
  138. init_gl(&gl, hmd_w, hmd_h);
  139. SDL_ShowCursor(SDL_DISABLE);
  140. const char* vertex;
  141. ohmd_gets(OHMD_GLSL_DISTORTION_VERT_SRC, &vertex);
  142. const char* fragment;
  143. ohmd_gets(OHMD_GLSL_DISTORTION_FRAG_SRC, &fragment);
  144. GLuint shader = compile_shader(vertex, fragment);
  145. glUseProgram(shader);
  146. glUniform1i(glGetUniformLocation(shader, "warpTexture"), 0);
  147. glUniform2fv(glGetUniformLocation(shader, "ViewportScale"), 1, viewport_scale);
  148. glUniform3fv(glGetUniformLocation(shader, "aberr"), 1, aberr_scale);
  149. glUseProgram(0);
  150. GLuint list = gen_cubes();
  151. int eye_w = hmd_w/2*OVERSAMPLE_SCALE;
  152. int eye_h = hmd_h*OVERSAMPLE_SCALE;
  153. GLuint left_color_tex = 0, left_depth_tex = 0, left_fbo = 0;
  154. create_fbo(eye_w, eye_h, &left_fbo, &left_color_tex, &left_depth_tex);
  155. GLuint right_color_tex = 0, right_depth_tex = 0, right_fbo = 0;
  156. create_fbo(eye_w, eye_h, &right_fbo, &right_color_tex, &right_depth_tex);
  157. bool done = false;
  158. bool crosshair_overlay = false;
  159. while(!done){
  160. ohmd_ctx_update(ctx);
  161. SDL_Event event;
  162. while(SDL_PollEvent(&event)){
  163. if(event.type == SDL_KEYDOWN){
  164. switch(event.key.keysym.sym){
  165. case SDLK_ESCAPE:
  166. done = true;
  167. break;
  168. case SDLK_F1:
  169. {
  170. gl.is_fullscreen = !gl.is_fullscreen;
  171. SDL_SetWindowFullscreen(gl.window, gl.is_fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
  172. }
  173. break;
  174. case SDLK_F2:
  175. {
  176. // reset rotation and position
  177. float zero[] = {0, 0, 0, 1};
  178. ohmd_device_setf(hmd, OHMD_ROTATION_QUAT, zero);
  179. ohmd_device_setf(hmd, OHMD_POSITION_VECTOR, zero);
  180. }
  181. break;
  182. case SDLK_F3:
  183. {
  184. float mat[16];
  185. ohmd_device_getf(hmd, OHMD_LEFT_EYE_GL_PROJECTION_MATRIX, mat);
  186. printf("Projection L: ");
  187. print_matrix(mat);
  188. printf("\n");
  189. ohmd_device_getf(hmd, OHMD_RIGHT_EYE_GL_PROJECTION_MATRIX, mat);
  190. printf("Projection R: ");
  191. print_matrix(mat);
  192. printf("\n");
  193. ohmd_device_getf(hmd, OHMD_LEFT_EYE_GL_MODELVIEW_MATRIX, mat);
  194. printf("View: ");
  195. print_matrix(mat);
  196. printf("\n");
  197. printf("viewport_scale: [%0.4f, %0.4f]\n", viewport_scale[0], viewport_scale[1]);
  198. printf("lens separation: %04f\n", sep);
  199. printf("IPD: %0.4f\n", ipd);
  200. printf("warp_scale: %0.4f\r\n", warp_scale);
  201. printf("distortion coeffs: [%0.4f, %0.4f, %0.4f, %0.4f]\n", distortion_coeffs[0], distortion_coeffs[1], distortion_coeffs[2], distortion_coeffs[3]);
  202. printf("aberration coeffs: [%0.4f, %0.4f, %0.4f]\n", aberr_scale[0], aberr_scale[1], aberr_scale[2]);
  203. printf("left_lens_center: [%0.4f, %0.4f]\n", left_lens_center[0], left_lens_center[1]);
  204. printf("right_lens_center: [%0.4f, %0.4f]\n", right_lens_center[0], right_lens_center[1]);
  205. }
  206. break;
  207. case SDLK_w:
  208. sep += 0.001;
  209. left_lens_center[0] = viewport_scale[0] - sep/2.0f;
  210. right_lens_center[0] = sep/2.0f;
  211. break;
  212. case SDLK_q:
  213. sep -= 0.001;
  214. left_lens_center[0] = viewport_scale[0] - sep/2.0f;
  215. right_lens_center[0] = sep/2.0f;
  216. break;
  217. case SDLK_a:
  218. warp_adj *= 1.0/0.9;
  219. break;
  220. case SDLK_z:
  221. warp_adj *= 0.9;
  222. break;
  223. case SDLK_i:
  224. ipd -= 0.001;
  225. ohmd_device_setf(hmd, OHMD_EYE_IPD, &ipd);
  226. break;
  227. case SDLK_o:
  228. ipd += 0.001;
  229. ohmd_device_setf(hmd, OHMD_EYE_IPD, &ipd);
  230. break;
  231. case SDLK_d:
  232. /* toggle between distorted and undistorted views */
  233. if ((distortion_coeffs[0] != 0.0) ||
  234. (distortion_coeffs[1] != 0.0) ||
  235. (distortion_coeffs[2] != 0.0) ||
  236. (distortion_coeffs[3] != 1.0)) {
  237. distortion_coeffs[0] = 0.0;
  238. distortion_coeffs[1] = 0.0;
  239. distortion_coeffs[2] = 0.0;
  240. distortion_coeffs[3] = 1.0;
  241. } else {
  242. ohmd_device_getf(hmd, OHMD_UNIVERSAL_DISTORTION_K, &(distortion_coeffs[0]));
  243. }
  244. break;
  245. case SDLK_x:
  246. crosshair_overlay = ! crosshair_overlay;
  247. break;
  248. default:
  249. break;
  250. }
  251. }
  252. }
  253. // Common scene state
  254. glEnable(GL_BLEND);
  255. glEnable(GL_DEPTH_TEST);
  256. float matrix[16];
  257. // set hmd rotation, for left eye.
  258. glMatrixMode(GL_PROJECTION);
  259. ohmd_device_getf(hmd, OHMD_LEFT_EYE_GL_PROJECTION_MATRIX, matrix);
  260. glLoadMatrixf(matrix);
  261. glMatrixMode(GL_MODELVIEW);
  262. ohmd_device_getf(hmd, OHMD_LEFT_EYE_GL_MODELVIEW_MATRIX, matrix);
  263. glLoadMatrixf(matrix);
  264. // Draw scene into framebuffer.
  265. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, left_fbo);
  266. glViewport(0, 0, eye_w, eye_h);
  267. glClearColor(0.0, 0.0, 0.0, 1.0);
  268. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  269. draw_scene(list);
  270. if (crosshair_overlay) {
  271. glClear(GL_DEPTH_BUFFER_BIT);
  272. glLineWidth(2.0*OVERSAMPLE_SCALE);
  273. glColor4f(1.0, 0.5, 0.0, 1.0);
  274. draw_crosshairs(0.1, 2*left_lens_center[0]/viewport_scale[0] - 1.0f, 2*left_lens_center[1]/viewport_scale[1] - 1.0f);
  275. }
  276. // set hmd rotation, for right eye.
  277. glMatrixMode(GL_PROJECTION);
  278. ohmd_device_getf(hmd, OHMD_RIGHT_EYE_GL_PROJECTION_MATRIX, matrix);
  279. glLoadMatrixf(matrix);
  280. glMatrixMode(GL_MODELVIEW);
  281. ohmd_device_getf(hmd, OHMD_RIGHT_EYE_GL_MODELVIEW_MATRIX, matrix);
  282. glLoadMatrixf(matrix);
  283. // Draw scene into framebuffer.
  284. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, right_fbo);
  285. glViewport(0, 0, eye_w, eye_h);
  286. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  287. draw_scene(list);
  288. if (crosshair_overlay) {
  289. glClear(GL_DEPTH_BUFFER_BIT);
  290. glLineWidth(5.0);
  291. glColor4f(1.0, 0.5, 0.0, 1.0);
  292. draw_crosshairs(0.1, 2*right_lens_center[0]/viewport_scale[0] - 1.0f, 2*right_lens_center[1]/viewport_scale[1] - 1.0f);
  293. }
  294. // Clean up common draw state
  295. glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
  296. glDisable(GL_BLEND);
  297. glDisable(GL_DEPTH_TEST);
  298. // Setup ortho state.
  299. glUseProgram(shader);
  300. glUniform1f(glGetUniformLocation(shader, "WarpScale"), warp_scale*warp_adj);
  301. glUniform4fv(glGetUniformLocation(shader, "HmdWarpParam"), 1, distortion_coeffs);
  302. glViewport(0, 0, hmd_w, hmd_h);
  303. glEnable(GL_TEXTURE_2D);
  304. glColor4d(1, 1, 1, 1);
  305. // Setup simple render state
  306. glMatrixMode(GL_PROJECTION);
  307. glLoadIdentity();
  308. glMatrixMode(GL_MODELVIEW);
  309. glLoadIdentity();
  310. // Draw left eye
  311. glUniform2fv(glGetUniformLocation(shader, "LensCenter"), 1, left_lens_center);
  312. glBindTexture(GL_TEXTURE_2D, left_color_tex);
  313. glBegin(GL_QUADS);
  314. glTexCoord2d( 0, 0);
  315. glVertex3d( -1, -1, 0);
  316. glTexCoord2d( 1, 0);
  317. glVertex3d( 0, -1, 0);
  318. glTexCoord2d( 1, 1);
  319. glVertex3d( 0, 1, 0);
  320. glTexCoord2d( 0, 1);
  321. glVertex3d( -1, 1, 0);
  322. glEnd();
  323. // Draw right eye
  324. glUniform2fv(glGetUniformLocation(shader, "LensCenter"), 1, right_lens_center);
  325. glBindTexture(GL_TEXTURE_2D, right_color_tex);
  326. glBegin(GL_QUADS);
  327. glTexCoord2d( 0, 0);
  328. glVertex3d( 0, -1, 0);
  329. glTexCoord2d( 1, 0);
  330. glVertex3d( 1, -1, 0);
  331. glTexCoord2d( 1, 1);
  332. glVertex3d( 1, 1, 0);
  333. glTexCoord2d( 0, 1);
  334. glVertex3d( 0, 1, 0);
  335. glEnd();
  336. // Clean up state.
  337. glBindTexture(GL_TEXTURE_2D, 0);
  338. glDisable(GL_TEXTURE_2D);
  339. glUseProgram(0);
  340. // Da swap-dawup!
  341. SDL_GL_SwapWindow(gl.window);
  342. SDL_Delay(10);
  343. }
  344. ohmd_ctx_destroy(ctx);
  345. return 0;
  346. }