Name LibOVR classes after the API, not the device
[libs/vr.git] / source / libovr / libovrcombiner.cpp
1 #include <msp/gl/meshbuilder.h>
2 #include <msp/gl/texture2d.h>
3 #include "libovrcombiner.h"
4 #include "libovrsystem.h"
5 #include "libovrsystem_private.h"
6
7 using namespace std;
8
9
10 namespace {
11
12 const char vs_source[] =
13         "uniform mat4 timewarp[2];\n"
14         "uniform vec2 uv_scale;\n"
15         "uniform vec2 uv_offset;\n"
16         "varying vec2 texcoord_r;\n"
17         "varying vec2 texcoord_g;\n"
18         "varying vec2 texcoord_b;\n"
19         "varying float vignette;\n"
20         "vec2 apply_timewarp(vec2 coords, float factor)\n"
21         "{\n"
22         "       vec4 coords4 = vec4(coords, 1.0, 1.0);\n"
23         "       vec4 warped = mix(timewarp[0]*coords4, timewarp[1]*coords4, factor);\n"
24         "       return (warped.xy/warped.z)*uv_scale+uv_offset;\n"
25         "}\n"
26         "void main()\n"
27         "{\n"
28         "       gl_Position = vec4(gl_Vertex.xy, 0.5, 1.0);\n"
29         "       float tw_factor = gl_MultiTexCoord3.y;\n"
30         "       texcoord_r = apply_timewarp(gl_MultiTexCoord0.xy, tw_factor);\n"
31         "       texcoord_g = apply_timewarp(gl_MultiTexCoord1.xy, tw_factor);\n"
32         "       texcoord_b = apply_timewarp(gl_MultiTexCoord2.xy, tw_factor);\n"
33         "       vignette = gl_MultiTexCoord3.x;\n"
34         "}\n";
35
36 const char fs_source[] =
37         "uniform sampler2D texture;\n"
38         "varying vec2 texcoord_r;\n"
39         "varying vec2 texcoord_g;\n"
40         "varying vec2 texcoord_b;\n"
41         "varying float vignette;\n"
42         "void main()\n"
43         "{\n"
44         "       float r = texture2D(texture, texcoord_r).r;\n"
45         "       float g = texture2D(texture, texcoord_g).g;\n"
46         "       float b = texture2D(texture, texcoord_b).b;\n"
47         "       gl_FragColor = vec4(vec3(r, g, b)*vignette, 1.0);\n"
48         "}\n";
49
50 void create_distortion_mesh(Msp::GL::Mesh &mesh, ovrHmd hmd, ovrEyeType eye, const ovrFovPort &fov)
51 {
52         ovrDistortionMesh ovr_mesh;
53         ovrHmd_CreateDistortionMesh(hmd, eye, fov, ovrDistortionCap_Vignette|ovrDistortionCap_TimeWarp, &ovr_mesh);
54
55         Msp::GL::MeshBuilder bld(mesh);
56         for(unsigned i=0; i<ovr_mesh.VertexCount; ++i)
57         {
58                 ovrDistortionVertex &v = ovr_mesh.pVertexData[i];
59                 bld.multitexcoord(0, v.TanEyeAnglesR.x, v.TanEyeAnglesR.y);
60                 bld.multitexcoord(1, v.TanEyeAnglesG.x, v.TanEyeAnglesG.y);
61                 bld.multitexcoord(2, v.TanEyeAnglesB.x, v.TanEyeAnglesB.y);
62                 bld.multitexcoord(3, v.VignetteFactor, v.TimeWarpFactor);
63                 bld.vertex(v.ScreenPosNDC.x, v.ScreenPosNDC.y);
64         }
65
66         Msp::GL::Batch batch(Msp::GL::TRIANGLES);
67         batch.append(vector<unsigned>(ovr_mesh.pIndexData, ovr_mesh.pIndexData+ovr_mesh.IndexCount));
68         mesh.add_batch(batch);
69
70         ovrHmd_DestroyDistortionMesh(&ovr_mesh);
71 }
72
73 }
74
75 namespace Msp {
76 namespace VR {
77
78 struct LibOVRCombiner::Frustum: StereoCombiner::Frustum
79 {
80         Frustum(const ovrFovPort &);
81 };
82
83
84 LibOVRCombiner::LibOVRCombiner(LibOVRSystem &d, GL::View &v):
85         device(d),
86         view(v),
87         left_mesh((GL::VERTEX2, GL::TEXCOORD2,0, GL::TEXCOORD2,1, GL::TEXCOORD2,2, GL::TEXCOORD2,3)),
88         right_mesh((GL::VERTEX2, GL::TEXCOORD2,0, GL::TEXCOORD2,1, GL::TEXCOORD2,2, GL::TEXCOORD2,3)),
89         shprog(vs_source, fs_source)
90 {
91         ovrHmd hmd = device.get_private().ovr_hmd;
92
93         ovrFovPort left_fov = hmd->DefaultEyeFov[ovrEye_Left];
94         ovrFovPort right_fov = hmd->DefaultEyeFov[ovrEye_Right];
95         configure_eye_frustums(Frustum(left_fov), Frustum(right_fov));
96
97         left_fov.UpTan = left_fov.DownTan = tan(fov/2.0f);
98         left_fov.LeftTan = left_fov.UpTan*render_aspect*(1-frustum_skew);
99         left_fov.RightTan = left_fov.UpTan*render_aspect*(1+frustum_skew);
100         right_fov = left_fov;
101         swap(right_fov.LeftTan, right_fov.RightTan);
102
103         create_distortion_mesh(left_mesh, hmd, ovrEye_Left, left_fov);
104         create_distortion_mesh(right_mesh, hmd, ovrEye_Right, right_fov);
105
106         ovrSizei tex_size = ovrHmd_GetFovTextureSize(hmd, ovrEye_Left, left_fov, 1.0);
107         target_width = tex_size.w;
108         target_height = tex_size.h;
109
110         left_shdata.uniform("texture", 0);
111         right_shdata.uniform("texture", 0);
112
113         ovrRecti view_rect;
114         view_rect.Pos.x = 0;
115         view_rect.Pos.y = 0;
116         view_rect.Size = tex_size;
117         ovrVector2f uv_scale_offset[2];
118         ovrHmd_GetRenderScaleAndOffset(left_fov, tex_size, view_rect, uv_scale_offset);
119         left_shdata.uniform("uv_scale", uv_scale_offset[0].x, -uv_scale_offset[0].y);
120         left_shdata.uniform("uv_offset", uv_scale_offset[1].x, 1-uv_scale_offset[1].y);
121         ovrHmd_GetRenderScaleAndOffset(right_fov, tex_size, view_rect, uv_scale_offset);
122         right_shdata.uniform("uv_scale", uv_scale_offset[0].x, -uv_scale_offset[0].y);
123         right_shdata.uniform("uv_offset", uv_scale_offset[1].x, 1-uv_scale_offset[1].y);
124
125         device.configure_window(view.get_window());
126 }
127
128 void LibOVRCombiner::prepare() const
129 {
130         device.begin_frame();
131 }
132
133 void LibOVRCombiner::render(const GL::Texture2D &left, const GL::Texture2D &right) const
134 {
135         GL::Bind bind_shprog(shprog);
136
137         ovrHmd hmd = device.get_private().ovr_hmd;
138
139         if(device.is_timing_active())
140         {
141                 ovr_WaitTillTime(device.get_timewarp_time());
142                 ovrTrackingState state = ovrHmd_GetTrackingState(hmd, device.get_tracking_time());
143
144                 ovrMatrix4f matrices[2];
145                 ovrHmd_GetEyeTimewarpMatrices(hmd, ovrEye_Left, state.HeadPose.ThePose, matrices);
146                 left_shdata.uniform_matrix4_array("timewarp", 2, &matrices[0].M[0][0]);
147
148                 ovrHmd_GetEyeTimewarpMatrices(hmd, ovrEye_Right, state.HeadPose.ThePose, matrices);
149                 right_shdata.uniform_matrix4_array("timewarp", 2, &matrices[0].M[0][0]);
150         }
151         else
152         {
153                 GL::Matrix matrices[2];
154                 left_shdata.uniform_matrix4_array("timewarp", 2, matrices[0].data());
155                 right_shdata.uniform_matrix4_array("timewarp", 2, matrices[0].data());
156         }
157
158         GL::Bind bind_tex(left);
159         left_shdata.apply();
160         left_mesh.draw();
161
162         right.bind();
163         right_shdata.apply();
164         right_mesh.draw();
165
166         view.get_context().swap_buffers();
167         device.end_frame();
168 }
169
170
171 LibOVRCombiner::Frustum::Frustum(const ovrFovPort &fov):
172         StereoCombiner::Frustum(-fov.LeftTan, fov.RightTan, -fov.DownTan, fov.UpTan)
173 { }
174
175 } // namespace VR
176 } // namespace Msp