handle per model transforms, default scene mode off

interface/src/Menu.cpp

@@ -438,7 +438,7 @@ Menu::Menu() :
     addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::DisableLightEntities, 0, false);
 
     addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::DontReduceMaterialSwitches, 0, false);
-    addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::DontRenderEntitiesAsScene, 0, false);
+    addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::RenderEntitiesAsScene, 0, false);
 
     QMenu* entityCullingMenu = entitiesDebugMenu->addMenu("Culling");
     addCheckableActionToQMenuAndActionHash(entityCullingMenu, MenuOption::DontCullOutOfViewMeshParts, 0, false);

interface/src/Menu.h

@@ -377,7 +377,6 @@ namespace MenuOption {
     const QString DontCullOutOfViewMeshParts = "Don't Cull Out Of View Mesh Parts";
     const QString DontCullTooSmallMeshParts = "Don't Cull Too Small Mesh Parts";
     const QString DontReduceMaterialSwitches = "Don't Attempt to Reduce Material Switches";
-    const QString DontRenderEntitiesAsScene = "Don't Render Entities as Scene";
     const QString DecreaseAvatarSize = "Decrease Avatar Size";
     const QString DecreaseVoxelSize = "Decrease Voxel Size";
     const QString DisableActivityLogger = "Disable Activity Logger";
@@ -448,6 +447,7 @@ namespace MenuOption {
     const QString ReloadAllScripts = "Reload All Scripts";
     const QString RenderBoundingCollisionShapes = "Show Bounding Collision Shapes";
     const QString RenderDualContourSurfaces = "Render Dual Contour Surfaces";
+    const QString RenderEntitiesAsScene = "Render Entities as Scene";
     const QString RenderFocusIndicator = "Show Eye Focus";
     const QString RenderHeadCollisionShapes = "Show Head Collision Shapes";
     const QString RenderHeightfields = "Render Heightfields";

interface/src/entities/EntityTreeRenderer.cpp

@@ -253,7 +253,7 @@ void EntityTreeRenderer::checkEnterLeaveEntities() {
 }
 
 void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode) {
-    bool dontRenderAsScene = Menu::getInstance()->isOptionChecked(MenuOption::DontRenderEntitiesAsScene);
+    bool dontRenderAsScene = !Menu::getInstance()->isOptionChecked(MenuOption::RenderEntitiesAsScene);
     
     if (dontRenderAsScene) {
         OctreeRenderer::render(renderMode);

interface/src/entities/RenderableModelEntityItem.cpp

@@ -172,7 +172,7 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
                     // TODO: this is the majority of model render time. And rendering of a cube model vs the basic Box render
                     // is significantly more expensive. Is there a way to call this that doesn't cost us as much? 
                     PerformanceTimer perfTimer("model->render");
-                    bool dontRenderAsScene = Menu::getInstance()->isOptionChecked(MenuOption::DontRenderEntitiesAsScene);
+                    bool dontRenderAsScene = !Menu::getInstance()->isOptionChecked(MenuOption::RenderEntitiesAsScene);
                     if (dontRenderAsScene) {
                         _model->render(alpha, modelRenderMode, args);
                     } else {

interface/src/renderer/Model.cpp

@@ -1483,15 +1483,29 @@ void Model::deleteGeometry() {
 
 // Scene rendering support
 QVector<Model*> Model::_modelsInScene;
+gpu::Batch Model::_sceneRenderBatch;
 void Model::startScene() {
     _modelsInScene.clear();
 }
 
-void Model::endScene(RenderMode mode, RenderArgs* args) {
+void Model::setupBatchTransform(gpu::Batch& batch) {
+    GLBATCH(glPushMatrix)();
+    
+    // Capture the view matrix once for the rendering of this model
+    if (_transforms.empty()) {
+        _transforms.push_back(gpu::TransformPointer(new gpu::Transform()));
+    }
+    (*_transforms[0]) = gpu::Transform((*Application::getInstance()->getViewTransform()));
+    _transforms[0]->preTranslate(-_translation);
+    batch.setViewTransform(_transforms[0]);
+}
+
+void Model::endScene(RenderMode mode, RenderArgs* args) {
+    PROFILE_RANGE(__FUNCTION__);
 
-    // first, do all the batch/GPU setup work....
     // Let's introduce a gpu::Batch to capture all the calls to the graphics api
-    gpu::Batch batch;
+    _sceneRenderBatch.clear();
+    gpu::Batch& batch = _sceneRenderBatch;
 
     GLBATCH(glDisable)(GL_COLOR_MATERIAL);
     
@@ -1540,28 +1554,44 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
 
     // now, for each model in the scene, render the mesh portions
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, true, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, true, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, true, true, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, true, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, true, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         opaqueMeshPartsRendered += model->renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, true, args);
+        GLBATCH(glPopMatrix)();
     }
     
     // render translucent meshes afterwards
@@ -1577,28 +1607,44 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
     int translucentParts = 0;
     const float MOSTLY_OPAQUE_THRESHOLD = 0.75f;
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, true, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, true, false, args);
+        GLBATCH(glPopMatrix)();
     }
     foreach(Model* model, _modelsInScene) {
+        model->setupBatchTransform(batch);
         translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, true, args);
+        GLBATCH(glPopMatrix)();
     }
     
     GLBATCH(glDisable)(GL_ALPHA_TEST);
@@ -1617,28 +1663,44 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
     if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) {
         const float MOSTLY_TRANSPARENT_THRESHOLD = 0.0f;
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, args);
+            GLBATCH(glPopMatrix)();
         }
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, args);
+            GLBATCH(glPopMatrix)();
         }
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, args);
+            GLBATCH(glPopMatrix)();
         }
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, args);
+            GLBATCH(glPopMatrix)();
         }
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, false, args);
+            GLBATCH(glPopMatrix)();
         }
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, true, args);
+            GLBATCH(glPopMatrix)();
         }
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, true, false, args);
+            GLBATCH(glPopMatrix)();
         }
         foreach(Model* model, _modelsInScene) {
+            model->setupBatchTransform(batch);
             translucentParts += model->renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, true, args);
+            GLBATCH(glPopMatrix)();
         }
     }
 
@@ -1668,7 +1730,6 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
     {
         PROFILE_RANGE("render Batch");
         ::gpu::GLBackend::renderBatch(batch);
-        batch.clear();
     }
 
     // restore all the default material settings

interface/src/renderer/Model.h

@@ -284,7 +284,7 @@ private:
 
     gpu::Buffers _blendedVertexBuffers;
     gpu::Transforms _transforms;
-    gpu::Batch  _renderBatch;
+    gpu::Batch _renderBatch;
 
     QVector<QVector<QSharedPointer<Texture> > > _dilatedTextures;
     
@@ -398,6 +398,8 @@ private:
 
     // Scene rendering support
     static QVector<Model*> _modelsInScene;
+    static gpu::Batch _sceneRenderBatch;
+
     static void endSceneSimple(RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
     static void endSceneSplitPass(RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
 
@@ -406,6 +408,8 @@ private:
     bool renderCore(float alpha, RenderMode mode, RenderArgs* args);
     int renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, 
                         bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args = NULL);
+    void setupBatchTransform(gpu::Batch& batch);
+
 };
 
 Q_DECLARE_METATYPE(QPointer<Model>)