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         system(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 = system.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         system.configure_window(view.get_window());
 126 }
 127
 128 void LibOVRCombiner::prepare() const
 129 {
 130         system.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 = system.get_private().ovr_hmd;
 138
 139         if(system.is_timing_active())
 140         {
 141                 ovr_WaitTillTime(system.get_timewarp_time());
 142                 ovrTrackingState state = ovrHmd_GetTrackingState(hmd, system.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         system.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