Merge pull request #310 from favreau/master

Added Anaglyph camera to OptiX 6 engine (and a few refinements)

bioexplorer/backend/module/cuda/renderer/Density.cu

@@ -40,8 +40,8 @@ static __device__ inline void shade()
 
     while (color.w < 0.9f && t < farPlane)
     {
-        unsigned int hits = 0;
-        unsigned int seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
+        uint hits = 0;
+        uint seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
 
         const float3 hit_point = ray.origin + t_hit * ray.direction;
         const float3 normal = optix::normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, shading_normal));

bioexplorer/backend/module/cuda/renderer/Fields.cu

@@ -64,22 +64,22 @@ __device__ float treeWalker(const uint startIndices, const uint startData, const
     if (depth >= MAX_RECURSION_DEPTH)
         return 0.f;
 
-    const uint begin = userData[startIndices + index * 2];
-    const uint end = userData[startIndices + index * 2 + 1];
+    const uint begin = userDataBuffer[startIndices + index * 2];
+    const uint end = userDataBuffer[startIndices + index * 2 + 1];
     const uint idxData = startData + index * 4;
 
-    if (idxData >= userData.size())
+    if (idxData >= userDataBuffer.size())
         return 0.f;
 
     if (begin == 0 && end == 0)
         // Leaf
-        return userData[idxData + 3] / (distance * distance);
+        return userDataBuffer[idxData + 3] / (distance * distance);
 
     float voxelValue = 0.f;
     for (uint childIndex = begin; childIndex <= end; ++childIndex)
     {
         const uint idx = startData + childIndex * 4;
-        const float3 childPosition = make_float3(userData[idx], userData[idx + 1], userData[idx + 2]);
+        const float3 childPosition = make_float3(userDataBuffer[idx], userDataBuffer[idx + 1], userDataBuffer[idx + 2]);
         const float3 delta = point - childPosition;
 
         const float d = sqrt(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z);
@@ -89,7 +89,7 @@ __device__ float treeWalker(const uint startIndices, const uint startData, const
             // Child is further than the cutoff distance, no need to evaluate
             // events in the child node, we take the precomputed value of node
             // instead
-            voxelValue += userData[idx + 3] / (d * d);
+            voxelValue += userDataBuffer[idx + 3] / (d * d);
         }
         else
             // Dive into the child node and compute its contents
@@ -109,12 +109,12 @@ static __device__ inline void shade()
 {
     float4 finalColor = make_float4(0.f);
 
-    const float3 offset = make_float3(userData[0], userData[1], userData[2]);
-    const float3 spacing = make_float3(userData[3], userData[4], userData[5]);
-    const float3 dimensions = make_float3(userData[6], userData[7], userData[8]);
-    const float distance = userData[9] * 5.f;
+    const float3 offset = make_float3(userDataBuffer[0], userDataBuffer[1], userDataBuffer[2]);
+    const float3 spacing = make_float3(userDataBuffer[3], userDataBuffer[4], userDataBuffer[5]);
+    const float3 dimensions = make_float3(userDataBuffer[6], userDataBuffer[7], userDataBuffer[8]);
+    const float distance = userDataBuffer[9] * 5.f;
     const uint startIndices = 11;
-    const uint startData = startIndices + userData[10];
+    const uint startData = startIndices + userDataBuffer[10];
     const float diag = fmax(fmax(dimensions.x, dimensions.y), dimensions.z);
     const float t_step = fmax(minRayStep, diag / (float)nbRaySteps);
 

bioexplorer/backend/module/cuda/renderer/Voxel.cu

@@ -31,21 +31,19 @@ static __device__ inline void shade()
 {
     const float3 hit_point = ray.origin + t_hit * ray.direction;
     float3 color = make_float3(0.f);
-    if (prd.depth < maxRayDepth && cast_user_data && userData.size() > 0)
+    if (prd.depth < maxRayDepth)
     {
-        const float4 userDataColor =
-            calcTransferFunctionColor(transfer_function_map, value_range, userData[userDataIndex]);
+        PerRayData_radiance new_prd;
+        const float4 userDataColor = getUserData();
         if (userDataColor.w >= simulationThreshold)
         {
-            color = color * (1.f - userDataColor.w) + make_float3(userDataColor) * userDataColor.w;
-            prd.importance = userDataColor.w * alphaCorrection;
+            color = color * (1.f - userDataColor.w) + make_float3(userDataColor) * userDataColor.w * alphaCorrection;
+            new_prd.importance = userDataColor.w * alphaCorrection;
         }
         else
-            prd.importance = 0.f;
+            new_prd.importance = 0.f;
 
-        PerRayData_radiance new_prd;
         new_prd.depth = prd.depth + 1;
-
         const optix::Ray new_ray = optix::make_Ray(hit_point, ray.direction, radianceRayType, sceneEpsilon, ray.tmax);
         rtTrace(top_object, new_ray, new_prd);
     }

bioexplorer/backend/module/cuda/renderer/artistic/Golgi.cu

@@ -23,19 +23,11 @@
 
 #include <optix_world.h>
 
-#include <platform/engines/optix6/OptiXCommonStructs.h>
+#include <platform/engines/optix6/cuda/Context.cuh>
 
-// Scene
-rtDeclareVariable(optix::Ray, ray, rtCurrentRay, );
-rtDeclareVariable(PerRayData_radiance, prd, rtPayload, );
-rtDeclareVariable(float3, eye, , );
-rtDeclareVariable(float, t_hit, rtIntersectionDistance, );
 rtDeclareVariable(float, exponent, , );
 rtDeclareVariable(uint, inverse, , );
 
-// Material attributes
-rtDeclareVariable(float3, shading_normal, attribute shading_normal, );
-
 static __device__ inline void shade()
 {
     const float3 hit_point = ray.origin + t_hit * ray.direction;

bioexplorer/backend/module/ispc/renderer/DensityRenderer.cpp

@@ -24,6 +24,7 @@
 #include "DensityRenderer.h"
 
 #include <platform/core/common/Properties.h>
+#include <science/common/Properties.h>
 
 // ospray
 #include <ospray/SDK/common/Data.h>
@@ -49,10 +50,14 @@ void DensityRenderer::commit()
     _timestamp = getParam1f(RENDERER_PROPERTY_TIMESTAMP, DEFAULT_RENDERER_TIMESTAMP);
 
     // Sampling
-    _farPlane = getParam1f("farPlane", 1e6f);
-    _rayStep = getParam1f("rayStep", 1.f);
-    _samplesPerFrame = getParam1i("samplesPerFrame", 8);
-    _searchLength = getParam1f("searchLength", 100.f);
+    _farPlane = getParam1f(BIOEXPLORER_RENDERER_PROPERTY_DENSITY_FAR_PLANE.name.c_str(),
+                           BIOEXPLORER_DEFAULT_RENDERER_DENSITY_FAR_PLANE);
+    _rayStep = getParam1f(BIOEXPLORER_RENDERER_PROPERTY_DENSITY_RAY_STEP.name.c_str(),
+                          BIOEXPLORER_DEFAULT_RENDERER_DENSITY_RAY_STEP);
+    _samplesPerFrame = getParam1i(RENDERER_PROPERTY_GLOBAL_ILLUMINATION_SAMPLES.name.c_str(),
+                                  DEFAULT_RENDERER_GLOBAL_ILLUMINATION_RAY_LENGTH);
+    _searchLength = getParam1f(RENDERER_PROPERTY_GLOBAL_ILLUMINATION_STRENGTH.name.c_str(),
+                               DEFAULT_RENDERER_GLOBAL_ILLUMINATION_RAY_LENGTH);
     _alphaCorrection = getParam1f(RENDERER_PROPERTY_ALPHA_CORRECTION.name.c_str(), DEFAULT_RENDERER_ALPHA_CORRECTION);
 
     // Transfer function

bioexplorer/backend/module/ispc/renderer/FieldsRenderer.cpp

@@ -23,6 +23,8 @@
 
 #include "FieldsRenderer.h"
 
+#include <science/common/Properties.h>
+
 #include <platform/core/common/Properties.h>
 #include <platform/engines/ospray/OSPRayProperties.h>
 
@@ -55,17 +57,20 @@ void FieldsRenderer::commit()
 
     _bgMaterial = (AdvancedMaterial*)getParamObject(RENDERER_PROPERTY_BACKGROUND_MATERIAL, nullptr);
 
-    _useHardwareRandomizer =
-        getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(), DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER);
+    _useHardwareRandomizer = getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(),
+                                      static_cast<int>(DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER));
 
     _exposure = getParam1f(COMMON_PROPERTY_EXPOSURE.name.c_str(), DEFAULT_COMMON_EXPOSURE);
     _randomNumber = getParam1i(OSPRAY_RENDERER_PROPERTY_RANDOM_NUMBER, 0);
     _timestamp = getParam1f(RENDERER_PROPERTY_TIMESTAMP, DEFAULT_RENDERER_TIMESTAMP);
 
     // Sampling
-    _minRayStep = getParam1f("minRayStep", 0.1f);
-    _nbRaySteps = getParam1i("nbRaySteps", 8);
-    _nbRayRefinementSteps = getParam1i("nbRayRefinementSteps", 8);
+    _minRayStep = getParam1f(BIOEXPLORER_RENDERER_PROPERTY_FIELDS_MIN_RAY_STEP.name.c_str(),
+                             BIOEXPLORER_DEFAULT_RENDERER_FIELDS_MIN_RAY_STEP);
+    _nbRaySteps = getParam1i(BIOEXPLORER_RENDERER_PROPERTY_FIELDS_NB_RAY_STEPS.name.c_str(),
+                             BIOEXPLORER_DEFAULT_RENDERER_FIELDS_NB_RAY_STEPS);
+    _nbRayRefinementSteps = getParam1i(BIOEXPLORER_RENDERER_PROPERTY_FIELDS_NB_RAY_REFINEMENT_STEPS.name.c_str(),
+                                       BIOEXPLORER_DEFAULT_RENDERER_FIELDS_NB_RAY_REFINEMENT_STEPS);
     _alphaCorrection = getParam1f(RENDERER_PROPERTY_ALPHA_CORRECTION.name.c_str(), DEFAULT_RENDERER_ALPHA_CORRECTION);
 
     // Extra

bioexplorer/backend/module/ispc/renderer/PathTracingRenderer.cpp

@@ -55,15 +55,15 @@ void PathTracingRenderer::commit()
 
     _bgMaterial = (AdvancedMaterial*)getParamObject(RENDERER_PROPERTY_BACKGROUND_MATERIAL, nullptr);
     _exposure = getParam1f(COMMON_PROPERTY_EXPOSURE.name.c_str(), DEFAULT_COMMON_EXPOSURE);
-    _useHardwareRandomizer =
-        getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(), DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER);
+    _useHardwareRandomizer = getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(),
+                                      static_cast<int>(DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER));
     _showBackground = getParam(RENDERER_PROPERTY_SHOW_BACKGROUND.name.c_str(), DEFAULT_RENDERER_SHOW_BACKGROUND);
     _aoWeight = getParam1f(OSPRAY_RENDERER_AMBIENT_OCCLUSION_WEIGHT.name.c_str(), 1.f);
     _aoDistance = getParam1f(OSPRAY_RENDERER_AMBIENT_OCCLUSION_DISTANCE.name.c_str(), 100.f);
     _randomNumber = rand() % 1000;
 
     ispc::PathTracingRenderer_set(getIE(), (_bgMaterial ? _bgMaterial->getIE() : nullptr), spp, _lightPtr,
-                                  _lightArray.size(), (_simulationData ? (float*)_simulationData->data : nullptr),
+                                  _lightArray.size(), (_userData ? (float*)_userData->data : nullptr),
                                   _simulationDataSize, _timestamp, _randomNumber, _exposure, _aoWeight, _aoDistance,
                                   _useHardwareRandomizer, _showBackground);
 }

