use vr hiddenarea mask

opengl33renderer.cpp

@@ -125,7 +125,7 @@ bool opengl33_renderer::Init(GLFWwindow *Window)
         m_pick_shader = make_shader("vertexonly.vert", "pick.frag");
         m_pick_surface_shader = make_shader("simpleuv.vert", "pick_surface.frag");
 		m_billboard_shader = make_shader("simpleuv.vert", "billboard.frag");
-		m_celestial_shader = make_shader("celestial.vert", "celestial.frag");
+        m_celestial_shader = make_shader("celestial.vert", "celestial.frag");
 		if (Global.gfx_usegles)
 			m_depth_pointer_shader = make_shader("quad.vert", "gles_depthpointer.frag");
 		m_invalid_material = Fetch_Material("invalid");
@@ -173,6 +173,8 @@ bool opengl33_renderer::Init(GLFWwindow *Window)
         vr = vr_interface_factory::get_instance()->create(Global.vr_backend);
 
     if (vr) {
+        m_hiddenarea_shader = make_shader("hiddenarea.vert", "hiddenarea.frag");
+
         glm::ivec2 target_size = vr->get_target_size();
         WriteLog("using vr rendertarget: " + glm::to_string(target_size));
 
@@ -740,11 +742,28 @@ void opengl33_renderer::Render_pass(viewport_config &vp, rendermode const Mode)
 			glBindFramebuffer(GL_FRAMEBUFFER, 0);
 			glViewport(0, 0, target_size.x, target_size.y);
 			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-		}
+        }
 
-		glEnable(GL_DEPTH_TEST);
+        glEnable(GL_DEPTH_TEST);
 
 		Timer::subsystem.gfx_color.start();
+
+        if (vr && (vp.proj_type == viewport_config::vr_left || vp.proj_type == viewport_config::vr_right)) {
+            glDebug("vr hiddenarea");
+            TModel3d *mask = vr->get_hiddenarea_mesh((vp.proj_type == viewport_config::vr_left) ? vr_interface::eye_left : vr_interface::eye_right);
+
+            if (mask) {
+                glDisable(GL_CULL_FACE);
+                glDisable(GL_BLEND);
+                glDepthMask(GL_TRUE);
+
+                m_hiddenarea_shader->bind();
+                draw(mask->Root->m_geometry.handle);
+
+                glEnable(GL_CULL_FACE);
+            }
+        }
+
 		setup_matrices();
 		setup_drawing(true);
         m_renderpass.draw_stats = {};
@@ -1694,8 +1713,7 @@ bool opengl33_renderer::Render(world_environment *Environment)
 		return false;
 	}
 
-	Bind_Material(null_handle);
+    Bind_Material(null_handle);
-	::glDisable(GL_DEPTH_TEST);
 	::glPushMatrix();
 
 	// skydome
@@ -1860,8 +1878,7 @@ bool opengl33_renderer::Render(world_environment *Environment)
 
 	gl::program::unbind();
 	gl::vao::unbind();
-	::glPopMatrix();
+    ::glPopMatrix();
-	::glEnable(GL_DEPTH_TEST);
 
 	m_sunlight.apply_angle();
 	m_sunlight.apply_intensity();

opengl33renderer.h

