Allow use of renderers and cameras defined in external modules (#310)

brayns/Brayns.cpp

@@ -970,7 +970,7 @@ struct Brayns::Impl
     {
         RenderingParameters& renderParams =
             _parametersManager.getRenderingParameters();
-        renderParams.setRenderer(RendererType::basic);
+        renderParams.setRenderer(RendererType::default_);
     }
 
     void _particleRenderer()

brayns/common/camera/Camera.h

@@ -215,7 +215,7 @@ class Camera : public BaseObject
     */
     const ClipPlanes& getClipPlanes() const { return _clipPlanes; }
 private:
-    CameraType _type{CameraType::perspective};
+    CameraType _type{CameraType::default_};
     Vector3f _position;
     Vector3f _target;
     Vector3f _up;

brayns/common/types.h

@@ -179,7 +179,7 @@ class Statistics;
 /** Types of renderers */
 enum class RendererType
 {
-    basic,
+    default_,
     proximity,
     simulation,
     particle,
@@ -332,7 +332,7 @@ enum class ShadingType
 
 enum class CameraType
 {
-    perspective,
+    default_, // Perspective
     stereo,
     orthographic,
     panoramic,

brayns/parameters/RenderingParameters.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2015-2017, EPFL/Blue Brain Project
+/* Copyright (c) 2015-2018, EPFL/Blue Brain Project
  * All rights reserved. Do not distribute without permission.
  * Responsible Author: Cyrille Favreau <cyrille.favreau@epfl.ch>
  *
@@ -45,38 +45,43 @@ const std::string PARAM_DETECTION_ON_DIFFERENT_MATERIAL =
 const std::string PARAM_DETECTION_NEAR_COLOR = "detection-near-color";
 const std::string PARAM_DETECTION_FAR_COLOR = "detection-far-color";
 const std::string PARAM_EPSILON = "epsilon";
-const std::string PARAM_CAMERA_TYPE = "camera-type";
+const std::string PARAM_CAMERA = "camera";
 const std::string PARAM_HEAD_LIGHT = "head-light";
 const std::string PARAM_VARIANCE_THRESHOLD = "variance-threshold";
 
-const std::string ENGINES[2] = {"ospray", "optix"};
-const std::string RENDERERS[7] = {"basic",
-                                  "proximity",
-                                  "simulation",
-                                  "particle",
-                                  "geometrynormals",
-                                  "shadingnormals",
-                                  "scientificvisualization"};
-const std::string RENDERER_NAMES[7] = {"basic",
-                                       "proximityrenderer",
-                                       "simulationrenderer",
-                                       "particlerenderer",
-                                       "raycast_Ng",
-                                       "raycast_Ns",
-                                       "scivis"};
+const std::array<std::string, 2> ENGINES = {"ospray", "optix"};
+const std::array<std::string, 7> RENDERERS = {"default",
+                                              "proximity",
+                                              "simulation",
+                                              "particle",
+                                              "geometrynormals",
+                                              "shadingnormals",
+                                              "scientificvisualization"};
 
-const std::string CAMERA_TYPES[5] = {"perspective", "stereo", "orthographic",
-                                     "panoramic", "clipped"};
+const std::array<std::string, 7> RENDERER_INTERNAL_NAMES = {
+    "basic",
+    "proximityrenderer",
+    "simulationrenderer",
+    "particlerenderer",
+    "raycast_Ng",
+    "raycast_Ns",
+    "scivis"};
 
-const std::string SHADING_TYPES[3] = {"none", "diffuse", "electron"};
+const std::array<std::string, 5> CAMERA_TYPE_NAMES = {"perspective", "stereo",
+                                                      "orthographic",
+                                                      "panoramic", "clipped"};
+
+const std::array<std::string, 3> SHADING_TYPES = {"none", "diffuse",
+                                                  "electron"};
 }
 
 namespace brayns
 {
 RenderingParameters::RenderingParameters()
     : AbstractParameters("Rendering")
     , _engine(EngineType::ospray)
-    , _renderer(RendererType::basic)
+    , _renderer(RendererType::default_)
+    , _cameraType(CameraType::default_)
     , _ambientOcclusionStrength(0.f)
     , _ambientOcclusionDistance(1.20f)
     , _shading(ShadingType::diffuse)
@@ -90,15 +95,14 @@ RenderingParameters::RenderingParameters()
     , _detectionNearColor(1.f, 0.f, 0.f)
     , _detectionFarColor(0.f, 1.f, 0.f)
     , _epsilon(0.f)
-    , _cameraType(CameraType::perspective)
     , _headLight(false)
 {
     _parameters.add_options()(PARAM_ENGINE.c_str(), po::value<std::string>(),
                               "Engine name [ospray|optix]")(
         PARAM_MODULE.c_str(), po::value<std::string>(),
         "OSPRay module name [string]")(
         PARAM_RENDERER.c_str(), po::value<std::string>(),
-        "OSPRay active renderer [basic|simulation|proximity|particle]")(
+        "OSPRay active renderer [default|simulation|proximity|particle]")(
         PARAM_SPP.c_str(), po::value<size_t>(),
         "Number of samples per pixel [int]")(
         PARAM_ACCUMULATION.c_str(), po::value<bool>(),
@@ -128,15 +132,23 @@ RenderingParameters::RenderingParameters()
         PARAM_EPSILON.c_str(), po::value<float>(),
         "All intersection distances less than the "
         "epsilon value are ignored by the ray-tracer [float]")(
-        PARAM_CAMERA_TYPE.c_str(), po::value<std::string>(),
-        "Camera type [perspective|stereo|orthographic|panoramic]")(
+        PARAM_CAMERA.c_str(), po::value<std::string>(),
+        "Camera [perspective|stereo|orthographic|panoramic]")(
         PARAM_HEAD_LIGHT.c_str(), po::value<bool>(),
         "Enable/Disable light source attached to camera origin [bool]")(
         PARAM_VARIANCE_THRESHOLD.c_str(), po::value<float>(),
         "Threshold for adaptive accumulation [float]");
 
-    // Add default renderers
-    _renderers.push_back(RendererType::basic);
+    initializeDefaultRenderers();
+    initializeDefaultCameras();
+}
+
+void RenderingParameters::initializeDefaultRenderers()
+{
+    _rendererNames = {RENDERER_INTERNAL_NAMES.begin(),
+                      RENDERER_INTERNAL_NAMES.end()};
+    _renderers.clear();
+    _renderers.push_back(RendererType::default_);
     _renderers.push_back(RendererType::simulation);
     _renderers.push_back(RendererType::particle);
     _renderers.push_back(RendererType::proximity);
@@ -145,6 +157,11 @@ RenderingParameters::RenderingParameters()
     _renderers.push_back(RendererType::scientificvisualization);
 }
 
+void RenderingParameters::initializeDefaultCameras()
+{
+    _cameraTypeNames = {CAMERA_TYPE_NAMES.begin(), CAMERA_TYPE_NAMES.end()};
+}
+
 bool RenderingParameters::_parse(const po::variables_map& vm)
 {
     if (vm.count(PARAM_ENGINE))
@@ -159,11 +176,19 @@ bool RenderingParameters::_parse(const po::variables_map& vm)
         _module = vm[PARAM_MODULE].as<std::string>();
     if (vm.count(PARAM_RENDERER))
     {
-        _renderer = RendererType::basic;
-        const std::string& renderer = vm[PARAM_RENDERER].as<std::string>();
-        for (size_t i = 0; i < sizeof(RENDERERS) / sizeof(RENDERERS[0]); ++i)
-            if (renderer == RENDERERS[i])
-                _renderer = static_cast<RendererType>(i);
+        _renderer = RendererType::default_;
+        const std::string& rendererName = vm[PARAM_RENDERER].as<std::string>();
+        auto it = std::find(_rendererNames.begin(), _rendererNames.end(),
+                            rendererName);
+        if (it == _rendererNames.end())
+        {
+            BRAYNS_INFO << "'" << rendererName << "' replaces default renderer"
+                        << std::endl;
+            _rendererNames[0] = rendererName;
+        }
+        else
+            _renderer = static_cast<RendererType>(
+                std::distance(_rendererNames.begin(), it));
     }
     if (vm.count(PARAM_SPP))
         _spp = vm[PARAM_SPP].as<size_t>();
@@ -212,14 +237,21 @@ bool RenderingParameters::_parse(const po::variables_map& vm)
     }
     if (vm.count(PARAM_EPSILON))
         _epsilon = vm[PARAM_EPSILON].as<float>();
-    if (vm.count(PARAM_CAMERA_TYPE))
+    if (vm.count(PARAM_CAMERA))
     {
-        _cameraType = CameraType::perspective;
-        const std::string& cameraType = vm[PARAM_CAMERA_TYPE].as<std::string>();
-        for (size_t i = 0; i < sizeof(CAMERA_TYPES) / sizeof(CAMERA_TYPES[0]);
-             ++i)
-            if (cameraType == CAMERA_TYPES[i])
-                _cameraType = static_cast<CameraType>(i);
+        _cameraType = CameraType::default_;
+        const std::string& cameraTypeName = vm[PARAM_CAMERA].as<std::string>();
+        auto it = std::find(_cameraTypeNames.begin(), _cameraTypeNames.end(),
+                            cameraTypeName);
+        if (it == _cameraTypeNames.end())
+        {
+            BRAYNS_INFO << "'" << cameraTypeName << "' replaces default camera"
+                        << std::endl;
+            _cameraTypeNames[0] = cameraTypeName;
+        }
+        else
+            _cameraType = static_cast<CameraType>(
+                std::distance(_cameraTypeNames.begin(), it));
     }
     if (vm.count(PARAM_HEAD_LIGHT))
         _headLight = vm[PARAM_HEAD_LIGHT].as<bool>();
@@ -280,19 +312,13 @@ const std::string& RenderingParameters::getEngineAsString(
 const std::string& RenderingParameters::getRendererAsString(
     const RendererType value) const
 {
-    return RENDERERS[static_cast<size_t>(value)];
-}
-
-const std::string& RenderingParameters::getRendererNameAsString(
-    const RendererType value) const
-{
-    return RENDERER_NAMES[static_cast<size_t>(value)];
+    return _rendererNames[static_cast<size_t>(value)];
 }
 
 const std::string& RenderingParameters::getCameraTypeAsString(
     const CameraType value) const
 {
-    return CAMERA_TYPES[static_cast<size_t>(value)];
+    return _cameraTypeNames[static_cast<size_t>(value)];
 }
 
 const std::string& RenderingParameters::getShadingAsString(

brayns/parameters/RenderingParameters.h

@@ -48,9 +48,9 @@ class RenderingParameters : public AbstractParameters
     /** OSPRay module */
     const std::string& getModule() const { return _module; }
     /** OSPRay renderer */
+    void initializeDefaultRenderers();
     RendererType getRenderer() const { return _renderer; }
     const std::string& getRendererAsString(const RendererType value) const;
-    const std::string& getRendererNameAsString(const RendererType value) const;
     void setRenderer(const RendererType renderer)
     {
         _updateValue(_renderer, renderer);
@@ -166,6 +166,7 @@ class RenderingParameters : public AbstractParameters
     /**
        Camera type
     */
+    void initializeDefaultCameras();
     CameraType getCameraType() const { return _cameraType; }
     const std::string& getCameraTypeAsString(const CameraType value) const;
 
@@ -204,6 +205,9 @@ class RenderingParameters : public AbstractParameters
     std::string _module;
     RendererType _renderer;
     RendererTypes _renderers;
+    strings _rendererNames;
+    CameraType _cameraType;
+    strings _cameraTypeNames;
     float _ambientOcclusionStrength;
     float _ambientOcclusionDistance;
     ShadingType _shading;
@@ -218,7 +222,6 @@ class RenderingParameters : public AbstractParameters
     Vector3f _detectionNearColor;
     Vector3f _detectionFarColor;
     float _epsilon;
-    CameraType _cameraType;
     bool _headLight;
     bool _dynamicLoadBalancer{false};
     float _varianceThreshold{-1.f};

doc/UserGuide.md

@@ -329,7 +329,7 @@ braynsViewer --epsilon 0.001
 
 ## Camera types
 
-The --camera-type command line argument defines the type of camera to be used
+The --camera command line argument defines the type of camera to be used
 by the renderer. Four cameras are currently supported.
 - perspective: Perspective camera
 - stereo: Side-by-side camera
@@ -338,7 +338,7 @@ by the renderer. Four cameras are currently supported.
 - clipped: Perspective camera allowing clipping planes
 
 ```
-braynsViewer --camera-type orthographic
+braynsViewer --camera orthographic
 ```
 
 ## Head light

plugins/engines/ospray/OSPRayCamera.cpp

@@ -21,33 +21,18 @@
 #include "OSPRayCamera.h"
 
 #include <brayns/common/log.h>
+#include <brayns/parameters/ParametersManager.h>
+
 #include <ospray/SDK/common/OSPCommon.h>
 
 namespace brayns
 {
-OSPRayCamera::OSPRayCamera(const CameraType cameraType)
-    : Camera(cameraType)
+OSPRayCamera::OSPRayCamera(const CameraType& type, const std::string& name)
+    : Camera(type)
+    , _camera{ospNewCamera(name.c_str())}
 {
-    std::string cameraAsString;
-    switch (getType())
-    {
-    case CameraType::stereo:
-        cameraAsString = "stereo";
-        break;
-    case CameraType::orthographic:
-        cameraAsString = "orthographic";
-        break;
-    case CameraType::panoramic:
-        cameraAsString = "panoramic";
-        break;
-    case CameraType::clipped:
-        cameraAsString = "clippedperspective";
-        break;
-    default:
-        cameraAsString = "perspective";
-        break;
-    }
-    _camera = ospNewCamera(cameraAsString.c_str());
+    if (!_camera)
+        throw std::runtime_error(name + " is not a registered camera");
 }
 
 OSPRayCamera::~OSPRayCamera()

plugins/engines/ospray/OSPRayCamera.h

@@ -34,7 +34,7 @@ namespace brayns
 class OSPRayCamera : public brayns::Camera
 {
 public:
-    OSPRayCamera(const CameraType cameraType);
+    OSPRayCamera(const CameraType& type, const std::string& name);
     ~OSPRayCamera();
 
     /**