bioexplorer/backend/module/ispc/renderer/VoxelRenderer.cpp

@@ -43,7 +43,7 @@ void VoxelRenderer::commit()
     _simulationThreshold = getParam1f("simulationThreshold", 0.f);
 
     ispc::VoxelRenderer_set(getIE(), (_bgMaterial ? _bgMaterial->getIE() : nullptr), spp,
-                            (_simulationData ? (float*)_simulationData->data : nullptr), _simulationDataSize,
+                            (_userData ? (float*)_userData->data : nullptr), _simulationDataSize,
                             _alphaCorrection, _simulationThreshold, _exposure);
 }
 

bioexplorer/backend/module/ispc/renderer/artistic/GolgiStyleRenderer.cpp

@@ -23,6 +23,8 @@
 
 #include "GolgiStyleRenderer.h"
 
+#include <science/common/Properties.h>
+
 // ispc exports
 #include "GolgiStyleRenderer_ispc.h"
 
@@ -35,8 +37,10 @@ namespace rendering
 void GolgiStyleRenderer::commit()
 {
     Renderer::commit();
-    _exponent = getParam1f("exponent", 1.f);
-    _inverse = getParam("inverse", 0);
+    _exponent = getParam1f(BIOEXPLORER_RENDERER_PROPERTY_GOLGI_EXPONENT.name.c_str(),
+                           BIOEXPLORER_DEFAULT_RENDERER_GOLGI_EXPONENT);
+    _inverse =
+        getParam(BIOEXPLORER_RENDERER_PROPERTY_GOLGI_INVERSE.name.c_str(), BIOEXPLORER_DEFAULT_RENDERER_GOLGI_INVERSE);
 
     ispc::GolgiStyleRenderer_set(getIE(), (_bgMaterial ? _bgMaterial->getIE() : nullptr), spp, _exponent, _inverse);
 }

