added: support SBS and TAB display of xbmc gui

language/English/strings.po

@@ -14145,9 +14145,51 @@ msgctxt "#36420"
 msgid "No info available yet."
 msgstr ""
 
-#empty strings from id 36421 to 36999
+#empty strings from id 36421 to 36499
 #end reservation
 
+#: system/settings/settings.xml
+msgctxt "#36501"
+msgid "Stereoscopic 3d Mode"
+msgstr ""
+
+#: system/settings/settings.xml
+msgctxt "#36502"
+msgid "None"
+msgstr ""
+
+#: system/settings/settings.xml
+msgctxt "#36503"
+msgid "Over/Under"
+msgstr ""
+
+#: system/settings/settings.xml
+msgctxt "#36504"
+msgid "Side by side"
+msgstr ""
+
+#: system/settings/settings.xml
+msgctxt "#36505"
+msgid "Anaglyph Red/Cyan"
+msgstr ""
+
+#: system/settings/settings.xml
+msgctxt "#36506"
+msgid "Anaglyph Green/Magenta"
+msgstr ""
+
+#: system/settings/settings.xml
+msgctxt "#36507"
+msgid "Interlaced"
+msgstr ""
+
+#: system/settings/settings.xml
+msgctxt "#36508"
+msgid "Hardware Based"
+msgstr ""
+
+#reserved strings 365XX
+
 #: xbmc/cores/dvdplayer/DVDInputStreams/DVDInputStreamNavigator.cpp
 msgctxt "#37000"
 msgid "(Visually Impaired)"

system/settings/settings.xml

@@ -1891,6 +1891,14 @@
             <dependency type="enable" on="property" name="IsFullscreen" />
           </dependencies>
         </setting>
+        <setting id="videoscreen.mode3d" type="integer" label="36501" help="">
+          <level>0</level>
+          <default>0</default>
+          <constraints>
+            <options>mode3d</options>
+          </constraints>
+          <control type="spinner" format="integer" delayed="true"/>
+        </setting>
       </group>
       <group id="2">
         <setting id="videoscreen.vsync" type="integer" label="13105" help="36356">

xbmc/Application.cpp

@@ -2115,8 +2115,21 @@ void CApplication::Render()
   g_renderManager.FrameMove();
 
   CDirtyRegionList dirtyRegions = g_windowManager.GetDirty();
-  if (RenderNoPresent())
-    hasRendered = true;
+  if(g_graphicsContext.GetStereoMode())
+  {
+    g_graphicsContext.SetStereoView(RENDER_STEREO_VIEW_LEFT);
+    if(RenderNoPresent())
+      hasRendered = true;
+    g_graphicsContext.SetStereoView(RENDER_STEREO_VIEW_RIGHT);
+    if(RenderNoPresent())
+      hasRendered = true;
+    g_graphicsContext.SetStereoView(RENDER_STEREO_VIEW_OFF);
+  }
+  else
+  {
+    if(RenderNoPresent())
+      hasRendered = true;
+  }
 
   g_renderManager.FrameFinish();
 

xbmc/cores/VideoRenderers/BaseRenderer.cpp

@@ -600,9 +600,6 @@ void CBaseRenderer::SetViewMode(int viewMode)
   if (viewMode < ViewModeNormal || viewMode > ViewModeCustom)
     viewMode = ViewModeNormal;
 
-  if (m_iFlags & (CONF_FLAGS_STEREO_MODE_SBS | CONF_FLAGS_STEREO_MODE_TAB))
-    viewMode = ViewModeNormal;
-
   CMediaSettings::Get().GetCurrentVideoSettings().m_ViewMode = viewMode;
 
   // get our calibrated full screen resolution

xbmc/guilib/GraphicContext.cpp

@@ -61,6 +61,8 @@ CGraphicContext::CGraphicContext(void) :
   /*m_guiTransform,*/
   /*m_finalTransform, */
   /*m_groupTransform*/
+  , m_stereoView(RENDER_STEREO_VIEW_OFF)
+  , m_stereoMode(RENDER_STEREO_MODE_OFF)
 {
 }
 
@@ -250,17 +252,45 @@ void CGraphicContext::RestoreViewPort()
   UpdateCameraPosition(m_cameras.top());
 }
 
