updated other handlers and removed renderers re #21248

Framework/Geometry/inc/MantidGeometry/Rendering/GeometryRenderer.h

@@ -41,25 +41,52 @@ class IObjComponent;
 class MANTID_GEOMETRY_DLL GeometryRenderer {
 public:
   enum class RenderMode { Basic, Volumetric };
-
-  enum class RenderShape {
-    Sphere,
-    Cube,
-    Cone,
-    Hexahedron,
-    Cylinder,
-    SegmentedCylinder
-  };
-
   GeometryRenderer() = default;
   ~GeometryRenderer() = default;
 
-  template <typename... Args> void Render(RenderMode mode, Args &&... args) &;
+  /// General method for rendering geometry
+  template <typename... Args>
+  void render(RenderMode mode, Args &&... args) const &;
 
-  template <typename... Args> void Render(Args &&... args) &;
+  /// Render Basic geometry without transparency (non-volumetric)
+  template <typename... Args> void render(Args &&... args) const &;
+
+  /// Render IObjComponent
+  void renderIObjComponent(IObjComponent *objComp,
+                           RenderMode mode = RenderMode::Basic) const;
+  /// Render Traingulated Surface
+  void renderTriangulated(int noPts, int noFaces, double *points, int *faces,
+                          RenderMode mode = RenderMode::Basic) const;
+  /// Render OpenCascade Shape
+  void renderOpenCascade(TopoDS_Shape *objSurf,
+                         RenderMode mode = RenderMode::Basic) const;
+  /// Renders a sphere
+  void renderSphere(const Kernel::V3D &center, double radius,
+                    RenderMode mode = RenderMode::Basic) const;
+  /// Renders a cuboid
+  void renderCuboid(const Kernel::V3D &Point1, const Kernel::V3D &Point2,
+                    const Kernel::V3D &Point3, const Kernel::V3D &Point4,
+                    RenderMode mode = RenderMode::Basic) const;
+  /// Renders a Hexahedron from the input values
+  void renderHexahedron(const std::vector<Kernel::V3D> &points,
+                        RenderMode mode = RenderMode::Basic) const;
+  /// Renders a Cone from the input values
+  void renderCone(const Kernel::V3D &center, const Kernel::V3D &axis,
+                  double radius, double height,
+                  RenderMode mode = RenderMode::Basic) const;
+  /// Renders a Cylinder/Segmented cylinder from the input values
+  void renderCylinder(const Kernel::V3D &center, const Kernel::V3D &axis,
+                      double radius, double height, bool segmented = false,
+                      RenderMode mode = RenderMode::Basic) const;
+  /// Renders a Bitmap (used for rendering RectangularDetector)
+  void renderBitmap(const RectangularDetector *rectDet,
+                    RenderMode mode = RenderMode::Basic) const;
+  /// Renders structured geometry (used for rendering StructuredDetector)
+  void renderStructured(const StructuredDetector *structDet,
+                        RenderMode mode = RenderMode::Basic) const;
 
 private:
-  RenderMode m_renderMode;
+  mutable RenderMode m_renderMode;
   // general geometry
   /// Render IObjComponent
   void doRender(IObjComponent *ObjComp) const;
@@ -81,7 +108,7 @@ private:
                 double radius, double height) const;
   /// Renders a Cylinder/Segmented cylinder from the input values
   void doRender(const Kernel::V3D &center, const Kernel::V3D &axis,
-                double radius, double height, bool segmented = false) const;
+                double radius, double height, bool segmented) const;
   /// Renders a Bitmap (used for rendering RectangularDetector)
   void doRender(const RectangularDetector *rectDet) const;
   /// Renders structured geometry (used for rendering StructuredDetector)
@@ -89,7 +116,7 @@ private:
 };
 
 template <typename... Args>