bioexplorer/backend/plugins/MediaMaker/module/cuda/renderer/Albedo.cu

@@ -23,27 +23,35 @@
 
 #include <platform/engines/optix6/cuda/Helpers.cuh>
 #include <platform/engines/optix6/cuda/Random.cuh>
+#include <platform/engines/optix6/cuda/renderer/TransferFunction.cuh>
 
 using namespace optix;
 
-static __device__ inline void shade()
+static __device__ inline void shade(bool textured)
 {
     const float3 world_shading_normal = normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, shading_normal));
     const float3 world_geometric_normal = normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, geometric_normal));
     float3 normal = faceforward(world_shading_normal, -ray.direction, world_geometric_normal);
 
-    // Glossiness
+    float3 color;
+    if (textured && albedoMetallic_map)
+        color = make_float3(optix::rtTex2D<float4>(albedoMetallic_map, texcoord.x, texcoord.y));
+    else
+        color = Kd;
+
+    const float4 userDataColor = getUserData();
+    color = color * (1.f - userDataColor.w) + make_float3(userDataColor) * userDataColor.w;
+
+    // Glossiness7
     if (glossiness < 1.f)
     {
         optix::size_t2 screen = output_buffer.size();
-        unsigned int seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
+        uint seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
         normal = optix::normalize(normal + (1.f - glossiness) *
                                                make_float3(rnd(seed) - 0.5f, rnd(seed) - 0.5f, rnd(seed) - 0.5f));
     }
 