+CPoint CGraphicContext::StereoCorrection(const CPoint &point, bool scale) const
+{
+  CPoint res(point);
+
+  if(m_stereoMode == RENDER_STEREO_MODE_SPLIT_HORIZONTAL)
+  {
+    if(scale)
+      res.y *= 0.5f;
+    if(m_stereoView == RENDER_STEREO_VIEW_RIGHT)
+      res.y += 0.5f * m_iScreenHeight;
+  }
+  if(m_stereoMode == RENDER_STEREO_MODE_SPLIT_VERTICAL)
+  {
+    if(scale)
+      res.x *= 0.5f;
+    if(m_stereoView == RENDER_STEREO_VIEW_RIGHT)
+      res.x += 0.5f * m_iScreenWidth;
+  }
+  return res;
+}
+
+CRect CGraphicContext::StereoCorrection(const CRect &rect, bool scale) const
+{
+  CRect res(StereoCorrection(rect.P1(), scale)
+          , StereoCorrection(rect.P2(), scale));
+  return res;
+}
+
 void CGraphicContext::SetScissors(const CRect &rect)
 {
   m_scissors = rect;
   m_scissors.Intersect(CRect(0,0,(float)m_iScreenWidth, (float)m_iScreenHeight));
-  g_Windowing.SetScissors(m_scissors);
+  g_Windowing.SetScissors(StereoCorrection(m_scissors, false));
 }
 
 void CGraphicContext::ResetScissors()
 {
   m_scissors.SetRect(0, 0, (float)m_iScreenWidth, (float)m_iScreenHeight);
-  g_Windowing.ResetScissors(); // SetScissors(m_scissors) instead?
+  g_Windowing.SetScissors(StereoCorrection(m_scissors, false));
 }
 
 const CRect CGraphicContext::GetViewWindow() const
@@ -273,7 +303,7 @@ const CRect CGraphicContext::GetViewWindow() const
     rect.y1 = (float)info.Overscan.top;
     rect.x2 = (float)info.Overscan.right;
     rect.y2 = (float)info.Overscan.bottom;
-    return rect;
+    return StereoCorrection(rect, true);
   }
   return m_videoRect;
 }
@@ -632,6 +662,13 @@ const RESOLUTION_INFO CGraphicContext::GetResInfo(RESOLUTION res) const
   if (res >= 0 && res < (int)CDisplaySettings::Get().ResolutionInfoSize())
     info = CDisplaySettings::Get().GetResolutionInfo(res);
 
+  if(m_stereoMode)
+  {
+    CRect base = StereoCorrection(CRect(0, 0, m_iScreenWidth, m_iScreenHeight), true);
+    info.fPixelRatio /= base.Width()  / m_iScreenWidth;
+    info.fPixelRatio *= base.Height() / m_iScreenHeight;
+  }
+
   return info;
 }
 
@@ -700,6 +737,18 @@ void CGraphicContext::SetScalingResolution(const RESOLUTION_INFO &res, bool need
     m_guiScaleX = 1.0f;
     m_guiScaleY = 1.0f;
   }
+
+  if(m_stereoMode)
+  {
+    CRect base = StereoCorrection(CRect(0, 0, m_iScreenWidth, m_iScreenHeight), true);
+
+    m_guiScaleX    *= m_iScreenWidth  / base.Width();
+    m_guiScaleY    *= m_iScreenHeight / base.Height();
+    m_guiTransform  = TransformMatrix::CreateScaler(base.Width()  / m_iScreenWidth
+                                                  , base.Height() / m_iScreenHeight
+                                                  , 1.0) * m_guiTransform;
+  }
+
   // reset our origin and camera
   while (m_origins.size())
     m_origins.pop();
