Allow use of renderers and cameras defined in external modules

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,28 +45,30 @@ 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",
+const std::string RENDERERS[7] = {"default",
                                   "proximity",
                                   "simulation",
                                   "particle",
                                   "geometrynormals",
                                   "shadingnormals",
                                   "scientificvisualization"};
-const std::string RENDERER_NAMES[7] = {"basic",
-                                       "proximityrenderer",
-                                       "simulationrenderer",
-                                       "particlerenderer",
-                                       "raycast_Ng",
-                                       "raycast_Ns",
-                                       "scivis"};
 
-const std::string CAMERA_TYPES[5] = {"perspective", "stereo", "orthographic",
-                                     "panoramic", "clipped"};
+const std::string RENDERER_INTERNAL_NAMES[7] = {"basic",
+                                                "proximityrenderer",
+                                                "simulationrenderer",
+                                                "particlerenderer",
+                                                "raycast_Ng",
+                                                "raycast_Ns",
+                                                "scivis"};
+
+const std::string CAMERA_TYPE_NAMES[5] = {"perspective", "stereo",
+                                          "orthographic", "panoramic",
+                                          "clipped"};
 
 const std::string SHADING_TYPES[3] = {"none", "diffuse", "electron"};
 }
@@ -76,7 +78,7 @@ namespace brayns
 RenderingParameters::RenderingParameters()
     : AbstractParameters("Rendering")
     , _engine(EngineType::ospray)
-    , _renderer(RendererType::basic)
+    , _renderer(RendererType::default_)
     , _ambientOcclusionStrength(0.f)
     , _ambientOcclusionDistance(1.20f)
     , _shading(ShadingType::diffuse)
@@ -90,15 +92,15 @@ RenderingParameters::RenderingParameters()
     , _detectionNearColor(1.f, 0.f, 0.f)
     , _detectionFarColor(0.f, 1.f, 0.f)
     , _epsilon(0.f)
-    , _cameraType(CameraType::perspective)
+    , _cameraType(CameraType::default_)
     , _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 +130,27 @@ 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.clear();
+    for (size_t i = 0; i < sizeof(RENDERER_INTERNAL_NAMES) /
+                               sizeof(RENDERER_INTERNAL_NAMES[0]);
+         ++i)
+        _rendererNames.push_back(RENDERER_INTERNAL_NAMES[i]);
+
+    _renderers.clear();
+    _renderers.push_back(RendererType::default_);
     _renderers.push_back(RendererType::simulation);
     _renderers.push_back(RendererType::particle);
     _renderers.push_back(RendererType::proximity);
@@ -145,6 +159,14 @@ RenderingParameters::RenderingParameters()
     _renderers.push_back(RendererType::scientificvisualization);
 }
 
+void RenderingParameters::initializeDefaultCameras()
+{
+    _cameraTypeNames.clear();
+    for (size_t i = 0;
+         i < sizeof(CAMERA_TYPE_NAMES) / sizeof(CAMERA_TYPE_NAMES[0]); ++i)
+        _cameraTypeNames.push_back(CAMERA_TYPE_NAMES[i]);
+}
+
 bool RenderingParameters::_parse(const po::variables_map& vm)
 {
     if (vm.count(PARAM_ENGINE))
@@ -159,11 +181,21 @@ bool RenderingParameters::_parse(const po::variables_map& vm)
         _module = vm[PARAM_MODULE].as<std::string>();
     if (vm.count(PARAM_RENDERER))
     {
-        _renderer = RendererType::basic;
+        _renderer = RendererType::default_;
+        bool found = false;
         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])
+        for (size_t i = 0; !found && i < _rendererNames.size(); ++i)
+            if (renderer == _rendererNames[i])
+            {
                 _renderer = static_cast<RendererType>(i);
+                found = true;
+            }
+        if (!found)
+        {
+            BRAYNS_INFO << "'" << renderer << "' replaces default renderer"
+                        << std::endl;
+            _rendererNames[0] = renderer;
+        }
     }
     if (vm.count(PARAM_SPP))
         _spp = vm[PARAM_SPP].as<size_t>();