@@ -382,6 +382,7 @@ class opengl33_renderer : public gfx_renderer {
 	std::unique_ptr<gl::program> m_freespot_shader;
     std::unique_ptr<gl::program> m_billboard_shader;
     std::unique_ptr<gl::program> m_celestial_shader;
+    std::unique_ptr<gl::program> m_hiddenarea_shader;
 
     std::unique_ptr<gl::vao> m_empty_vao;
 

shaders/hiddenarea.frag

@@ -0,0 +1,15 @@
+#include <common>
+
+layout(location = 0) out vec4 out_color;
+#if MOTIONBLUR_ENABLED
+layout(location = 1) out vec4 out_motion;
+#endif
+
+void main()
+{
+out_color = vec4(vec3(0.0f), 1.0f);
+#if MOTIONBLUR_ENABLED
+	out_motion = vec4(0.0f);
+#endif
+gl_FragDepth = 1.0f;
+}

shaders/hiddenarea.vert

@@ -0,0 +1,6 @@
+layout(location = 0) in vec3 v_vert;
+
+void main()
+{
+	gl_Position = vec4(v_vert.xy * 2.0f - 1.0f, 0.5f, 1.0f);
+}

vr/openvr_imp.cpp

@@ -25,8 +25,39 @@ vr_openvr::vr_openvr()
     vr::VRInput()->GetActionSetHandle("/actions/main", &actionset);
     vr::VRInput()->GetActionHandle("/actions/main/in/PrimaryAction", &primary_action);
     vr::VRInput()->GetActionHandle("/actions/main/in/SecondaryAction", &secondary_action);
+
+    hiddenarea_mesh[(size_t)vr_interface::eye_left] = create_hiddenarea_model(vr_interface::eye_left);
+    hiddenarea_mesh[(size_t)vr_interface::eye_right] = create_hiddenarea_model(vr_interface::eye_right);
 }
 
+std::unique_ptr<TModel3d> vr_openvr::create_hiddenarea_model(vr_interface::eye_e e)
+{
+    vr::HiddenAreaMesh_t mesh = vr_system->GetHiddenAreaMesh((e == vr_interface::eye_left) ? vr::Eye_Left : vr::Eye_Right, vr::k_eHiddenAreaMesh_Standard);
+    if (!mesh.unTriangleCount)
+        return nullptr;
+
+    gfx::vertex_array vertices;
+    for (size_t v = 0; v < mesh.unTriangleCount * 3; v++) {
+        const vr::HmdVector2_t vertex = mesh.pVertexData[v];
+        vertices.push_back(gfx::basic_vertex(
+                               glm::vec3(vertex.v[0], vertex.v[1], 0.0f),
+                               glm::vec3(0.0f),
+                               glm::vec2(0.0f)));
+    }
+
+
+    std::unique_ptr<TModel3d> model = std::make_unique<TModel3d>();
+    model->AppendChildFromGeometry("__root", "none", vertices, gfx::index_array());
+    model->Init();
+
+    return model;
+}
+
+TModel3d* vr_openvr::get_hiddenarea_mesh(eye_e eye)
+{
+    return hiddenarea_mesh[(size_t)eye].get();
+};
+
 glm::ivec2 vr_openvr::get_target_size()
 {
     uint32_t vr_w, vr_h;

vr/openvr_imp.h

@@ -22,6 +22,8 @@ private:
     vr::VRInputValueHandle_t inputhandle_left = 0;
     vr::VRInputValueHandle_t inputhandle_right = 0;
 
+    std::array<std::unique_ptr<TModel3d>, 2> hiddenarea_mesh;
+
     uint32_t primary_controller;
     glm::mat4 primary_controller_transform;
 
@@ -29,6 +31,7 @@ private:
 
     bool update_component(const std::string &rendermodel, vr::VRInputValueHandle_t handle, TSubModel *component);
     glm::mat4 get_matrix(const vr::HmdMatrix34_t &src);
+    std::unique_ptr<TModel3d> create_hiddenarea_model(eye_e e);
 
     vr::VRActionSetHandle_t actionset = 0;
     vr::VRActionHandle_t primary_action = 0;
@@ -52,6 +55,7 @@ public:
     void begin_frame() override;
     void submit(eye_e, opengl_texture*) override;
     std::vector<TModel3d*> get_render_models() override;
+    TModel3d* get_hiddenarea_mesh(eye_e) override;
     glm::mat4 get_pick_transform() override;
     void finish_frame() override;
     ~vr_openvr() override;

vr/vr_interface.h

@@ -12,6 +12,7 @@ public:
     };
 
     virtual viewport_proj_config get_proj_config(eye_e) = 0;
+    virtual TModel3d* get_hiddenarea_mesh(eye_e) = 0;
     virtual glm::ivec2 get_target_size() = 0;
     virtual void begin_frame() = 0;
     virtual void submit(eye_e, opengl_texture*) = 0;