diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
index 7e6496f760..d8ab9634a4 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp
@@ -1,189 +1,230 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkFiberBundleMapper2D.h"
 #include <mitkBaseRenderer.h>
 #include <vtkActor.h>
-#include <vtkPolyDataMapper.h>
+#include <vtkOpenGLPolyDataMapper.h>
 #include <vtkPlane.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkProperty.h>
 #include <vtkLookupTable.h>
 #include <vtkPoints.h>
 #include <vtkCamera.h>
 #include <vtkPolyLine.h>
 #include <vtkRenderer.h>
 #include <vtkCellArray.h>
 #include <vtkMatrix4x4.h>
 #include <vtkTubeFilter.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkCoreServices.h>
 
 mitk::FiberBundleMapper2D::FiberBundleMapper2D()
     : m_LineWidth(1)
 {
     m_lut = vtkLookupTable::New();
     m_lut->Build();
 
 }
 
 mitk::FiberBundleMapper2D::~FiberBundleMapper2D()
 {
 }
 
 
 mitk::FiberBundle* mitk::FiberBundleMapper2D::GetInput()
 {
     return dynamic_cast< mitk::FiberBundle * > ( GetDataNode()->GetData() );
 }
 
 
 
 void mitk::FiberBundleMapper2D::Update(mitk::BaseRenderer * renderer)
 {
         bool visible = true;
         GetDataNode()->GetVisibility(visible, renderer, "visible");
         if ( !visible )
             return;
 
         // Calculate time step of the input data for the specified renderer (integer value)
         // this method is implemented in mitkMapper
         this->CalculateTimeStep( renderer );
 
         //check if updates occured in the node or on the display
         FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
         //set renderer independent shader properties
         const DataNode::Pointer node = this->GetDataNode();
         float thickness = 2.0;
         if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness))
             MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR";
 
         bool fiberfading = false;
         if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading))
             MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR";
 
         float fiberOpacity;
         this->GetDataNode()->GetOpacity(fiberOpacity, nullptr);
         node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberThickness",thickness);
         node->SetIntProperty("shader.mitkShaderFiberClipping.fiberFadingON",fiberfading);
         node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberOpacity",fiberOpacity);
 
         mitk::FiberBundle* fiberBundle = this->GetInput();
         if (fiberBundle==nullptr)
             return;
 
         int lineWidth = 0;
         node->GetIntProperty("LineWidth", lineWidth);
         if (m_LineWidth!=lineWidth)
         {
             m_LineWidth = lineWidth;
             fiberBundle->RequestUpdate2D();
         }
 
         if ( localStorage->m_LastUpdateTime<renderer->GetCurrentWorldPlaneGeometryUpdateTime() || localStorage->m_LastUpdateTime<fiberBundle->GetUpdateTime2D() )
         {
             this->UpdateShaderParameter(renderer);
             this->GenerateDataForRenderer( renderer );
         }
 }
 
 void mitk::FiberBundleMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer)
 {
     //get information about current position of views
     mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController();
     mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry();
 
     //generate according cutting planes based on the view position
     float planeNormal[3];
     planeNormal[0] = planeGeo->GetNormal()[0];
     planeNormal[1] = planeGeo->GetNormal()[1];
     planeNormal[2] = planeGeo->GetNormal()[2];
 
     float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0];
     float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1];
     float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2];
     float thickness = tmp1 + tmp2 + tmp3; //attention, correct normalvector
 
     DataNode::Pointer node = this->GetDataNode();
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.w",thickness,renderer);
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.x",planeNormal[0],renderer);
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.y",planeNormal[1],renderer);
     node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.z",planeNormal[2],renderer);
 }
 
 // vtkActors and Mappers are feeded here
 void mitk::FiberBundleMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
-    mitk::FiberBundle* fiberBundle = this->GetInput();
+  mitk::FiberBundle* fiberBundle = this->GetInput();
+
+  //the handler of local storage gets feeded in this method with requested data for related renderwindow
+  FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
+
+  mitk::DataNode* node = this->GetDataNode();
+  if (node == nullptr)
+    return;
+
+  vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
+  if (fiberPolyData == nullptr)
+    return;
+
+  fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors());
+  localStorage->m_FiberMapper->ScalarVisibilityOn();
+  localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
+  localStorage->m_FiberMapper->SetLookupTable(m_lut);  //apply the properties after the slice was set
+  localStorage->m_PointActor->GetProperty()->SetOpacity(0.999);
+  localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
+
+  localStorage->m_FiberMapper->SetInputData(fiberPolyData);
+  localStorage->m_FiberMapper->SetVertexShaderCode(
+    "varying vec3 positionWorld;\n"
+    "varying vec3 color;\n"
+
+    "void main(void)\n"
+    "{\n"
+    "  color = gl_Color.rgb;\n"
+    "  positionWorld = vec3(gl_Vertex);\n"
+    "  gl_Position = ftransform();\n"
+    "}\n"
+    );
+  localStorage->m_FiberMapper->SetFragmentShaderCode(
+    "//VTK::System::Dec\n"  // always start with this line
+    "//VTK::Output::Dec\n"  // always have this line in your FS
+    "uniform vec4 slicingPlane;\n"
+    "uniform float fiberThickness;\n"
+    "uniform int fiberFadingON;\n"
+    "uniform float fiberOpacity;\n"
+
+    "varying vec3 positionWorld;\n"
+    "varying vec3 color;\n"
+
+    "void main(void)\n"
+    "{"
+    "  float r1 = dot(positionWorld, slicingPlane.xyz) - slicingPlane.w;\n"
+    
+    "  if (abs(r1) >= fiberThickness)\n"
+    "    discard;\n"
+    
+    "  if (fiberFadingON != 0)\n"
+    "  {\n"
+    "    float x = (r1 + fiberThickness) / (fiberThickness*2.0);\n"
+    "    x = 1.0 - x;\n"
+    "    gl_FragColor = vec4(color*x, fiberOpacity);\n"
+    "  }\n"
+    "  else{\n"
+    "    gl_FragColor = vec4(color, fiberOpacity);\n"
+    "  }\n"
+    "}\n"
+    );
 