@@ -212,14 +244,23 @@ 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 = CameraType::default_;
+        const std::string& cameraTypeName = vm[PARAM_CAMERA].as<std::string>();
+        bool found = false;
+        for (size_t i = 0; !found && i < _cameraTypeNames.size(); ++i)
+            if (cameraTypeName == _cameraTypeNames[i])
+            {
                 _cameraType = static_cast<CameraType>(i);
+                found = true;
+            }
+        if (!found)
+        {
+            BRAYNS_INFO << "'" << cameraTypeName << "' replaces default camera"
+                        << std::endl;
+            _cameraTypeNames[0] = cameraTypeName;
+        }
     }
     if (vm.count(PARAM_HEAD_LIGHT))
         _headLight = vm[PARAM_HEAD_LIGHT].as<bool>();
@@ -286,13 +327,13 @@ const std::string& RenderingParameters::getRendererAsString(
 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,6 +48,7 @@ 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;
@@ -166,6 +167,7 @@ class RenderingParameters : public AbstractParameters
     /**
        Camera type
     */
+    void initializeDefaultCameras();
     CameraType getCameraType() const { return _cameraType; }
     const std::string& getCameraTypeAsString(const CameraType value) const;
 
@@ -204,6 +206,7 @@ class RenderingParameters : public AbstractParameters
     std::string _module;
     RendererType _renderer;
     RendererTypes _renderers;
+    strings _rendererNames;
     float _ambientOcclusionStrength;
     float _ambientOcclusionDistance;
     ShadingType _shading;
@@ -219,6 +222,7 @@ class RenderingParameters : public AbstractParameters
     Vector3f _detectionFarColor;
     float _epsilon;
     CameraType _cameraType;
+    strings _cameraTypeNames;
     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,29 @@
 #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(ParametersManager& parametersManager)
+    : Camera(parametersManager.getRenderingParameters().getCameraType())
 {
-    std::string cameraAsString;
-    switch (getType())
+    auto& rp = parametersManager.getRenderingParameters();
+    auto cameraTypeAsString = rp.getCameraTypeAsString(getType());
+    _camera = ospNewCamera(cameraTypeAsString.c_str());
+    if (!_camera)
     {
-    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;
+        BRAYNS_WARN
+            << "'" << cameraTypeAsString << "'"
+            << " is not a registered camera, using default camera instead"
+            << std::endl;
+        rp.initializeDefaultCameras();
+        cameraTypeAsString = rp.getCameraTypeAsString(CameraType::default_);
+        _camera = ospNewCamera(cameraTypeAsString.c_str());
     }
-    _camera = ospNewCamera(cameraAsString.c_str());
+    assert(_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(ParametersManager& parametersManager);
     ~OSPRayCamera();
 
     /**

plugins/engines/ospray/OSPRayEngine.cpp

@@ -108,7 +108,7 @@ OSPRayEngine::OSPRayEngine(int argc, const char** argv,
 
     BRAYNS_INFO << "Initializing scene" << std::endl;
     _scene.reset(new OSPRayScene(renderersForScene, _parametersManager));
-    _camera.reset(new OSPRayCamera(rp.getCameraType()));
+    _camera.reset(new OSPRayCamera(_parametersManager));
     _camera->setEnvironmentMap(
         !parametersManager.getSceneParameters().getEnvironmentMap().empty());
 

plugins/engines/ospray/OSPRayRenderer.cpp

@@ -32,8 +32,21 @@ OSPRayRenderer::OSPRayRenderer(const std::string& name,
     : Renderer(parametersManager)
     , _name(name)
     , _camera(0)
+    , _renderer(0)
 {
     _renderer = ospNewRenderer(name.c_str());
+    if (!_renderer)
+    {
+        BRAYNS_WARN
+            << "'" << name << "'"
+            << " is not a registered renderer, using default renderer instead"
+            << std::endl;
+        auto& rp = parametersManager.getRenderingParameters();
+        rp.initializeDefaultRenderers();
+        const auto& defaultRenderer =
+            rp.getRendererNameAsString(RendererType::default_);
+        _renderer = ospNewRenderer(defaultRenderer.c_str());
+    }
     assert(_renderer);
 }
 

plugins/extensions/plugins/jsonSerialization.h

@@ -94,7 +94,7 @@ STATICJSON_DECLARE_ENUM(brayns::MemoryMode,
                         {"replicated", brayns::MemoryMode::replicated});
 
 STATICJSON_DECLARE_ENUM(
-    brayns::RendererType, {"basic", brayns::RendererType::basic},
+    brayns::RendererType, {"default", brayns::RendererType::default_},
     {"proximity", brayns::RendererType::proximity},
     {"simulation", brayns::RendererType::simulation},
     {"particle", brayns::RendererType::particle},