-void GeometryRenderer::Render(RenderMode mode, Args &&... args) & {
+void GeometryRenderer::render(RenderMode mode, Args &&... args) const & {
   // Wait for no OopenGL error
   while (glGetError() != GL_NO_ERROR)
     ;
@@ -97,9 +124,11 @@ void GeometryRenderer::Render(RenderMode mode, Args &&... args) & {
   doRender(std::forward<Args>(args)...);
 }
 
-template <typename... Args> void GeometryRenderer::Render(Args &&... args) & {
-  Render(RenderMode::Basic, std::forward<Args>(args)...);
+template <typename... Args>
+void GeometryRenderer::render(Args &&... args) const & {
+  render(RenderMode::Basic, std::forward<Args>(args)...);
 }
+
 } // namespace Geometry
 } // namespace Mantid
 

Framework/Geometry/inc/MantidGeometry/Rendering/vtkGeometryCacheWriter.h

-#ifndef VTKGEOMETRYCACHEWRITER_H
-#define VTKGEOMETRYCACHEWRITER_H
-
-#include "MantidGeometry/DllConfig.h"
-#include <string>
-
-namespace Poco {
-namespace XML {
-class Document;
-class Element;
-}
-}
-namespace Mantid {
-
-namespace Geometry {
-/**
-   \class vtkGeometryCacheWriter
-   \brief Writes the Geometry from Object to Cache
-   \author Srikanth Nagella
-   \date January 2009
-   \version 1.0
-
-   This class writes the geometry (triangles) cached from Object to the vtk
-   format file.
-
-   Copyright &copy; 2008 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
-   National Laboratory & European Spallation Source
-
-   This file is part of Mantid.
-
-   Mantid is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   Mantid is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-   File change history is stored at: <https://github.com/mantidproject/mantid>
-*/
-class CSGObject;
-class MANTID_GEOMETRY_DLL vtkGeometryCacheWriter {
-private:
-  Poco::XML::Document *mDoc; ///< The XML document
-  Poco::XML::Element *mRoot; ///< The root XML element
-  std::string mFileName;     ///< The file name
-  // Private Methods
-  void Init();
-  void createVTKFileHeader();
-
-public:
-  vtkGeometryCacheWriter(std::string); ///< Constructor
-  ~vtkGeometryCacheWriter();           ///< Destructor
-  void addObject(CSGObject *obj);
-  void write(); ///< Write the XML to a file
-};
-
-} // NAMESPACE Geometry
-
-} // NAMESPACE Mantid
-
-#endif

Framework/Geometry/src/Rendering/GeometryRenderer.cpp

@@ -49,6 +49,63 @@ namespace Geometry {
 using Kernel::Quat;
 using Kernel::V3D;
 
+void GeometryRenderer::renderIObjComponent(IObjComponent *objComp,
+                                           RenderMode mode) const {
+  render(mode, objComp);
+}
+
+void GeometryRenderer::renderTriangulated(int noPts, int noFaces,
+                                          double *points, int *faces,
+                                          RenderMode mode) const {
+  render(mode, noPts, noFaces, points, faces);
+}
+
+void GeometryRenderer::renderOpenCascade(TopoDS_Shape *objSurf,
+                                         RenderMode mode) const {
+  render(mode, objSurf);
+}
+
+void GeometryRenderer::renderSphere(const Kernel::V3D &center, double radius,
+                                    RenderMode mode) const {
+  render(mode, center, radius);
+}
+
+void GeometryRenderer::renderCuboid(const Kernel::V3D &Point1,
+                                    const Kernel::V3D &Point2,
+                                    const Kernel::V3D &Point3,
+                                    const Kernel::V3D &Point4,
+                                    RenderMode mode) const {
+  render(mode, Point1, Point2, Point3, Point4);
+}
+
+void GeometryRenderer::renderHexahedron(const std::vector<Kernel::V3D> &points,
+                                        RenderMode mode) const {
+  render(mode, points);
+}
+
+void GeometryRenderer::renderCone(const Kernel::V3D &center,
+                                  const Kernel::V3D &axis, double radius,
+                                  double height, RenderMode mode) const {
+  render(mode, center, axis, radius, height);
+}
+
+void GeometryRenderer::renderCylinder(const Kernel::V3D &center,
+                                      const Kernel::V3D &axis, double radius,
+                                      double height, bool segmented,
+                                      RenderMode mode) const {
+  render(mode, center, axis, radius, height, segmented);
+}
+
+void GeometryRenderer::renderBitmap(const RectangularDetector *rectDet,
+                                    RenderMode mode) const {
+  render(mode, rectDet);
+}
+
+void GeometryRenderer::renderStructured(const StructuredDetector *structDet,
+                                        RenderMode mode) const {
+  render(mode, structDet);
+}
+
 // Render IObjectComponent
 void GeometryRenderer::doRender(IObjComponent *ObjComp) const {
   glPushMatrix();
@@ -332,7 +389,7 @@ void GeometryRenderer::doRender(const RectangularDetector *rectDet) const {
 
   glEnd();
   if (glGetError() > 0)
-    std::cout << "OpenGL error in BitmapGeometryHandler::Render \n";
+    std::cout << "OpenGL error in BitmapGeometryHandler::render \n";
 
   glDisable(
       GL_TEXTURE_2D); // stop texture mapping - not sure if this is necessary.
@@ -379,7 +436,7 @@ void GeometryRenderer::doRender(const StructuredDetector *structDet) const {
   glEnd();
 
   if (glGetError() > 0)
-    std::cout << "OpenGL error in StructuredGeometryHandler::Render \n";
+    std::cout << "OpenGL error in StructuredGeometryHandler::render \n";
 
   glDisable(
       GL_TEXTURE_2D); // stop texture mapping - not sure if this is necessary.