#5893: Move all renderer algorithm from OpenGLRenderSystem to separat…

…e SceneRenderer implementations, one for Lighting Mode, one for FullBright Mode.

include/irender.h

@@ -662,24 +662,12 @@ class RenderSystem
      * render flag which is 0 in this mask will not be enabled during rendering,
      * even if the particular shader requests it.
      *
-     * \param modelview
-     * The modelview transformation matrix to apply before rendering.
-     *
-     * \param projection
-     * The view projection matrix to apply before rendering.
-     *
-     * \param viewer
-     * Location of the viewer in world space.
-     * 
-     * * \param volume
-     * The volume structure that can be used for culling.
+     * * \param view
+     * The view used to setup the projection, modelview and lighting calculations.
      */
     virtual void render(RenderViewType renderViewType,
                         RenderStateFlags globalFlagsMask,
-                        const Matrix4& modelview,
-                        const Matrix4& projection,
-                        const Vector3& viewer,
-                        const VolumeTest& volume) = 0;
+                        const render::IRenderView& view) = 0;
 
     virtual void startFrame() = 0;
     virtual void endFrame() = 0;

libs/render/NopRenderView.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "irenderview.h"
+#include "NopVolumeTest.h"
+#include "math/Frustum.h"
+#include "math/Viewer.h"
+
+namespace render
+{
+
+class NopRenderView :
+    public IRenderView
+{
+private:
+    NopVolumeTest _volumeTest;
+    Frustum _frustum;
+    Viewer _viewer;
+
+public:
+    bool TestPoint(const Vector3& point) const { return _volumeTest.TestPoint(point); }
+    bool TestLine(const Segment& segment) const { return _volumeTest.TestLine(segment); }
+    bool TestPlane(const Plane3& plane) const { return _volumeTest.TestPlane(plane); }
+    bool TestPlane(const Plane3& plane, const Matrix4& localToWorld) const { return _volumeTest.TestPlane(plane, localToWorld); }
+
+    VolumeIntersectionValue TestAABB(const AABB& aabb) const
+    {
+        return _volumeTest.TestAABB(aabb);
+    }
+
+    VolumeIntersectionValue TestAABB(const AABB& aabb, const Matrix4& localToWorld) const
+    { 
+        return _volumeTest.TestAABB(aabb, localToWorld);
+    }
+
+    bool fill() const { return _volumeTest.fill(); }
+
+    const Matrix4& GetViewProjection() const { return _volumeTest.GetViewProjection(); }
+    const Matrix4& GetViewport() const { return _volumeTest.GetViewport(); }
+    const Matrix4& GetProjection() const { return _volumeTest.GetProjection(); }
+    const Matrix4& GetModelview() const { return _volumeTest.GetModelview(); }
+
+    void construct(const Matrix4& projection, const Matrix4& modelview, std::size_t width, std::size_t height) override
+    {
+        _volumeTest.setProjection(projection);
+        _volumeTest.setModelView(modelview);
+
+        _frustum = Frustum::createFromViewproj(_volumeTest.GetViewProjection());
+        _viewer = Viewer::createFromViewProjection(_volumeTest.GetViewProjection());
+    }
+
+    Vector3 getViewer() const override
+    {
+        return _viewer.getVector3();
+    }
+
+    const Frustum& getFrustum() const override
+    {
+        return _frustum;
+    }
+
+    std::string getCullStats() const override
+    {
+        return {};
+    }
+};
+
+}

libs/wxutil/preview/RenderPreview.cpp

@@ -478,30 +478,29 @@ bool RenderPreview::drawPreview()
     Matrix4 projection = camera::calculateProjectionMatrix(0.1f, 10000, PREVIEW_FOV, _previewWidth, _previewHeight);
 
     // Keep the modelview matrix in the volumetest class up to date
-    _volumeTest.setModelView(getModelViewMatrix());
-    _volumeTest.setProjection(projection);
+    _view.construct(projection, getModelViewMatrix(), _previewWidth, _previewHeight);
 
 	// Set the projection and modelview matrices
 	glMatrixMode(GL_PROJECTION);
 	glLoadMatrixd(projection);
 
 	glMatrixMode(GL_MODELVIEW);
-	glLoadMatrixd(_volumeTest.GetModelview());
+	glLoadMatrixd(_view.GetModelview());
 
 	if (_renderGrid && canDrawGrid())
 	{
 		drawGrid();
 	}
 
 	// Front-end render phase, collect OpenGLRenderable objects from the scene
