oculus2_psprite
view src/main.c @ 8:4d6733229e01
porting to 0.4.3 (finally on linux)
| author | John Tsiombikas <nuclear@member.fsf.org> |
|---|---|
| date | Sat, 25 Oct 2014 20:07:24 +0300 |
| parents | cd9f1560b909 |
| children | 9c36ae39ad95 |
line source
1 /* Very simple OculusSDK OpenGL usage example.
2 * Uses SDL2 for event handling and OpenGL context management.
3 *
4 * Author: John Tsiombikas <nuclear@member.fsf.org>
5 * This code is in the public domain. Do whatever you like with it.
6 */
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <assert.h>
10 #include <SDL2/SDL.h>
11 #include <GL/glew.h>
13 #ifdef WIN32
14 #define OVR_OS_WIN32
15 #endif
16 #ifdef __APPLE__
17 #define OVR_OS_MAC
18 #endif
20 #include <OVR_CAPI.h>
21 #include <OVR_CAPI_GL.h>
23 int init(void);
24 void cleanup(void);
25 void toggle_hmd_fullscreen(void);
26 void display(void);
27 void draw_scene(void);
28 void draw_box(float xsz, float ysz, float zsz, float norm_sign);
29 void update_rtarg(int width, int height);
30 int handle_event(SDL_Event *ev);
31 int key_event(int key, int state);
32 void reshape(int x, int y);
33 unsigned int next_pow2(unsigned int x);
34 void quat_to_matrix(const float *quat, float *mat);
35 unsigned int gen_chess_tex(float r0, float g0, float b0, float r1, float g1, float b1);
37 /* forward declaration to avoid including non-public headers of libovr */
38 OVR_EXPORT void ovrhmd_EnableHSWDisplaySDKRender(ovrHmd hmd, ovrBool enable);
40 static SDL_Window *win;
41 static SDL_GLContext ctx;
42 static int win_width, win_height;
44 static unsigned int fbo, fb_tex, fb_depth;
45 static int fb_width, fb_height;
46 static int fb_tex_width, fb_tex_height;
48 static ovrHmd hmd;
49 static ovrSizei eyeres[2];
50 static ovrEyeRenderDesc eye_rdesc[2];
51 static ovrGLTexture fb_ovr_tex[2];
53 static unsigned int chess_tex;
56 int main(int argc, char **argv)
57 {
58 if(init() == -1) {
59 return 1;
60 }
62 for(;;) {
63 SDL_Event ev;
64 while(SDL_PollEvent(&ev)) {
65 if(handle_event(&ev) == -1) {
66 goto done;
67 }
68 }
69 display();
70 }
72 done:
73 cleanup();
74 return 0;
75 }
78 int init(void)
79 {
80 int i, x, y;
81 unsigned int flags, dcaps;
82 union ovrGLConfig glcfg;
84 /* libovr must be initialized before we create the OpenGL context */
85 ovr_Initialize();
87 SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
89 x = y = SDL_WINDOWPOS_UNDEFINED;
90 flags = SDL_WINDOW_OPENGL;
91 if(!(win = SDL_CreateWindow("press 'f' to move to the HMD", x, y, 1280, 800, flags))) {
92 fprintf(stderr, "failed to create window\n");
93 return -1;
94 }
95 if(!(ctx = SDL_GL_CreateContext(win))) {
96 fprintf(stderr, "failed to create OpenGL context\n");
97 return -1;
98 }
100 glewInit();
102 if(!(hmd = ovrHmd_Create(0))) {
103 fprintf(stderr, "failed to open Oculus HMD, falling back to virtual debug HMD\n");
104 if(!(hmd = ovrHmd_CreateDebug(ovrHmd_DK2))) {
105 fprintf(stderr, "failed to create virtual debug HMD\n");
106 return -1;
107 }
108 }
109 printf("initialized HMD: %s - %s\n", hmd->Manufacturer, hmd->ProductName);
111 /* resize our window to match the HMD resolution */
112 SDL_SetWindowSize(win, hmd->Resolution.w, hmd->Resolution.h);
113 SDL_SetWindowPosition(win, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
114 win_width = hmd->Resolution.w;
115 win_height = hmd->Resolution.h;
117 /* enable position and rotation tracking (and anything else they might add in the future) */
118 ovrHmd_ConfigureTracking(hmd, 0xffffffff, 0);
119 /* retrieve the optimal render target resolution for each eye */
120 eyeres[0] = ovrHmd_GetFovTextureSize(hmd, ovrEye_Left, hmd->DefaultEyeFov[0], 1.0);
121 eyeres[1] = ovrHmd_GetFovTextureSize(hmd, ovrEye_Right, hmd->DefaultEyeFov[1], 1.0);
123 /* and create a single render target texture to encompass both eyes */
124 fb_width = eyeres[0].w + eyeres[1].w;
125 fb_height = eyeres[0].h > eyeres[1].h ? eyeres[0].h : eyeres[1].h;
126 update_rtarg(fb_width, fb_height);
128 /* fill in the ovrGLTexture structures that describe our render target texture */
129 for(i=0; i<2; i++) {
130 fb_ovr_tex[i].OGL.Header.API = ovrRenderAPI_OpenGL;
131 fb_ovr_tex[i].OGL.Header.TextureSize.w = fb_tex_width;
132 fb_ovr_tex[i].OGL.Header.TextureSize.h = fb_tex_height;
133 /* this next field is the only one that differs between the two eyes */
134 fb_ovr_tex[i].OGL.Header.RenderViewport.Pos.x = i == 0 ? 0 : fb_width / 2.0;
135 fb_ovr_tex[i].OGL.Header.RenderViewport.Pos.y = fb_tex_height - fb_height;
136 fb_ovr_tex[i].OGL.Header.RenderViewport.Size.w = fb_width / 2.0;
137 fb_ovr_tex[i].OGL.Header.RenderViewport.Size.h = fb_height;
138 fb_ovr_tex[i].OGL.TexId = fb_tex; /* both eyes will use the same texture id */
139 }
141 /* fill in the ovrGLConfig structure needed by the SDK to draw our stereo pair
142 * to the actual HMD display (SDK-distortion mode)
143 */
144 memset(&glcfg, 0, sizeof glcfg);
145 glcfg.OGL.Header.API = ovrRenderAPI_OpenGL;
146 glcfg.OGL.Header.RTSize = hmd->Resolution;
147 glcfg.OGL.Header.Multisample = 1;
149 if(hmd->HmdCaps & ovrHmdCap_ExtendDesktop) {
150 printf("running in \"extended desktop\" mode\n");
151 } else {
152 /* to sucessfully draw to the HMD display in "direct-hmd" mode, we have to
153 * call ovrHmd_AttachToWindow
154 * XXX: this doesn't work properly yet due to bugs in the oculus 0.4.1 sdk/driver
155 */
156 #ifdef WIN32
157 void *sys_win = GetActiveWindow();
158 glcfg.OGL.Window = sys_win;
159 glcfg.OGL.DC = wglGetCurrentDC();
160 ovrHmd_AttachToWindow(hmd, sys_win, 0, 0);
161 #endif
162 printf("running in \"direct-hmd\" mode\n");
163 }
165 /* enable low-persistence display and dynamic prediction for lattency compensation */
166 ovrHmd_SetEnabledCaps(hmd, ovrHmdCap_LowPersistence | ovrHmdCap_DynamicPrediction);
168 /* configure SDK-rendering and enable chromatic abberation correction, vignetting, and
169 * timewrap, which shifts the image before drawing to counter any lattency between the call
170 * to ovrHmd_GetEyePose and ovrHmd_EndFrame.
171 */
172 dcaps = ovrDistortionCap_Chromatic | ovrDistortionCap_Vignette | ovrDistortionCap_TimeWarp;
173 if(!ovrHmd_ConfigureRendering(hmd, &glcfg.Config, dcaps, hmd->DefaultEyeFov, eye_rdesc)) {
174 fprintf(stderr, "failed to configure distortion renderer\n");
175 }
177 /* disable the retarded "health and safety warning" */
178 ovrhmd_EnableHSWDisplaySDKRender(hmd, 0);
180 glEnable(GL_DEPTH_TEST);
181 glEnable(GL_CULL_FACE);
182 glEnable(GL_LIGHTING);
183 glEnable(GL_LIGHT0);
184 glEnable(GL_LIGHT1);
185 glEnable(GL_NORMALIZE);
187 glClearColor(0.1, 0.1, 0.1, 1);
189 chess_tex = gen_chess_tex(1.0, 0.7, 0.4, 0.4, 0.7, 1.0);
190 return 0;
191 }
193 void cleanup(void)
194 {
195 if(hmd) {
196 ovrHmd_Destroy(hmd);
197 }
198 ovr_Shutdown();
200 SDL_Quit();
201 }
203 void toggle_hmd_fullscreen(void)
204 {
205 static int fullscr, prev_x, prev_y;
206 fullscr = !fullscr;
208 if(fullscr) {
209 /* going fullscreen on the rift. save current window position, and move it
210 * to the rift's part of the desktop before going fullscreen
211 */
212 SDL_GetWindowPosition(win, &prev_x, &prev_y);
213 SDL_SetWindowPosition(win, hmd->WindowsPos.x, hmd->WindowsPos.y);
214 SDL_SetWindowFullscreen(win, SDL_WINDOW_FULLSCREEN_DESKTOP);
215 } else {
216 /* return to windowed mode and move the window back to its original position */
217 SDL_SetWindowFullscreen(win, 0);
218 SDL_SetWindowPosition(win, prev_x, prev_y);
219 }
220 }
222 void display(void)
223 {
224 int i;
225 ovrMatrix4f proj;
226 ovrPosef pose[2];
227 float rot_mat[16];
229 /* the drawing starts with a call to ovrHmd_BeginFrame */
230 ovrHmd_BeginFrame(hmd, 0);
232 /* start drawing onto our texture render target */
233 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
234 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
236 /* for each eye ... */
237 for(i=0; i<2; i++) {
238 int eye = hmd->EyeRenderOrder[i];
240 /* -- viewport transformation --
241 * setup the viewport to draw in the left half of the framebuffer when we're
242 * rendering the left eye's view (0, 0, width/2, height), and in the right half
243 * of the framebuffer for the right eye's view (width/2, 0, width/2, height)
244 */
245 glViewport(eye == 0 ? 0 : fb_width / 2, 0, fb_width / 2, fb_height);
247 /* -- projection transformation --
248 * we'll just have to use the projection matrix supplied by the oculus SDK for this eye
249 * note that libovr matrices are the transpose of what OpenGL expects, so we have to
250 * use glLoadTransposeMatrixf instead of glLoadMatrixf to load it.
251 */
252 proj = ovrMatrix4f_Projection(hmd->DefaultEyeFov[eye], 0.5, 500.0, 1);
253 glMatrixMode(GL_PROJECTION);
254 glLoadTransposeMatrixf(proj.M[0]);
256 /* -- view/camera transformation --
257 * we need to construct a view matrix by combining all the information provided by the oculus
258 * SDK, about the position and orientation of the user's head in the world.
259 */
260 /* TODO: use ovrHmd_GetEyePoses out of the loop instead */
261 pose[eye] = ovrHmd_GetHmdPosePerEye(hmd, eye);
262 glMatrixMode(GL_MODELVIEW);
263 glLoadIdentity();
264 glTranslatef(eye_rdesc[eye].HmdToEyeViewOffset.x,
265 eye_rdesc[eye].HmdToEyeViewOffset.y,
266 eye_rdesc[eye].HmdToEyeViewOffset.z);
267 /* retrieve the orientation quaternion and convert it to a rotation matrix */
268 quat_to_matrix(&pose[eye].Orientation.x, rot_mat);
269 glMultMatrixf(rot_mat);
270 /* translate the view matrix with the positional tracking */
271 glTranslatef(-pose[eye].Position.x, -pose[eye].Position.y, -pose[eye].Position.z);
272 /* move the camera to the eye level of the user */
273 glTranslatef(0, -ovrHmd_GetFloat(hmd, OVR_KEY_EYE_HEIGHT, 1.65), 0);
275 /* finally draw the scene for this eye */
276 draw_scene();
277 }
279 /* after drawing both eyes into the texture render target, revert to drawing directly to the
280 * display, and we call ovrHmd_EndFrame, to let the Oculus SDK draw both images properly
281 * compensated for lens distortion and chromatic abberation onto the HMD screen.
282 */
283 glBindFramebuffer(GL_FRAMEBUFFER, 0);
284 glViewport(0, 0, win_width, win_height);
286 ovrHmd_EndFrame(hmd, pose, &fb_ovr_tex[0].Texture);
288 assert(glGetError() == GL_NO_ERROR);
289 }
291 void draw_scene(void)
292 {
293 int i;
294 float grey[] = {0.8, 0.8, 0.8, 1};
295 float col[] = {0, 0, 0, 1};
296 float lpos[][4] = {
297 {-8, 2, 10, 1},
298 {0, 15, 0, 1}
299 };
300 float lcol[][4] = {
301 {0.8, 0.8, 0.8, 1},
302 {0.4, 0.3, 0.3, 1}
303 };
305 for(i=0; i<2; i++) {
306 glLightfv(GL_LIGHT0 + i, GL_POSITION, lpos[i]);
307 glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, lcol[i]);
308 }
310 glMatrixMode(GL_MODELVIEW);
312 glPushMatrix();
313 glTranslatef(0, 10, 0);
314 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, grey);
315 glBindTexture(GL_TEXTURE_2D, chess_tex);
316 glEnable(GL_TEXTURE_2D);
317 draw_box(30, 20, 30, -1.0);
318 glDisable(GL_TEXTURE_2D);
319 glPopMatrix();
321 for(i=0; i<4; i++) {
322 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, grey);
323 glPushMatrix();
324 glTranslatef(i & 1 ? 5 : -5, 1, i & 2 ? -5 : 5);
325 draw_box(0.5, 2, 0.5, 1.0);
326 glPopMatrix();
328 col[0] = i & 1 ? 1.0 : 0.3;
329 col[1] = i == 0 ? 1.0 : 0.3;
330 col[2] = i & 2 ? 1.0 : 0.3;
331 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, col);
333 glPushMatrix();
334 if(i & 1) {
335 glTranslatef(0, 0.25, i & 2 ? 2 : -2);
336 } else {
337 glTranslatef(i & 2 ? 2 : -2, 0.25, 0);
338 }
339 draw_box(0.5, 0.5, 0.5, 1.0);
340 glPopMatrix();
341 }
342 }
344 void draw_box(float xsz, float ysz, float zsz, float norm_sign)
345 {
346 glMatrixMode(GL_MODELVIEW);
347 glScalef(xsz * 0.5, ysz * 0.5, zsz * 0.5);
349 if(norm_sign < 0.0) {
350 glFrontFace(GL_CW);
351 }
353 glBegin(GL_QUADS);
354 glNormal3f(0, 0, 1 * norm_sign);
355 glTexCoord2f(0, 0); glVertex3f(-1, -1, 1);
356 glTexCoord2f(1, 0); glVertex3f(1, -1, 1);
357 glTexCoord2f(1, 1); glVertex3f(1, 1, 1);
358 glTexCoord2f(0, 1); glVertex3f(-1, 1, 1);
359 glNormal3f(1 * norm_sign, 0, 0);
360 glTexCoord2f(0, 0); glVertex3f(1, -1, 1);
361 glTexCoord2f(1, 0); glVertex3f(1, -1, -1);
362 glTexCoord2f(1, 1); glVertex3f(1, 1, -1);
363 glTexCoord2f(0, 1); glVertex3f(1, 1, 1);
364 glNormal3f(0, 0, -1 * norm_sign);
365 glTexCoord2f(0, 0); glVertex3f(1, -1, -1);
366 glTexCoord2f(1, 0); glVertex3f(-1, -1, -1);
367 glTexCoord2f(1, 1); glVertex3f(-1, 1, -1);
368 glTexCoord2f(0, 1); glVertex3f(1, 1, -1);
369 glNormal3f(-1 * norm_sign, 0, 0);
370 glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
371 glTexCoord2f(1, 0); glVertex3f(-1, -1, 1);
372 glTexCoord2f(1, 1); glVertex3f(-1, 1, 1);
373 glTexCoord2f(0, 1); glVertex3f(-1, 1, -1);
374 glEnd();
375 glBegin(GL_TRIANGLE_FAN);
376 glNormal3f(0, 1 * norm_sign, 0);
377 glTexCoord2f(0.5, 0.5); glVertex3f(0, 1, 0);
378 glTexCoord2f(0, 0); glVertex3f(-1, 1, 1);
379 glTexCoord2f(1, 0); glVertex3f(1, 1, 1);
380 glTexCoord2f(1, 1); glVertex3f(1, 1, -1);
381 glTexCoord2f(0, 1); glVertex3f(-1, 1, -1);
382 glTexCoord2f(0, 0); glVertex3f(-1, 1, 1);
383 glEnd();
384 glBegin(GL_TRIANGLE_FAN);
385 glNormal3f(0, -1 * norm_sign, 0);
386 glTexCoord2f(0.5, 0.5); glVertex3f(0, -1, 0);
387 glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
388 glTexCoord2f(1, 0); glVertex3f(1, -1, -1);
389 glTexCoord2f(1, 1); glVertex3f(1, -1, 1);
390 glTexCoord2f(0, 1); glVertex3f(-1, -1, 1);
391 glTexCoord2f(0, 0); glVertex3f(-1, -1, -1);
392 glEnd();
394 glFrontFace(GL_CCW);
395 }
397 /* update_rtarg creates (and/or resizes) the render target used to draw the two stero views */
398 void update_rtarg(int width, int height)
399 {
400 if(!fbo) {
401 /* if fbo does not exist, then nothing does... create every opengl object */
402 glGenFramebuffers(1, &fbo);
403 glGenTextures(1, &fb_tex);
404 glGenRenderbuffers(1, &fb_depth);
406 glBindTexture(GL_TEXTURE_2D, fb_tex);
407 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
408 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
409 }
411 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
413 /* calculate the next power of two in both dimensions and use that as a texture size */
414 fb_tex_width = next_pow2(width);
415 fb_tex_height = next_pow2(height);
417 /* create and attach the texture that will be used as a color buffer */
418 glBindTexture(GL_TEXTURE_2D, fb_tex);
419 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, fb_tex_width, fb_tex_height, 0,
420 GL_RGBA, GL_UNSIGNED_BYTE, 0);
421 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fb_tex, 0);
423 /* create and attach the renderbuffer that will serve as our z-buffer */
424 glBindRenderbuffer(GL_RENDERBUFFER, fb_depth);
425 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, fb_tex_width, fb_tex_height);
426 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fb_depth);
428 if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
429 fprintf(stderr, "incomplete framebuffer!\n");
430 }
432 glBindFramebuffer(GL_FRAMEBUFFER, 0);
433 printf("created render target: %dx%d (texture size: %dx%d)\n", width, height, fb_tex_width, fb_tex_height);
434 }
436 int handle_event(SDL_Event *ev)
437 {
438 switch(ev->type) {
439 case SDL_QUIT:
440 return -1;
442 case SDL_KEYDOWN:
443 case SDL_KEYUP:
444 if(key_event(ev->key.keysym.sym, ev->key.state == SDL_PRESSED) == -1) {
445 return -1;
446 }
447 break;
449 default:
450 break;
451 }
453 return 0;
454 }
456 int key_event(int key, int state)
457 {
458 if(state) {
459 /*
460 ovrHSWDisplayState hsw;
461 ovrHmd_GetHSWDisplayState(hmd, &hsw);
462 if(hsw.Displayed) {
463 ovrHmd_DismissHSWDisplay(hmd);
464 }
465 */
467 switch(key) {
468 case 27:
469 return -1;
471 case ' ':
472 /* allow the user to recenter by pressing space */
473 ovrHmd_RecenterPose(hmd);
474 break;
476 case 'f':
477 /* press f to move the window to the HMD */
478 toggle_hmd_fullscreen();
479 break;
481 default:
482 break;
483 }
484 }
485 return 0;
486 }
488 unsigned int next_pow2(unsigned int x)
489 {
490 x -= 1;
491 x |= x >> 1;
492 x |= x >> 2;
493 x |= x >> 4;
494 x |= x >> 8;
495 x |= x >> 16;
496 return x + 1;
497 }
499 /* convert a quaternion to a rotation matrix */
500 void quat_to_matrix(const float *quat, float *mat)
501 {
502 mat[0] = 1.0 - 2.0 * quat[1] * quat[1] - 2.0 * quat[2] * quat[2];
503 mat[4] = 2.0 * quat[0] * quat[1] + 2.0 * quat[3] * quat[2];
504 mat[8] = 2.0 * quat[2] * quat[0] - 2.0 * quat[3] * quat[1];
505 mat[12] = 0.0f;
507 mat[1] = 2.0 * quat[0] * quat[1] - 2.0 * quat[3] * quat[2];
508 mat[5] = 1.0 - 2.0 * quat[0]*quat[0] - 2.0 * quat[2]*quat[2];
509 mat[9] = 2.0 * quat[1] * quat[2] + 2.0 * quat[3] * quat[0];
510 mat[13] = 0.0f;
512 mat[2] = 2.0 * quat[2] * quat[0] + 2.0 * quat[3] * quat[1];
513 mat[6] = 2.0 * quat[1] * quat[2] - 2.0 * quat[3] * quat[0];
514 mat[10] = 1.0 - 2.0 * quat[0]*quat[0] - 2.0 * quat[1]*quat[1];
515 mat[14] = 0.0f;
517 mat[3] = mat[7] = mat[11] = 0.0f;
518 mat[15] = 1.0f;
519 }
521 /* generate a chessboard texture with tiles colored (r0, g0, b0) and (r1, g1, b1) */
522 unsigned int gen_chess_tex(float r0, float g0, float b0, float r1, float g1, float b1)
523 {
524 int i, j;
525 unsigned int tex;
526 unsigned char img[8 * 8 * 3];
527 unsigned char *pix = img;
529 for(i=0; i<8; i++) {
530 for(j=0; j<8; j++) {
531 int black = (i & 1) == (j & 1);
532 pix[0] = (black ? r0 : r1) * 255;
533 pix[1] = (black ? g0 : g1) * 255;
534 pix[2] = (black ? b0 : b1) * 255;
535 pix += 3;
536 }
537 }
539 glGenTextures(1, &tex);
540 glBindTexture(GL_TEXTURE_2D, tex);
541 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
542 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
543 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, img);
545 return tex;
546 }