@@ -723,29 +772,54 @@ void CGraphicContext::SetRenderingResolution(const RESOLUTION_INFO &res, bool ne
 
 void CGraphicContext::UpdateFinalTransform(const TransformMatrix &matrix)
 {
-  m_finalTransform = matrix;
   // We could set the world transform here to GPU-ize the animation system.
   // trouble is that we require the resulting x,y coords to be rounded to
   // the nearest pixel (vertex shader perhaps?)
+  m_finalTransform.Reset();
+
+  if(m_stereoMode)
+  {
+    CPoint base = StereoCorrection(CPoint(0, 0), false);
+    m_finalTransform *= TransformMatrix::CreateTranslation(base.x, base.y, 0.0);
+  }
+
+  m_finalTransform *= matrix;
+}
+
+void CGraphicContext::SetStereoView(RENDER_STEREO_VIEW view)
+{
+  m_stereoView = view;
+
+  while(m_viewStack.size())
+    m_viewStack.pop();
+
+  CRect viewport(0.0f, 0.0f, (float)m_iScreenWidth, (float)m_iScreenHeight);
+
+  viewport = StereoCorrection(viewport, true);
+
+  m_viewStack.push(viewport);
+  g_Windowing.SetStereoMode(m_stereoMode, m_stereoView);
+  g_Windowing.SetScissors(viewport);
 }
 
 void CGraphicContext::InvertFinalCoords(float &x, float &y) const
 {
   m_finalTransform.InverseTransformPosition(x, y);
+
+  // to make mouse behave as we move across screen, we need to modify for splits
+  if(m_stereoMode)
+  {
+    CRect base = StereoCorrection(CRect(0, 0, m_iScreenWidth, m_iScreenHeight), true);
+    x *= base.Width()  / m_iScreenWidth;
+    y *= base.Height() / m_iScreenHeight;
+  }
 }
 
 float CGraphicContext::GetScalingPixelRatio() const
 {
   // assume the resolutions are different - we want to return the aspect ratio of the video resolution
   // but only once it's been corrected for the skin -> screen coordinates scaling
-  RESOLUTION_INFO info = GetResInfo();
-  float winWidth  = (float)m_windowResolution.iWidth;
-  float winHeight = (float)m_windowResolution.iHeight;
-  float outWidth  = (float)info.iWidth;
-  float outHeight = (float)info.iHeight;
-  float outPR     = info.fPixelRatio;
-
-  return outPR * (outWidth / outHeight) / (winWidth / winHeight);
+  return GetResInfo().fPixelRatio * (m_guiScaleY / m_guiScaleX);
 }
 
 void CGraphicContext::SetCameraPosition(const CPoint &camera)
@@ -812,7 +886,9 @@ CRect CGraphicContext::generateAABB(const CRect &rect) const
 //       to cut down on one setting)
 void CGraphicContext::UpdateCameraPosition(const CPoint &camera)
 {
-  g_Windowing.SetCameraPosition(camera, m_iScreenWidth, m_iScreenHeight);
+  CPoint camera2 = StereoCorrection(camera, true);
+
+  g_Windowing.SetCameraPosition(camera2, m_iScreenWidth, m_iScreenHeight);
 }
 
 bool CGraphicContext::RectIsAngled(float x1, float y1, float x2, float y2) const
@@ -895,6 +971,13 @@ void CGraphicContext::SetMediaDir(const CStdString &strMediaDir)
 void CGraphicContext::Flip(const CDirtyRegionList& dirty)
 {
   g_Windowing.PresentRender(dirty);
+  RENDER_STEREO_MODE mode = (RENDER_STEREO_MODE)CSettings::Get().GetInt("videoscreen.mode3d");
+  if(m_stereoMode != mode)
+  {
+    m_stereoMode = mode;
+    SetStereoView(RENDER_STEREO_VIEW_OFF);
+    g_windowManager.SendMessage(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_RENDERER_RESET);
+  }
 }
 
 void CGraphicContext::ApplyHardwareTransform()

xbmc/guilib/GraphicContext.h

@@ -48,6 +48,7 @@
 #include "utils/GlobalsHandling.h"
 #include "DirtyRegion.h"
 #include "settings/ISettingCallback.h"
+#include "rendering/RenderSystem.h"
 
 enum VIEW_TYPE { VIEW_TYPE_NONE = 0,
                  VIEW_TYPE_LIST,
@@ -149,6 +150,9 @@ class CGraphicContext : public CCriticalSection,
   void SetOrigin(float x, float y);
   void RestoreOrigin();
   void SetCameraPosition(const CPoint &camera);
+  void SetStereoView(RENDER_STEREO_VIEW view);
+  RENDER_STEREO_VIEW GetStereoView()  { return m_stereoView; }
+  RENDER_STEREO_MODE GetStereoMode()  { return m_stereoMode; }
   void RestoreCameraPosition();
   /*! \brief Set a region in which to clip all rendering
    Anything that is rendered after setting a clip region will be clipped so that no part renders
@@ -217,6 +221,10 @@ class CGraphicContext : public CCriticalSection,
       UpdateFinalTransform(TransformMatrix());
   }
 
+  /* modifies final coordinates according to stereo mode if needed */
+  CRect StereoCorrection(const CRect &rect, bool scale) const;
+  CPoint StereoCorrection(const CPoint &point, bool scale) const;
+
   CRect generateAABB(const CRect &rect) const;
 
 protected:
@@ -245,6 +253,8 @@ class CGraphicContext : public CCriticalSection,
   TransformMatrix m_guiTransform;
   TransformMatrix m_finalTransform;
   std::stack<TransformMatrix> m_groupTransform;
+  RENDER_STEREO_VIEW m_stereoView;
+  RENDER_STEREO_MODE m_stereoMode;
 
   CRect m_scissors;
 };

xbmc/rendering/RenderSystem.cpp

@@ -65,3 +65,16 @@ bool CRenderSystemBase::SupportsBGRAApple() const
   return (m_renderCaps & RENDER_CAPS_BGRA_APPLE) == RENDER_CAPS_BGRA_APPLE;
 }
 