-    render::CamRenderer renderer(_volumeTest, _shaders);
-    render::SceneRenderWalker sceneWalker(renderer, _volumeTest);
-    getScene()->foreachVisibleNodeInVolume(_volumeTest, sceneWalker);
+    render::CamRenderer renderer(_view, _shaders);
+    render::SceneRenderWalker sceneWalker(renderer, _view);
+    getScene()->foreachVisibleNodeInVolume(_view, sceneWalker);
 
     RenderStateFlags flags = getRenderFlagsFill();
 
     // Launch the back end rendering
-    _renderSystem->render(RenderViewType::Camera, flags, _volumeTest.GetModelview(), projection, _viewOrigin, _volumeTest);
+    _renderSystem->render(RenderViewType::Camera, flags, _view);
 
     // Give subclasses an opportunity to render their own on-screen stuff
     onPostRender();
@@ -520,12 +519,12 @@ void RenderPreview::renderWireFrame()
     Matrix4 projection = camera::calculateProjectionMatrix(0.1f, 10000, PREVIEW_FOV, _previewWidth, _previewHeight);
 
     // Front-end render phase, collect OpenGLRenderable objects from the scene
-    render::CamRenderer renderer(_volumeTest, _shaders);
-    render::SceneRenderWalker sceneWalker(renderer, _volumeTest);
-    getScene()->foreachVisibleNodeInVolume(_volumeTest, sceneWalker);
+    render::CamRenderer renderer(_view, _shaders);
+    render::SceneRenderWalker sceneWalker(renderer, _view);
+    getScene()->foreachVisibleNodeInVolume(_view, sceneWalker);
 
     // Launch the back end rendering
-    _renderSystem->render(RenderViewType::Camera, flags, _volumeTest.GetModelview(), projection, _viewOrigin, _volumeTest);
+    _renderSystem->render(RenderViewType::Camera, flags, _view);
 }
 
 void RenderPreview::onGLMouseClick(wxMouseEvent& ev)

libs/wxutil/preview/RenderPreview.h

@@ -12,7 +12,7 @@
 #include "irender.h"
 
 #include "../FreezePointer.h"
-#include "render/NopVolumeTest.h"
+#include "render/NopRenderView.h"
 #include "render/CamRenderer.h"
 
 class wxToolBarToolBase;
@@ -94,8 +94,8 @@ class RenderPreview :
     // The backend rendersystem instance
     RenderSystemPtr _renderSystem;
 
-    // Dummy VolumeTest
-    render::NopVolumeTest _volumeTest;
+    // Uses a dummy VolumeTest implementation
+    render::NopRenderView _view;
 
     // Current viewer position and view angles
     Vector3 _viewOrigin;

radiant/camera/CamWnd.cpp

@@ -810,8 +810,7 @@ void CamWnd::Cam_Draw()
         }
         else
         {
-            GlobalRenderSystem().render(RenderViewType::Camera, allowedRenderFlags,
-                _camera->getModelView(), _camera->getProjection(), _view.getViewer(), _view);
+            GlobalRenderSystem().render(RenderViewType::Camera, allowedRenderFlags, _view);
         }
 
         _renderer->cleanup();

radiant/xyview/XYRenderer.h

@@ -78,8 +78,8 @@ class XYRenderer :
         }
     }
 
-    void render(const Matrix4& modelview, const Matrix4& projection, const VolumeTest& view)
+    void render(const Matrix4& modelview, const Matrix4& projection, const render::IRenderView& view)
     {
-        GlobalRenderSystem().render(RenderViewType::OrthoView, _globalstate, modelview, projection, Vector3(0,0,0), view);
+        GlobalRenderSystem().render(RenderViewType::OrthoView, _globalstate, view);
     }
 }; // class XYRenderer

radiantcore/CMakeLists.txt

@@ -219,6 +219,9 @@ add_library(radiantcore MODULE
             rendersystem/backend/BuiltInShader.cpp
             rendersystem/backend/ColourShader.cpp
             rendersystem/backend/LightInteractions.cpp
+            rendersystem/backend/SceneRenderer.cpp
+            rendersystem/backend/FullBrightRenderer.cpp
+            rendersystem/backend/LightingModeRenderer.cpp
             rendersystem/backend/ObjectRenderer.cpp
             rendersystem/backend/OpenGLShader.cpp
             rendersystem/backend/OpenGLShaderPass.cpp