Merge pull request #3799 from samcake/temp0

improvement on stereo rendering (but not Occulus....)

interface/src/Application.cpp

@@ -2878,7 +2878,7 @@ QImage Application::renderAvatarBillboard() {
     return image;
 }
 
-void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
+void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly, RenderArgs::RenderSide renderSide) {
     PROFILE_RANGE(__FUNCTION__);
     PerformanceTimer perfTimer("display");
     PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "Application::displaySide()");
@@ -3025,7 +3025,7 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
             PerformanceTimer perfTimer("entities");
             PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
                 "Application::displaySide() ... entities...");
-            _entities.render();
+            _entities.render(RenderArgs::DEFAULT_RENDER_MODE, renderSide);
         }
 
         // render JS/scriptable overlays

interface/src/Application.h

@@ -265,7 +265,7 @@ public:
 
     QImage renderAvatarBillboard();
 
-    void displaySide(Camera& whichCamera, bool selfAvatarOnly = false);
+    void displaySide(Camera& whichCamera, bool selfAvatarOnly = false, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
 
     /// Stores the current modelview matrix as the untranslated view matrix to use for transforms and the supplied vector as
     /// the view matrix translation.

interface/src/devices/TV3DManager.cpp

@@ -126,7 +126,7 @@ void TV3DManager::display(Camera& whichCamera) {
 
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
-        Application::getInstance()->displaySide(whichCamera);
+        Application::getInstance()->displaySide(whichCamera, false, RenderArgs::STEREO_LEFT);
 
         if (displayOverlays) {
             applicationOverlay.displayOverlayTexture3DTV(whichCamera, _aspect, fov);
@@ -156,7 +156,7 @@ void TV3DManager::display(Camera& whichCamera) {
 
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
-        Application::getInstance()->displaySide(whichCamera);
+        Application::getInstance()->displaySide(whichCamera, false, RenderArgs::STEREO_RIGHT);
 
         if (displayOverlays) {
             applicationOverlay.displayOverlayTexture3DTV(whichCamera, _aspect, fov);

interface/src/entities/EntityTreeRenderer.cpp

@@ -252,15 +252,15 @@ void EntityTreeRenderer::checkEnterLeaveEntities() {
     }
 }
 
-void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode) {
+void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode, RenderArgs::RenderSide renderSide) {
     bool dontRenderAsScene = !Menu::getInstance()->isOptionChecked(MenuOption::RenderEntitiesAsScene);
     
     if (dontRenderAsScene) {
-        OctreeRenderer::render(renderMode);
+        OctreeRenderer::render(renderMode, renderSide);
     } else {
         if (_tree) {
-            Model::startScene();
+            Model::startScene(renderSide);
-            RenderArgs args = { this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, 
+            RenderArgs args = { this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, renderSide,
                                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
             _tree->lockForRead();
             _tree->recurseTreeWithOperation(renderOperation, &args);

interface/src/entities/EntityTreeRenderer.h

@@ -56,7 +56,7 @@ public:
     void processEraseMessage(const QByteArray& dataByteArray, const SharedNodePointer& sourceNode);
 
     virtual void init();
-    virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE);
+    virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
 
     virtual const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem);
     virtual const Model* getModelForEntityItem(const EntityItem* entityItem);

interface/src/renderer/Model.cpp

@@ -1484,8 +1484,10 @@ void Model::deleteGeometry() {
 // Scene rendering support
 QVector<Model*> Model::_modelsInScene;
 gpu::Batch Model::_sceneRenderBatch;
-void Model::startScene() {
+void Model::startScene(RenderArgs::RenderSide renderSide) {
+    if (renderSide != RenderArgs::STEREO_RIGHT) {
         _modelsInScene.clear();
+    }
 }
 
 void Model::setupBatchTransform(gpu::Batch& batch) {
@@ -1503,6 +1505,13 @@ void Model::setupBatchTransform(gpu::Batch& batch) {
 void Model::endScene(RenderMode mode, RenderArgs* args) {
     PROFILE_RANGE(__FUNCTION__);
 
+    RenderArgs::RenderSide renderSide = RenderArgs::MONO;
+    if (args) {
+        renderSide = args->_renderSide;
+    }
+
+    // Do the rendering batch creation for mono or left eye, not for right eye
+    if (renderSide != RenderArgs::STEREO_RIGHT) {
         // Let's introduce a gpu::Batch to capture all the calls to the graphics api
         _sceneRenderBatch.clear();
         gpu::Batch& batch = _sceneRenderBatch;
@@ -1629,20 +1638,22 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
         GLBATCH(glBindBuffer)(GL_ARRAY_BUFFER, 0);
         GLBATCH(glBindBuffer)(GL_ELEMENT_ARRAY_BUFFER, 0);
         GLBATCH(glBindTexture)(GL_TEXTURE_2D, 0);
+    if (args) {
+        args->_translucentMeshPartsRendered = translucentParts;
+        args->_opaqueMeshPartsRendered = opaqueMeshPartsRendered;
+    }
+
+    }
 
     // Render!
     {
         PROFILE_RANGE("render Batch");
-        ::gpu::GLBackend::renderBatch(batch);
+        ::gpu::GLBackend::renderBatch(_sceneRenderBatch);
     }
 
     // restore all the default material settings
     Application::getInstance()->setupWorldLight();
     
-    if (args) {
-        args->_translucentMeshPartsRendered = translucentParts;
-        args->_opaqueMeshPartsRendered = opaqueMeshPartsRendered;
-    }
 }
 
 bool Model::renderInScene(float alpha, RenderArgs* args) {

interface/src/renderer/Model.h

@@ -31,7 +31,7 @@
 class QScriptEngine;
 
 class Shape;
-class RenderArgs;
+#include "RenderArgs.h"
 class ViewFrustum;
 
 
@@ -91,7 +91,7 @@ public:
     bool render(float alpha = 1.0f, RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
     
     // Scene rendering support
-    static void startScene();
+    static void startScene(RenderArgs::RenderSide renderSide);
     bool renderInScene(float alpha = 1.0f, RenderArgs* args = NULL);
     static void endScene(RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
 

interface/src/ui/overlays/Overlays.cpp

@@ -86,14 +86,14 @@ void Overlays::render2D() {
 
     RenderArgs args = { NULL, Application::getInstance()->getViewFrustum(),
         Menu::getInstance()->getVoxelSizeScale(), Menu::getInstance()->getBoundaryLevelAdjust(),
-        RenderArgs::DEFAULT_RENDER_MODE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::MONO, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
     foreach(Overlay* thisOverlay, _overlays2D) {
         thisOverlay->render(&args);
     }
 }
 
-void Overlays::render3D(RenderArgs::RenderMode renderMode) {
+void Overlays::render3D(RenderArgs::RenderMode renderMode, RenderArgs::RenderSide renderSide) {
     QReadLocker lock(&_lock);
     if (_overlays3D.size() == 0) {
         return;
@@ -108,7 +108,7 @@ void Overlays::render3D(RenderArgs::RenderMode renderMode) {
     
     RenderArgs args = { NULL, Application::getInstance()->getViewFrustum(),
                         Menu::getInstance()->getVoxelSizeScale(), Menu::getInstance()->getBoundaryLevelAdjust(), 
-                        renderMode, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+                        renderMode, renderSide, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     
 
     foreach(Overlay* thisOverlay, _overlays3D) {

interface/src/ui/overlays/Overlays.h

@@ -51,7 +51,7 @@ public:
     ~Overlays();
     void init(QGLWidget* parent);
     void update(float deltatime);
-    void render3D(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE);
+    void render3D(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
     void render2D();
 
 public slots:

libraries/octree/src/OctreeRenderer.cpp

@@ -162,8 +162,8 @@ bool OctreeRenderer::renderOperation(OctreeElement* element, void* extraData) {
     return false;
 }
 
-void OctreeRenderer::render(RenderArgs::RenderMode renderMode) {
+void OctreeRenderer::render(RenderArgs::RenderMode renderMode, RenderArgs::RenderSide renderSide) {
-    RenderArgs args = { this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, 
+    RenderArgs args = { this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, renderSide, 
                                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     if (_tree) {
         _tree->lockForRead();

libraries/octree/src/OctreeRenderer.h

@@ -52,7 +52,7 @@ public:
     virtual void init();
 
     /// render the content of the octree
-    virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE);
+    virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
 
     ViewFrustum* getViewFrustum() const { return _viewFrustum; }
     void setViewFrustum(ViewFrustum* viewFrustum) { _viewFrustum = viewFrustum; }

libraries/shared/src/RenderArgs.h

@@ -18,12 +18,14 @@ class OctreeRenderer;
 class RenderArgs {
 public:
     enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE };
+    enum RenderSide { MONO, STEREO_LEFT, STEREO_RIGHT };
 
     OctreeRenderer* _renderer;
     ViewFrustum* _viewFrustum;
     float _sizeScale;
     int _boundaryLevelAdjust;
     RenderMode _renderMode;
+    RenderSide _renderSide;
 
     int _elementsTouched;
     int _itemsRendered;