-    //the handler of local storage gets feeded in this method with requested data for related renderwindow
-    FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
-
-    mitk::DataNode* node = this->GetDataNode();
-    if ( node == nullptr )
-        return;
-
-    vtkSmartPointer<vtkPolyData> fiberPolyData = fiberBundle->GetFiberPolyData();
-    if (fiberPolyData == nullptr)
-        return;
-
-    fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors());
-    localStorage->m_FiberMapper->ScalarVisibilityOn();
-    localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData();
-    localStorage->m_FiberMapper->SetLookupTable(m_lut);  //apply the properties after the slice was set
-    localStorage->m_PointActor->GetProperty()->SetOpacity(0.999);
-    localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS");
-
-    localStorage->m_FiberMapper->SetInputData(fiberPolyData);
     localStorage->m_PointActor->SetMapper(localStorage->m_FiberMapper);
     localStorage->m_PointActor->GetProperty()->ShadingOn();
     localStorage->m_PointActor->GetProperty()->SetLineWidth(m_LineWidth);
 
     // Applying shading properties
     this->ApplyShaderProperties(renderer);
 
     // We have been modified => save this for next Update()
     localStorage->m_LastUpdateTime.Modified();
 }
 
 
 vtkProp* mitk::FiberBundleMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
     this->Update(renderer);
     return m_LocalStorageHandler.GetLocalStorage(renderer)->m_PointActor;
 }
 
 
 void mitk::FiberBundleMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
     Superclass::SetDefaultProperties(node, renderer, overwrite);
 //    node->SetProperty("shader",mitk::ShaderProperty::New("mitkShaderFiberClipping"));
 
     //add other parameters to propertylist
     node->AddProperty( "Fiber2DSliceThickness", mitk::FloatProperty::New(1.0f), renderer, overwrite );
     node->AddProperty( "Fiber2DfadeEFX", mitk::BoolProperty::New(true), renderer, overwrite );
     node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite);
 }
 
 
 mitk::FiberBundleMapper2D::FBXLocalStorage::FBXLocalStorage()
 {
     m_PointActor = vtkSmartPointer<vtkActor>::New();
-    m_FiberMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    m_FiberMapper = vtkSmartPointer<MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER>::New();
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
index 538174c223..984e79a0d0 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.h
@@ -1,109 +1,110 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef FiberBundleMAPPER2D_H_HEADER_INCLUDED
 #define FiberBundleMAPPER2D_H_HEADER_INCLUDED
 
 //MITK Rendering
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 //#include <MitkFiberTrackingExports.h>
 
 #include <mitkVtkMapper.h>
 #include <mitkFiberBundle.h>
 #include <vtkSmartPointer.h>
 
+#define MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER vtkOpenGLPolyDataMapper
 
 class vtkActor;
 //class vtkPropAssembly; //lets see if we need it
 class mitkBaseRenderer;
-class vtkPolyDataMapper;
+class MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER;
 class vtkCutter;
 class vtkPlane;
 class vtkPolyData;
 
 
 
 namespace mitk {
 
 struct IShaderRepository;
 
 class FiberBundleMapper2D : public VtkMapper
 {
 
 public:
     mitkClassMacro(FiberBundleMapper2D, VtkMapper);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     mitk::FiberBundle* GetInput();
 
 
     /** \brief Checks whether this mapper needs to update itself and generate data. */
     virtual void Update(mitk::BaseRenderer * renderer) override;
 
 
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false );
 
 
     //### methods of MITK-VTK rendering pipeline
     virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) override;
     //### end of methods of MITK-VTK rendering pipeline
 
 
     class  FBXLocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
         /** \brief Point Actor of a 2D render window. */
         vtkSmartPointer<vtkActor> m_PointActor;
         /** \brief Point Mapper of a 2D render window. */
-        vtkSmartPointer<vtkPolyDataMapper> m_FiberMapper;
+        vtkSmartPointer<MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER> m_FiberMapper;
         vtkSmartPointer<vtkPlane> m_SlicingPlane;  //needed later when optimized 2D mapper
         vtkSmartPointer<vtkPolyData> m_SlicedResult; //might be depricated in optimized 2D mapper
 
         /** \brief Timestamp of last update of stored data. */
         itk::TimeStamp m_LastUpdateTime;
         /** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */
         FBXLocalStorage(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file
 
         ~FBXLocalStorage()
         {
         }
     };
 
     /** \brief This member holds all three LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<FBXLocalStorage> m_LocalStorageHandler;
 
 
 
 protected:
     FiberBundleMapper2D();
     virtual ~FiberBundleMapper2D();
 
     /** Does the actual resampling, without rendering. */
     virtual void GenerateDataForRenderer(mitk::BaseRenderer*) override;
 
     void UpdateShaderParameter(mitk::BaseRenderer*);
 
 private:
     vtkSmartPointer<vtkLookupTable> m_lut;
 
     int     m_LineWidth;
 };
 
 
 }//end namespace
 
 #endif