+bool CRenderSystemBase::SupportsStereo(RENDER_STEREO_MODE mode) const
+{
+  switch(mode)
+  {
+    case RENDER_STEREO_MODE_OFF:
+    case RENDER_STEREO_MODE_SPLIT_HORIZONTAL:
+    case RENDER_STEREO_MODE_SPLIT_VERTICAL:
+      return true;
+    default:
+      return false;
+  }
+}
+

xbmc/rendering/RenderSystem.h

@@ -60,6 +60,25 @@ enum
   RENDER_QUIRKS_BROKEN_OCCLUSION_QUERY       = 1 << 2,
 };
 
+enum RENDER_STEREO_VIEW
+{
+  RENDER_STEREO_VIEW_OFF,
+  RENDER_STEREO_VIEW_LEFT,
+  RENDER_STEREO_VIEW_RIGHT,
+};
+
+enum RENDER_STEREO_MODE
+{
+  RENDER_STEREO_MODE_OFF,
+  RENDER_STEREO_MODE_SPLIT_HORIZONTAL,
+  RENDER_STEREO_MODE_SPLIT_VERTICAL,
+  RENDER_STEREO_MODE_ANAGLYPH_RED_CYAN,
+  RENDER_STEREO_MODE_ANAGLYPH_GREEN_MAGENTA,
+  RENDER_STEREO_MODE_INTERLACED,
+  RENDER_STEREO_MODE_HARDWAREBASED,
+};
+
+
 class CRenderSystemBase
 {
 public:
@@ -94,6 +113,11 @@ class CRenderSystemBase
   virtual void SetCameraPosition(const CPoint &camera, int screenWidth, int screenHeight) = 0;
   virtual void ApplyHardwareTransform(const TransformMatrix &matrix) = 0;
   virtual void RestoreHardwareTransform() = 0;
+  virtual void SetStereoMode(RENDER_STEREO_MODE mode, RENDER_STEREO_VIEW view)
+  {
+    m_stereoMode = mode;
+    m_stereoView = view;
+  }
 
   virtual bool TestRender() = 0;
 
@@ -110,6 +134,7 @@ class CRenderSystemBase
   bool SupportsBGRA() const;
   bool SupportsBGRAApple() const;
   bool SupportsNPOT(bool dxt) const;
+  bool SupportsStereo(RENDER_STEREO_MODE mode) const;
   unsigned int GetMaxTextureSize() const { return m_maxTextureSize; }
   unsigned int GetMinDXTPitch() const { return m_minDXTPitch; }
   unsigned int GetRenderQuirks() const { return m_renderQuirks; }
@@ -128,6 +153,8 @@ class CRenderSystemBase
   int          m_RenderVersionMajor;
   unsigned int m_renderCaps;
   unsigned int m_renderQuirks;
+  RENDER_STEREO_VIEW m_stereoView;
+  RENDER_STEREO_MODE m_stereoMode;
 };
 
 #endif // RENDER_SYSTEM_H