Side by side rendering

- Side by side rendering implemented throughout the graphics pipeline.
- New GuiTSCtrl renderStyle property is set to "stereo side by side" to
activate.
- You set an IDisplayDevice on the GameConnection to define any vertical
FOV, projection offset, and stereo eye offset properties required for
the stereo rendering (no display device included with this commit).
- Full and Empty templates updated with correct scripts and shaders.

Engine/source/scene/sceneManager.cpp

@@ -233,7 +233,70 @@ void SceneManager::renderScene( SceneRenderState* renderState, U32 objectMask, S
 
    // Render the scene.
 
-   renderSceneNoLights( renderState, objectMask, baseObject, baseZone );
+   if(GFX->getCurrentRenderStyle() == GFXDevice::RS_StereoSideBySide)
+   {
+      // Store previous values
+      RectI originalVP = GFX->getViewport();
+      MatrixF originalWorld = GFX->getWorldMatrix();
+
+      Point2F projOffset = GFX->getCurrentProjectionOffset();
+      Point3F eyeOffset = GFX->getStereoEyeOffset();
+
+      // Render left half of display
+      RectI leftVP = originalVP;
+      leftVP.extent.x *= 0.5;
+      GFX->setViewport(leftVP);
+
+      MatrixF leftWorldTrans(true);
+      leftWorldTrans.setPosition(Point3F(eyeOffset.x, eyeOffset.y, eyeOffset.z));
+      MatrixF leftWorld(originalWorld);
+      leftWorld.mulL(leftWorldTrans);
+      GFX->setWorldMatrix(leftWorld);
+
+      Frustum gfxFrustum = GFX->getFrustum();
+      gfxFrustum.setProjectionOffset(Point2F(projOffset.x, projOffset.y));
+      GFX->setFrustum(gfxFrustum);
+
+      SceneCameraState cameraStateLeft = SceneCameraState::fromGFX();
+      SceneRenderState renderStateLeft( this, renderState->getScenePassType(), cameraStateLeft );
+      renderStateLeft.setSceneRenderStyle(SRS_SideBySide);
+      renderStateLeft.setSceneRenderField(0);
+
+      renderSceneNoLights( &renderStateLeft, objectMask, baseObject, baseZone );
+
+      // Render right half of display
+      RectI rightVP = originalVP;
+      rightVP.extent.x *= 0.5;
+      rightVP.point.x += rightVP.extent.x;
+      GFX->setViewport(rightVP);
+
+      MatrixF rightWorldTrans(true);
+      rightWorldTrans.setPosition(Point3F(-eyeOffset.x, eyeOffset.y, eyeOffset.z));
+      MatrixF rightWorld(originalWorld);
+      rightWorld.mulL(rightWorldTrans);
+      GFX->setWorldMatrix(rightWorld);
+
+      gfxFrustum = GFX->getFrustum();
+      gfxFrustum.setProjectionOffset(Point2F(-projOffset.x, projOffset.y));
+      GFX->setFrustum(gfxFrustum);
+
+      SceneCameraState cameraStateRight = SceneCameraState::fromGFX();
+      SceneRenderState renderStateRight( this, renderState->getScenePassType(), cameraStateRight );
+      renderStateRight.setSceneRenderStyle(SRS_SideBySide);
+      renderStateRight.setSceneRenderField(1);
+
+      renderSceneNoLights( &renderStateRight, objectMask, baseObject, baseZone );
+
+      // Restore previous values
+      GFX->setWorldMatrix(originalWorld);
+      gfxFrustum.clearProjectionOffset();
+      GFX->setFrustum(gfxFrustum);
+      GFX->setViewport(originalVP);
+   }
+   else
+   {
+      renderSceneNoLights( renderState, objectMask, baseObject, baseZone );
+   }
 
    // Trigger the post-render signal.
 

Engine/source/scene/sceneManager.h

@@ -89,6 +89,18 @@ enum ScenePassType
 };
 
 
+/// The type of scene render style
+/// @see SceneRenderState
+enum SceneRenderStyle
+{
+   /// The regular style of rendering
+   SRS_Standard,
+
+   /// Side-by-side style rendering
+   SRS_SideBySide,
+};
+
+
 /// An object that manages the SceneObjects belonging to a scene.
 class SceneManager
 {

Engine/source/scene/sceneRenderState.cpp

@@ -44,7 +44,9 @@ SceneRenderState::SceneRenderState( SceneManager* sceneManager,
       mUsePostEffects( usePostEffects ),
       mDisableAdvancedLightingBins( false ),
       mRenderArea( view.getFrustum().getBounds() ),
-      mAmbientLightColor( sceneManager->getAmbientLightColor() )
+      mAmbientLightColor( sceneManager->getAmbientLightColor() ),
+      mSceneRenderStyle( SRS_Standard ),
+      mRenderField( 0 )
 {
    // Setup the default parameters for the screen metrics methods.
    mDiffuseCameraTransform = view.getViewWorldMatrix();

Engine/source/scene/sceneRenderState.h

@@ -69,6 +69,12 @@ class SceneRenderState
       /// The type of scene render pass we're doing.
       ScenePassType mScenePassType;
 
+      /// The render style being performed
+      SceneRenderStyle mSceneRenderStyle;
+
+      /// When doing stereo rendering, the current field that is being rendered
+      S32 mRenderField;
+
       /// The render pass which we are setting up with this scene state.
       RenderPassManager* mRenderPass;
 
@@ -219,6 +225,23 @@ class SceneRenderState
 
       /// @}
 
+      /// @name Render Style
+      /// @{
+
+      /// Get the rendering style used for the scene
+      SceneRenderStyle getSceneRenderStyle() const { return mSceneRenderStyle; }
+
+      /// Set the rendering style used for the scene
+      void setSceneRenderStyle(SceneRenderStyle style) { mSceneRenderStyle = style; }
+
+      /// Get the stereo field being rendered
+      S32 getSceneRenderField() const { return mRenderField; }
+
+      /// Set the stereo field being rendered
+      void setSceneRenderField(S32 field) { mRenderField = field; }
+
+      /// @}
+
       /// @name Transforms, projections, and viewports.
       /// @{