-    float3 color = Kd;
     const float3 hit_point = ray.origin + t_hit * ray.direction;
-
     const float opacity = fmaxf(Ko);
     if (opacity > 0.f && prd.depth < maxRayDepth - 1)
     {
@@ -87,10 +95,10 @@ RT_PROGRAM void any_hit_shadow()
 
 RT_PROGRAM void closest_hit_radiance()
 {
-    shade();
+    shade(false);
 }
 
 RT_PROGRAM void closest_hit_radiance_textured()
 {
-    shade();
+    shade(true);
 }

bioexplorer/backend/plugins/MediaMaker/module/cuda/renderer/AmbientOcclusion.cu

@@ -27,7 +27,7 @@
 static __device__ inline void shade()
 {
     optix::size_t2 screen = output_buffer.size();
-    unsigned int seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
+    uint seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
 
     const float3 hit_point = ray.origin + t_hit * ray.direction;
     const float3 world_shading_normal = optix::normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, shading_normal));

bioexplorer/backend/plugins/MediaMaker/module/cuda/renderer/GeometryNormal.cu

@@ -25,7 +25,10 @@
 
 static __device__ inline void shade()
 {
-    prd.result = make_float4(optix::normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, geometric_normal)), 1.f);
+    const float3 world_geometric_normal = optix::normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, geometric_normal));
+    const float3 normal =
+        optix::dot(world_geometric_normal, ray.direction) > 0.f ? -world_geometric_normal : world_geometric_normal;
+    prd.result = make_float4(optix::normalize(0.5 + 0.5 * normal), 1.f);
 }
 
 RT_PROGRAM void any_hit_shadow()

