oculus1

view src/vr.cc @ 26:75ab0d4ce2bb

find changesets by author, revision, files, or words in the commit message
backed out the shaderless oculus distortion method, as it's completely pointless
author John Tsiombikas <nuclear@member.fsf.org>
date Fri, 04 Oct 2013 14:57:33 +0300
parents ef4c9d8eeca7
children
line source
1 #include <stdio.h>
2 #include <GL/glew.h>
3 #include "vr.h"
4 #include "vr_impl.h"
5 #include "vr_sdr.h"
6
7 #ifndef WIN32
8 #include <alloca.h>
9 #else
10 #include <malloc.h>
11 #endif
12
13 static void init_ctx();
14 static bool init_ovr();
15 static bool init_sdr();
16
17 VRContext vr_ctx;
18 static unsigned int sdrprog;
19
20 extern "C" int vr_init(enum vr_init_mode mode)
21 {
22 glewInit();
23
24 init_ctx();
25
26 if(!init_ovr()) {
27 return -1;
28 }
29
30 if(!init_sdr()) {
31 return -1;
32 }
33
34 return 0;
35 }
36
37 extern "C" void vr_shutdown(void)
38 {
39 delete [] vr_ctx.info.display;
40 //System::Destroy();
41 }
42
43 static void init_ctx()
44 {
45 vr_ctx.info.width = 1280;
46 vr_ctx.info.height = 800;
47 vr_ctx.info.fov = M_PI / 2.0;
48 vr_ctx.info.aspect = (float)vr_ctx.info.width / (float)vr_ctx.info.height;
49 vr_ctx.info.ipd = 0.035;
50 vr_ctx.info.scale = 1.0;
51 }
52
53 static bool init_ovr()
54 {
55 LogMaskConstants log_level = LogMask_All;
56 // initialize Oculus SDK
57 const char *logenv = getenv("VR_LOGLEVEL");
58 if(logenv) {
59 switch(atoi(logenv)) {
60 case 0:
61 log_level = LogMask_None;
62 break;
63 case 1:
64 log_level = LogMask_Regular;
65 break;
66 case 2:
67 default:
68 log_level = LogMask_All;
69 break;
70 }
71 }
72
73 System::Init(Log::ConfigureDefaultLog(log_level));
74 if(!(vr_ctx.ovr_devman = DeviceManager::Create())) {
75 fprintf(stderr, "failed to create OVR device manager\n");
76 return false;
77 }
78
79 // create the display device
80 HMDInfo info;
81 if(!(vr_ctx.ovr_hmd_dev = vr_ctx.ovr_devman->EnumerateDevices<HMDDevice>().CreateDevice())) {
82 fprintf(stderr, "no oculus rift devices found\n");
83 } else {
84 if(vr_ctx.ovr_hmd_dev->GetDeviceInfo(&info)) {
85 printf("oculus device info:\n");
86 printf(" name: %s\n", info.DisplayDeviceName);
87 printf(" ipd: %f\n", info.InterpupillaryDistance);
88 printf(" distortion: %f %f %f %f\n", info.DistortionK[0],
89 info.DistortionK[1], info.DistortionK[2], info.DistortionK[3]);
90 }
91
92 // calculate and store viewing parameters
93 vr_ctx.info.width = info.HResolution;
94 vr_ctx.info.height = info.VResolution;
95 vr_ctx.info.aspect = (float)vr_ctx.info.width / (float)vr_ctx.info.height;
96
97 vr_ctx.info.ipd = info.InterpupillaryDistance;
98 for(int i=0; i<4; i++) {
99 vr_ctx.info.distort[i] = info.DistortionK[i];
100 }
101
102 Util::Render::StereoConfig stereohelp;
103 stereohelp.SetFullViewport(Util::Render::Viewport(0, 0, vr_ctx.info.width, vr_ctx.info.height));
104 stereohelp.SetStereoMode(Util::Render::Stereo_LeftRight_Multipass);
105 stereohelp.SetHMDInfo(info);
106 stereohelp.SetDistortionFitPointVP(-1.0, 0.0);
107
108 vr_ctx.info.scale = stereohelp.GetDistortionScale();
109
110 float vhalfsz = vr_ctx.info.scale * info.VScreenSize * 0.5;
111 vr_ctx.info.fov = 2.0 * atan(vhalfsz / info.EyeToScreenDistance);
112
113 vr_ctx.info.lens_center_offset = 0.5 - info.LensSeparationDistance / info.HScreenSize;
114
115 // calculate center of projection shift to match the lens positions
116 float center_dist_meters = info.HScreenSize * 0.25;
117 float proj_shift = center_dist_meters - info.LensSeparationDistance * 0.5;
118 vr_ctx.info.proj_center_offset = 4.0 * proj_shift / info.HScreenSize;
119
120 // grab the display info
121 vr_ctx.info.display = new char[strlen(info.DisplayDeviceName) + 1];
122 strcpy(vr_ctx.info.display, info.DisplayDeviceName);
123
124 vr_ctx.info.display_xoffs = info.DesktopX;
125 vr_ctx.info.display_yoffs = info.DesktopY;
126
127 printf("display: \"%s\" offset: %+d %+d\n", vr_ctx.info.display,
128 vr_ctx.info.display_xoffs, vr_ctx.info.display_yoffs);
129 }
130
131 // get the sensor device
132 if(vr_ctx.ovr_hmd_dev) {
133 if(!(vr_ctx.ovr_sensor_dev = vr_ctx.ovr_hmd_dev->GetSensor())) {
134 fprintf(stderr, "failed to get oculus sensor device\n");
135 }
136 } else {
137 if(!(vr_ctx.ovr_sensor_dev = vr_ctx.ovr_devman->EnumerateDevices<SensorDevice>().CreateDevice())) {
138 fprintf(stderr, "failed to get oculus sensor device\n");
139 }
140 }
141
142 if(vr_ctx.ovr_sensor_dev) {
143 SensorInfo sinfo;
144 if(vr_ctx.ovr_sensor_dev->GetDeviceInfo(&sinfo)) {
145 printf("oculus sensor device info:\n");
146 printf(" name: %s\n", sinfo.ProductName);
147 }
148
149 vr_ctx.ovr_sfusion.AttachToSensor(vr_ctx.ovr_sensor_dev);
150 }
151 return true;
152 }
153
154 #define EXTERNAL_SHADER
155
156 static bool init_sdr()
157 {
158 int status;
159
160 #ifdef EXTERNAL_SHADER
161 FILE *fp = fopen("sdr/sdr.glsl", "rb");
162 if(!fp) {
163 perror("failed to load sdr.glsl");
164 return false;
165 }
166 fseek(fp, 0, SEEK_END);
167 long sz = ftell(fp);
168 rewind(fp);
169
170 char *buf = (char*)alloca(sz + 1);
171 fread(buf, 1, sz, fp);
172 buf[sz] = 0;
173 sdr_src = buf;
174
175 fclose(fp);
176 #endif
177
178 unsigned int sdr = glCreateShader(GL_FRAGMENT_SHADER);
179 glShaderSource(sdr, 1, &sdr_src, 0);
180 glCompileShader(sdr);
181 glGetShaderiv(sdr, GL_COMPILE_STATUS, &status);
182 if(!status) {
183 fprintf(stderr, "failed to compile distortion shader\n");
184
185 int loglen;
186 glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &loglen);
187
188 if(loglen > 0) {
189 char *log = (char*)alloca(loglen);
190 glGetShaderInfoLog(sdr, loglen, &loglen, log);
191 fprintf(stderr, "%s\n", log);
192 }
193
194 return false;
195 }
196
197 sdrprog = glCreateProgram();
198 glAttachShader(sdrprog, sdr);
199 glLinkProgram(sdrprog);
200 if(!status) {
201 fprintf(stderr, "failed to link distortion shader program\n");
202 glDeleteShader(sdr);
203 return false;
204 }
205
206 int loc;
207
208 glUseProgram(sdrprog);
209
210 if((loc = glGetUniformLocation(sdrprog, "tex")) != -1) {
211 glUniform1i(loc, 0);
212 }
213 if((loc = glGetUniformLocation(sdrprog, "lens_center_offset")) != -1) {
214 glUniform1f(loc, 0);
215 }
216 if((loc = glGetUniformLocation(sdrprog, "scr_center")) != -1) {
217 glUniform2f(loc, 0, 0);
218 }
219 if((loc = glGetUniformLocation(sdrprog, "scale")) != -1) {
220 glUniform1f(loc, vr_ctx.info.scale);
221 }
222 if((loc = glGetUniformLocation(sdrprog, "aspect")) != -1) {
223 printf("setting aspect: %f\n", vr_ctx.info.aspect / 2.0);
224 glUniform1f(loc, vr_ctx.info.aspect / 2.0);
225 }
226 if((loc = glGetUniformLocation(sdrprog, "scale_in")) != -1) {
227 glUniform2f(loc, 1, 1);
228 }
229 if((loc = glGetUniformLocation(sdrprog, "dist_factors")) != -1) {
230 glUniform4f(loc, vr_ctx.info.distort[0], vr_ctx.info.distort[1],
231 vr_ctx.info.distort[2], vr_ctx.info.distort[3]);
232 }
233
234 return true;
235 }
236
237 extern "C" const char *vr_get_display_name(void)
238 {
239 return vr_ctx.info.display;
240 }
241
242 extern "C" void vr_get_display_pos(int *xptr, int *yptr)
243 {
244 *xptr = vr_ctx.info.display_xoffs;
245 *yptr = vr_ctx.info.display_yoffs;
246 }
247
248 extern "C" int vr_get_width(void)
249 {
250 return vr_ctx.info.width;
251 }
252
253 extern "C" int vr_get_height(void)
254 {
255 return vr_ctx.info.height;
256 }
257
258 extern "C" float vr_get_fov(void)
259 {
260 return vr_ctx.info.fov;
261 }
262
263 extern "C" float vr_get_aspect(void)
264 {
265 return vr_ctx.info.aspect;
266 }
267
268 extern "C" void vr_set_eyedist(float ipd)
269 {
270 vr_ctx.info.ipd = ipd;
271 }
272
273 extern "C" float vr_get_eyedist(void)
274 {
275 return vr_ctx.info.ipd;
276 }
277
278 extern "C" void vr_set_distort(const float *coef)
279 {
280 memcpy(vr_ctx.info.distort, coef, sizeof vr_ctx.info.distort);
281 }
282
283 extern "C" void vr_get_distort(float *coef)
284 {
285 memcpy(coef, vr_ctx.info.distort, sizeof vr_ctx.info.distort);
286 }
287
288 extern "C" void vr_set_prediction_sec(float dt)
289 {
290 vr_ctx.ovr_sfusion.SetPrediction(dt);
291 }
292
293 extern "C" float vr_get_prediction_sec(void)
294 {
295 return vr_ctx.ovr_sfusion.GetPredictionDelta();
296 }
297
298 extern "C" void vr_get_view_matrix(float *res, int eye)
299 {
300 // TODO
301 }
302
303 extern "C" void vr_get_proj_matrix(float *res, int eye)
304 {
305 static float eye_scale[] = {0.0, 1.0, -1.0};
306
307 Matrix4f proj = Matrix4f::PerspectiveRH(vr_ctx.info.fov, vr_ctx.info.aspect / 2.0, 0.3, 1000.0);
308 proj = Matrix4f::Translation(vr_ctx.info.proj_center_offset * eye_scale[eye], 0, 0) * proj;
309
310 memcpy(res, proj.M[0], 16 * sizeof(float));
311 }
312
313 extern "C" void vr_get_translation(float *offs)
314 {
315 // current oculus devkit doesn't do translation
316 offs[0] = offs[1] = offs[2] = 0.0f;
317 }
318
319 extern "C" void vr_get_rotation(float *quat)
320 {
321 Quatf oq = vr_ctx.ovr_sfusion.GetPredictedOrientation();
322 quat[0] = oq.x;
323 quat[1] = oq.y;
324 quat[2] = oq.z;
325 quat[3] = oq.w;
326 }
327
328 extern "C" void vr_get_rotation_euler(float *euler)
329 {
330 Quatf oq = vr_ctx.ovr_sfusion.GetPredictedOrientation();
331 oq.GetEulerAngles<Axis_Y, Axis_X, Axis_Z>(euler + 1, euler, euler + 2);
332 }
333
334 extern "C" void vr_draw_eye(int eye, unsigned int tex, float tex_scale_x, float tex_scale_y)
335 {
336 static const float rects[3][4] = {
337 {-1, -1, 1, 1},
338 {-1, -1, 0, 1},
339 {0, -1, 1, 1}
340 };
341 static const float offs_scale[3] = {0.0, -1.0, 1.0};
342
343 glPushAttrib(GL_ENABLE_BIT);
344 glDisable(GL_DEPTH_TEST);
345 glDisable(GL_LIGHTING);
346 glEnable(GL_TEXTURE_2D);
347
348 glMatrixMode(GL_MODELVIEW);
349 glPushMatrix();
350 glLoadIdentity();
351
352 glMatrixMode(GL_PROJECTION);
353 glPushMatrix();
354 glLoadIdentity();
355
356 glUseProgram(sdrprog);
357
358 if(sdrprog) {
359 int loc;
360 if((loc = glGetUniformLocation(sdrprog, "lens_center_offset")) != -1) {
361 float offset = vr_ctx.info.lens_center_offset * offs_scale[eye];
362 glUniform1f(loc, offset);
363 }
364
365 if((loc = glGetUniformLocation(sdrprog, "tex_scale")) != -1) {
366 glUniform2f(loc, tex_scale_x, tex_scale_y);
367 }
368 }
369
370 glBindTexture(GL_TEXTURE_2D, tex);
371 glBegin(GL_QUADS);
372 glColor4f(1, 1, 1, 1);
373 glTexCoord2f(0, 0); glVertex2f(rects[eye][0], rects[eye][1]);
374 glTexCoord2f(1, 0); glVertex2f(rects[eye][2], rects[eye][1]);
375 glTexCoord2f(1, 1); glVertex2f(rects[eye][2], rects[eye][3]);
376 glTexCoord2f(0, 1); glVertex2f(rects[eye][0], rects[eye][3]);
377 glEnd();
378
379 glUseProgram(0);
380
381 glPopMatrix();
382 glMatrixMode(GL_MODELVIEW);
383 glPopMatrix();
384
385 glPopAttrib();
386 }