Merge topic 'task/rendering_fixes'

09ed5871b adding switch for ray tracer shadning
bc4d034f8 fixing compositing error

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !1420

vtkm/rendering/MapperRayTracer.cxx

@@ -45,10 +45,12 @@ struct MapperRayTracer::InternalsType
   vtkm::rendering::raytracing::Camera RayCamera;
   vtkm::rendering::raytracing::Ray<vtkm::Float32> Rays;
   bool CompositeBackground;
+  bool Shade;
   VTKM_CONT
   InternalsType()
     : Canvas(nullptr)
     , CompositeBackground(true)
+    , Shade(true)
   {
   }
 };
@@ -128,6 +130,7 @@ void MapperRayTracer::RenderCells(const vtkm::cont::DynamicCellSet& cellset,
   this->Internals->Tracer.SetField(scalarField, scalarRange);
 
   this->Internals->Tracer.SetColorMap(this->ColorMap);
+  this->Internals->Tracer.SetShadingOn(this->Internals->Shade);
   this->Internals->Tracer.Render(this->Internals->Rays);
 
   timer.Reset();
@@ -150,6 +153,11 @@ void MapperRayTracer::SetCompositeBackground(bool on)
   this->Internals->CompositeBackground = on;
 }
 
+void MapperRayTracer::SetShadingOn(bool on)
+{
+  this->Internals->Shade = on;
+}
+
 void MapperRayTracer::StartScene()
 {
   // Nothing needs to be done.

vtkm/rendering/MapperRayTracer.h

@@ -52,6 +52,7 @@ public:
   virtual void EndScene() override;
   void SetCompositeBackground(bool on);
   vtkm::rendering::Mapper* NewCopy() const override;
+  void SetShadingOn(bool on);
 
 private:
   struct InternalsType;

vtkm/rendering/raytracing/ConnectivityTracer.hxx

@@ -775,11 +775,11 @@ public:
     while (enterDistance <= currentDistance && currentDistance <= exitDistance)
     {
       //composite
-      sampleColor[3] *= (1.f - color[3]);
+      vtkm::Float32 alpha = sampleColor[3] * (1.f - color[3]);
-      color[0] = color[0] + sampleColor[0] * sampleColor[3];
+      color[0] = color[0] + sampleColor[0] * alpha;
-      color[1] = color[1] + sampleColor[1] * sampleColor[3];
+      color[1] = color[1] + sampleColor[1] * alpha;
-      color[2] = color[2] + sampleColor[2] * sampleColor[3];
+      color[2] = color[2] + sampleColor[2] * alpha;
-      color[3] = sampleColor[3] + color[3];
+      color[3] = alpha + color[3];
 
       if (color[3] > 1.)
       {

vtkm/rendering/raytracing/RayTracer.cxx

@@ -44,7 +44,7 @@ namespace detail
 class SurfaceColor
 {
 public:
-  class MapScalarToColor : public vtkm::worklet::WorkletMapField
+  class Shade : public vtkm::worklet::WorkletMapField
   {
   private:
     vtkm::Vec<vtkm::Float32, 3> LightPosition;
@@ -57,9 +57,9 @@ public:
 
   public:
     VTKM_CONT
-    MapScalarToColor(const vtkm::Vec<vtkm::Float32, 3>& lightPosition,
+    Shade(const vtkm::Vec<vtkm::Float32, 3>& lightPosition,
-                     const vtkm::Vec<vtkm::Float32, 3>& cameraPosition,
+          const vtkm::Vec<vtkm::Float32, 3>& cameraPosition,
-                     const vtkm::Vec<vtkm::Float32, 3>& lookAt)
+          const vtkm::Vec<vtkm::Float32, 3>& lookAt)
       : LightPosition(lightPosition)
       , CameraPosition(cameraPosition)
       , LookAt(lookAt)
@@ -139,24 +139,74 @@ public:
       colors.Set(offset + 3, color[3]);
     }
 
+  }; //class Shade
+
+  class MapScalarToColor : public vtkm::worklet::WorkletMapField
+  {
+  public:
+    VTKM_CONT
+    MapScalarToColor() {}
+
+    using ControlSignature = void(FieldIn<>, FieldIn<>, WholeArrayInOut<>, WholeArrayIn<>);
+    using ExecutionSignature = void(_1, _2, _3, _4, WorkIndex);
+
+    template <typename ColorPortalType, typename Precision, typename ColorMapPortalType>
+    VTKM_EXEC void operator()(const vtkm::Id& hitIdx,
+                              const Precision& scalar,
+                              ColorPortalType& colors,
+                              ColorMapPortalType colorMap,
+                              const vtkm::Id& idx) const
+    {
+
+      if (hitIdx < 0)
+      {
+        return;
+      }
+
+      vtkm::Vec<Precision, 4> color;
+      vtkm::Id offset = idx * 4;
+
+      vtkm::Int32 colorMapSize = static_cast<vtkm::Int32>(colorMap.GetNumberOfValues());
+      vtkm::Int32 colorIdx = vtkm::Int32(scalar * Precision(colorMapSize - 1));
+
+      // clamp color index
+      colorIdx = vtkm::Max(0, colorIdx);
+      colorIdx = vtkm::Min(colorMapSize - 1, colorIdx);
+      color = colorMap.Get(colorIdx);
+
+      colors.Set(offset + 0, color[0]);
+      colors.Set(offset + 1, color[1]);
+      colors.Set(offset + 2, color[2]);
+      colors.Set(offset + 3, color[3]);
+    }
+
   }; //class MapScalarToColor
 
   template <typename Precision>
   VTKM_CONT void run(Ray<Precision>& rays,
                      vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>& colorMap,
-                     const vtkm::rendering::raytracing::Camera& camera)
+                     const vtkm::rendering::raytracing::Camera& camera,
+                     bool shade)
   {
-    // TODO: support light positions
+    if (shade)
-    vtkm::Vec<vtkm::Float32, 3> scale(2, 2, 2);
+    {
-    vtkm::Vec<vtkm::Float32, 3> lightPosition = camera.GetPosition() + scale * camera.GetUp();
+      // TODO: support light positions
-    vtkm::worklet::DispatcherMapField<MapScalarToColor>(
+      vtkm::Vec<vtkm::Float32, 3> scale(2, 2, 2);
-      MapScalarToColor(lightPosition, camera.GetPosition(), camera.GetLookAt()))
+      vtkm::Vec<vtkm::Float32, 3> lightPosition = camera.GetPosition() + scale * camera.GetUp();
-      .Invoke(rays.HitIdx,
+      vtkm::worklet::DispatcherMapField<Shade>(
-              rays.Scalar,
+        Shade(lightPosition, camera.GetPosition(), camera.GetLookAt()))
-              rays.Normal,
+        .Invoke(rays.HitIdx,
-              rays.Intersection,
+                rays.Scalar,
-              rays.Buffers.at(0).Buffer,
+                rays.Normal,
-              colorMap);
+                rays.Intersection,
+                rays.Buffers.at(0).Buffer,
+                colorMap);
+    }
+    else
+    {
+      vtkm::worklet::DispatcherMapField<MapScalarToColor>(MapScalarToColor())
+        .Invoke(rays.HitIdx, rays.Scalar, rays.Buffers.at(0).Buffer, colorMap);
+    }
   }
 }; // class SurfaceColor
 
@@ -164,6 +214,7 @@ public:
 
 RayTracer::RayTracer()
   : NumberOfShapes(0)
+  , Shade(true)
 {
 }
 
@@ -205,6 +256,11 @@ void RayTracer::Render(Ray<vtkm::Float64>& rays)
   RenderOnDevice(rays);
 }
 
+void RayTracer::SetShadingOn(bool on)
+{
+  Shade = on;
+}
+
 vtkm::Id RayTracer::GetNumberOfShapes() const
 {
   return NumberOfShapes;
@@ -253,7 +309,7 @@ void RayTracer::RenderOnDevice(Ray<Precision>& rays)
 
       // Calculate the color at the intersection  point
       detail::SurfaceColor surfaceColor;
-      surfaceColor.run(rays, ColorMap, camera);
+      surfaceColor.run(rays, ColorMap, camera, this->Shade);
 
       time = timer.GetElapsedTime();
       logger->AddLogData("shade", time);

vtkm/rendering/raytracing/RayTracer.h

@@ -43,6 +43,7 @@ protected:
   vtkm::Id NumberOfShapes;
   vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorMap;
   vtkm::Range ScalarRange;
+  bool Shade;
 
   template <typename Precision>
   void RenderOnDevice(Ray<Precision>& rays);
@@ -65,6 +66,9 @@ public:
   VTKM_CONT
   void SetColorMap(const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>& colorMap);
 
+  VTKM_CONT
+  void SetShadingOn(bool on);
+
   VTKM_CONT
   void Render(vtkm::rendering::raytracing::Ray<vtkm::Float32>& rays);