bioexplorer/backend/plugins/MediaMaker/module/cuda/renderer/ShadingNormal.cu

@@ -25,7 +25,10 @@
 
 static __device__ inline void shade()
 {
-    prd.result = make_float4(optix::normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, shading_normal)), 1.f);
+    const float3 world_shading_normal = optix::normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, shading_normal));
+    const float3 normal =
+        optix::dot(world_shading_normal, ray.direction) > 0.f ? -world_shading_normal : world_shading_normal;
+    prd.result = make_float4(optix::normalize(0.5 + 0.5 * normal), 1.f);
 }
 
 RT_PROGRAM void any_hit_shadow()

bioexplorer/backend/plugins/MediaMaker/module/cuda/renderer/Shadow.cu

@@ -29,12 +29,12 @@ rtDeclareVariable(int, shadowSamples, , );
 static __device__ inline void shade()
 {
     optix::size_t2 screen = output_buffer.size();
-    unsigned int seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
+    uint seed = tea<16>(screen.x * launch_index.y + launch_index.x, frame);
 
     const float3 hit_point = ray.origin + t_hit * ray.direction;
     const float3 normal = optix::normalize(rtTransformNormal(RT_OBJECT_TO_WORLD, shading_normal));
 
-    unsigned int num_lights = lights.size();
+    uint num_lights = lights.size();
     float attenuation = 0.f;
     for (int s = 0; s < shadowSamples; ++s)
     {

bioexplorer/backend/plugins/MediaMaker/module/ispc/renderer/AlbedoRenderer.cpp

@@ -45,7 +45,7 @@ void AlbedoRenderer::commit()
     SimulationRenderer::commit();
 
     ispc::AlbedoRenderer_set(getIE(), spp, _maxBounces, _useHardwareRandomizer,
-                             _simulationData ? (float*)_simulationData->data : nullptr, _simulationDataSize);
+                             _userData ? (float*)_userData->data : nullptr, _simulationDataSize);
 }
 
 AlbedoRenderer::AlbedoRenderer()

bioexplorer/backend/plugins/MediaMaker/module/ispc/renderer/AmbientOcclusionRenderer.cpp

@@ -49,8 +49,8 @@ void AmbientOcclusionRenderer::commit()
     _aoRayLength = getParam1f(RENDERER_PROPERTY_GLOBAL_ILLUMINATION_RAY_LENGTH.name.c_str(),
                               DEFAULT_RENDERER_GLOBAL_ILLUMINATION_RAY_LENGTH);
     _maxBounces = getParam1i(RENDERER_PROPERTY_MAX_RAY_DEPTH.name.c_str(), DEFAULT_RENDERER_MAX_RAY_DEPTH);
-    _useHardwareRandomizer =
-        getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(), DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER);
+    _useHardwareRandomizer = getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(),
+                                      static_cast<int>(DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER));
 
     ispc::AmbientOcclusionRenderer_set(getIE(), spp, _samplesPerFrame, _aoRayLength, _maxBounces,
                                        _useHardwareRandomizer);

bioexplorer/backend/plugins/MediaMaker/plugin/MediaMakerPlugin.cpp

@@ -85,7 +85,10 @@ void _addAlbedoRenderer(core::Engine &engine)
     PLUGIN_REGISTER_RENDERER(RENDERER_ALBEDO);
     core::PropertyMap properties;
     properties.setProperty(RENDERER_PROPERTY_MAX_RAY_DEPTH);
-    properties.setProperty(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER);
+    auto &params = engine.getParametersManager().getApplicationParameters();
+    const auto &engineName = params.getEngine();
+    if (engineName == ENGINE_OSPRAY)
+        properties.setProperty(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER);
     engine.addRendererType(RENDERER_ALBEDO, properties);
 }
 
@@ -98,6 +101,10 @@ void _addAmbientOcclusionRenderer(core::Engine &engine)
     properties.setProperty(samples);
     properties.setProperty(RENDERER_PROPERTY_GLOBAL_ILLUMINATION_RAY_LENGTH);
     properties.setProperty(RENDERER_PROPERTY_MAX_RAY_DEPTH);
+    auto &params = engine.getParametersManager().getApplicationParameters();
+    const auto &engineName = params.getEngine();
+    if (engineName == ENGINE_OSPRAY)
+        properties.setProperty(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER);
     properties.setProperty(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER);
     engine.addRendererType(RENDERER_AMBIENT_OCCLUSION, properties);
 }

bioexplorer/backend/plugins/Sonata/module/ispc/camera/SphereClippingPerspectiveCamera.cpp

@@ -54,14 +54,14 @@ void SphereClippingPerspectiveCamera::commit()
     aspect = getParamf(CAMERA_PROPERTY_ASPECT_RATIO.name.c_str(), DEFAULT_CAMERA_ASPECT_RATIO);
     apertureRadius = getParamf(CAMERA_PROPERTY_APERTURE_RADIUS.name.c_str(), DEFAULT_CAMERA_APERTURE_RADIUS);
     focalDistance = getParamf(CAMERA_PROPERTY_FOCAL_DISTANCE.name.c_str(), DEFAULT_CAMERA_FOCAL_DISTANCE);
-    stereo = getParam(CAMERA_PROPERTY_STEREO.name.c_str(), DEFAULT_CAMERA_STEREO);
+    stereo = getParam(CAMERA_PROPERTY_STEREO.name.c_str(), static_cast<int>(DEFAULT_CAMERA_STEREO));
     interpupillaryDistance =
         getParamf(CAMERA_PROPERTY_INTERPUPILLARY_DISTANCE.name.c_str(), DEFAULT_CAMERA_INTERPUPILLARY_DISTANCE);
     enableClippingPlanes =
         getParam(CAMERA_PROPERTY_ENABLE_CLIPPING_PLANES.name.c_str(), DEFAULT_CAMERA_ENABLE_CLIPPING_PLANES);
     clipPlanes = enableClippingPlanes ? getParamData(CAMERA_PROPERTY_CLIPPING_PLANES, nullptr) : nullptr;
-    useHardwareRandomizer =
-        getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(), DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER);
+    useHardwareRandomizer = getParam(COMMON_PROPERTY_USE_HARDWARE_RANDOMIZER.name.c_str(),
+                                     static_cast<int>(DEFAULT_COMMON_USE_HARDWARE_RANDOMIZER));
 
     // ------------------------------------------------------------------
     // now, update the local precomputed values

bioexplorer/backend/plugins/Sonata/module/ispc/render/CellGrowthRenderer.cpp

@@ -50,7 +50,7 @@ void CellGrowthRenderer::commit()
                                          SONATA_DEFAULT_RENDERER_CELL_GROWTH_USE_TRANSFER_FUNCTION_COLOR);
     ispc::CellGrowthRenderer_set(getIE(), (_secondaryModel ? _secondaryModel->getIE() : nullptr),
                                  (_bgMaterial ? _bgMaterial->getIE() : nullptr), spp, _lightPtr, _lightArray.size(),
-                                 (_simulationData ? (float*)_simulationData->data : nullptr), _simulationDataSize,
+                                 (_userData ? (float*)_userData->data : nullptr), _simulationDataSize,
                                  _alphaCorrection, _simulationThreshold, _exposure, _fogThickness, _fogStart, _shadows,
                                  _softShadows, _shadowDistance, _useTransferFunctionColor, _useHardwareRandomizer);
 }