diff --git a/Modules/Simulation/mitkSimulationObjectFactory.cpp b/Modules/Simulation/mitkSimulationObjectFactory.cpp
index 0304cd92f6..630d9f1672 100644
--- a/Modules/Simulation/mitkSimulationObjectFactory.cpp
+++ b/Modules/Simulation/mitkSimulationObjectFactory.cpp
@@ -1,153 +1,154 @@
 /*===================================================================
 
 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 "mitkIndexROI.h"
 #include "mitkSimulation.h"
 #include "mitkSimulationGLMapper2D.h"
 #include "mitkSimulationObjectFactory.h"
 #include "mitkSimulationVtkMapper3D.h"
 #include "mitkSimulationWriter.h"
 #include "mitkVtkModel.h"
 #include <mitkCoreObjectFactory.h>
+#include <mitkVtkGLMapperWrapper.h>
 #include <sofa/helper/system/glut.h>
 #include <sofa/component/init.h>
 #include <sofa/core/ObjectFactory.h>
 #include <sofa/core/visual/VisualParams.h>
 #include <sofa/simulation/common/xml/initXml.h>
 
 static void InitializeSofa()
 {
   int argc = 0;
   glutInit(&argc, NULL);
 
   sofa::component::init();
   sofa::simulation::xml::initXml();
 
   sofa::core::visual::VisualParams::defaultInstance()->setSupported(sofa::core::visual::API_OpenGL);
 }
 
 static void RegisterSofaClasses()
 {
   using sofa::core::ObjectFactory;
   using sofa::core::RegisterObject;
 
   int IndexROIClass = RegisterObject("").add<mitk::IndexROI>();
   int VtkModelClass = RegisterObject("").add<mitk::VtkModel>();
 
   ObjectFactory::AddAlias("VisualModel", "VtkModel", true);
   ObjectFactory::AddAlias("OglModel", "VtkModel", true);
 }
 
 mitk::SimulationObjectFactory::SimulationObjectFactory()
   : m_SimulationIOFactory(SimulationIOFactory::New()),
     m_SimulationWriterFactory(SimulationWriterFactory::New())
 {
   itk::ObjectFactoryBase::RegisterFactory(m_SimulationIOFactory);
   itk::ObjectFactoryBase::RegisterFactory(m_SimulationWriterFactory);
 
   m_FileWriters.push_back(SimulationWriter::New().GetPointer());
 
   std::string description = "SOFA Scene Files";
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.scn", description));
 
   InitializeSofa();
   RegisterSofaClasses();
 }
 
 mitk::SimulationObjectFactory::~SimulationObjectFactory()
 {
   itk::ObjectFactoryBase::UnRegisterFactory(m_SimulationWriterFactory);
   itk::ObjectFactoryBase::UnRegisterFactory(m_SimulationIOFactory);
 }
 
 mitk::Mapper::Pointer mitk::SimulationObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId slotId)
 {
   Mapper::Pointer mapper;
 
   if (dynamic_cast<Simulation*>(node->GetData()) != NULL)
   {
     if (slotId == BaseRenderer::Standard2D)
     {
-      mapper = SimulationGLMapper2D::New();
+      mapper = VtkGLMapperWrapper::New(SimulationGLMapper2D::New().GetPointer());
     }
     else if (slotId == BaseRenderer::Standard3D)
     {
       mapper = SimulationVtkMapper3D::New();
     }
 
     if (mapper.IsNotNull())
       mapper->SetDataNode(node);
   }
 
   return mapper;
 }
 
 const char* mitk::SimulationObjectFactory::GetDescription() const
 {
   return "Simulation Object Factory";
 }
 
 const char* mitk::SimulationObjectFactory::GetFileExtensions()
 {
   std::string fileExtensions;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtensions);
   return fileExtensions.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::SimulationObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::SimulationObjectFactory::GetITKSourceVersion() const
 {
   return ITK_SOURCE_VERSION;
 }
 
 const char* mitk::SimulationObjectFactory::GetSaveFileExtensions()
 {
   std::string saveFileExtensions;
   this->CreateFileExtensions(m_FileExtensionsMap, saveFileExtensions);
   return saveFileExtensions.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::SimulationObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::SimulationObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   if (node == NULL)
     return;
 
   if (dynamic_cast<Simulation*>(node->GetData()) != NULL)
   {
     SimulationGLMapper2D::SetDefaultProperties(node);
     SimulationVtkMapper3D::SetDefaultProperties(node);
   }
 }
 
 void mitk::RegisterSimulationObjectFactory()
 {
   static bool alreadyRegistered = false;
 
   if (!alreadyRegistered)
   {
     CoreObjectFactory::GetInstance()->RegisterExtraFactory(SimulationObjectFactory::New());
     alreadyRegistered = true;
   }
 }
diff --git a/Modules/Simulation/mitkSimulationVtkMapper3D.cpp b/Modules/Simulation/mitkSimulationVtkMapper3D.cpp
index 369077e42f..70ed74fbc5 100644
--- a/Modules/Simulation/mitkSimulationVtkMapper3D.cpp
+++ b/Modules/Simulation/mitkSimulationVtkMapper3D.cpp
@@ -1,164 +1,164 @@
 /*===================================================================
 
 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 "mitkSetVtkRendererVisitor.h"
 #include "mitkSimulation.h"
 #include "mitkSimulationVtkMapper3D.h"
 #include "mitkVtkSimulationPolyDataMapper.h"
 #include <sofa/component/visualmodel/VisualStyle.h>
 #include <sofa/core/visual/VisualParams.h>
 
 mitk::SimulationVtkMapper3D::LocalStorage::LocalStorage()
   : m_Actor(vtkSmartPointer<vtkActor>::New())
 {
 }
 
 mitk::SimulationVtkMapper3D::LocalStorage::~LocalStorage()
 {
 }
 
 void mitk::SimulationVtkMapper3D::SetDefaultProperties(DataNode* node, BaseRenderer* renderer, bool overwrite)
 {
   if (node != NULL)
   {
     Simulation* simulation = dynamic_cast<Simulation*>(node->GetData());
 
     if (simulation != NULL)
     {
       sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
       sofa::component::visualmodel::VisualStyle::SPtr visualStyle;
 
       rootNode->get(visualStyle);
 
       if (!visualStyle)
       {
         visualStyle = sofa::core::objectmodel::New<sofa::component::visualmodel::VisualStyle>();
 
         sofa::core::visual::DisplayFlags* displayFlags = visualStyle->displayFlags.beginEdit();
         displayFlags->setShowVisualModels();
         visualStyle->displayFlags.endEdit();
 
         rootNode->addObject(visualStyle);
       }
 
       const sofa::core::visual::DisplayFlags& displayFlags = visualStyle->displayFlags.getValue();
 
       node->AddProperty("Simulation.Behavior.Behavior Models", BoolProperty::New(displayFlags.getShowBehaviorModels()), renderer, overwrite);
       node->AddProperty("Simulation.Behavior.Force Fields", BoolProperty::New(displayFlags.getShowForceFields()), renderer, overwrite);
       node->AddProperty("Simulation.Behavior.Interactions", BoolProperty::New(displayFlags.getShowInteractionForceFields()), renderer, overwrite);
       node->AddProperty("Simulation.Collision.Bounding Trees", BoolProperty::New(displayFlags.getShowBoundingCollisionModels()), renderer, overwrite);
       node->AddProperty("Simulation.Collision.Collision Models", BoolProperty::New(displayFlags.getShowCollisionModels()), renderer, overwrite);
       node->AddProperty("Simulation.Mapping.Mechanical Mappings", BoolProperty::New(displayFlags.getShowMechanicalMappings()), renderer, overwrite);
       node->AddProperty("Simulation.Mapping.Visual Mappings", BoolProperty::New(displayFlags.getShowMappings()), renderer, overwrite);
       node->AddProperty("Simulation.Options.Normals", BoolProperty::New(displayFlags.getShowNormals()), renderer, overwrite);
       node->AddProperty("Simulation.Options.Wire Frame", BoolProperty::New(displayFlags.getShowWireFrame()), renderer, overwrite);
       node->AddProperty("Simulation.Visual.Visual Models", BoolProperty::New(displayFlags.getShowVisualModels() != sofa::core::visual::tristate::false_value), renderer, overwrite);
     }
 
     Superclass::SetDefaultProperties(node, renderer, overwrite);
   }
 }
 
 mitk::SimulationVtkMapper3D::SimulationVtkMapper3D()
 {
 }
 
 mitk::SimulationVtkMapper3D::~SimulationVtkMapper3D()
 {
 }
 
 void mitk::SimulationVtkMapper3D::ApplyColorAndOpacityProperties(vtkActor*, BaseRenderer*)
 {
 }
 
 void mitk::SimulationVtkMapper3D::ApplySimulationProperties(BaseRenderer* renderer)
 {
   DataNode* node = this->GetDataNode();
 
   bool showBehaviorModels;
   bool showForceFields;
   bool showInteractionForceFields;
   bool showBoundingCollisionModels;
   bool showCollisionModels;
   bool showMechanicalMappings;
   bool showMappings;
   bool showNormals;
   bool showWireFrame;
   bool showVisualModels;
 
   node->GetBoolProperty("Simulation.Behavior.Behavior Models", showBehaviorModels, renderer);
   node->GetBoolProperty("Simulation.Behavior.Force Fields", showForceFields, renderer);
   node->GetBoolProperty("Simulation.Behavior.Interactions", showInteractionForceFields, renderer);
   node->GetBoolProperty("Simulation.Collision.Bounding Trees", showBoundingCollisionModels, renderer);
   node->GetBoolProperty("Simulation.Collision.Collision Models", showCollisionModels, renderer);
   node->GetBoolProperty("Simulation.Mapping.Mechanical Mappings", showMechanicalMappings, renderer);
   node->GetBoolProperty("Simulation.Mapping.Visual Mappings", showMappings, renderer);
   node->GetBoolProperty("Simulation.Options.Normals", showNormals, renderer);
   node->GetBoolProperty("Simulation.Options.Wire Frame", showWireFrame, renderer);
   node->GetBoolProperty("Simulation.Visual.Visual Models", showVisualModels, renderer);
 
   Simulation* simulation = static_cast<Simulation*>(this->GetData());
   sofa::component::visualmodel::VisualStyle::SPtr visualStyle;
   simulation->GetRootNode()->get(visualStyle);
 
   sofa::core::visual::DisplayFlags* displayFlags = visualStyle->displayFlags.beginEdit();
 
   displayFlags->setShowBehaviorModels(showBehaviorModels);
   displayFlags->setShowForceFields(showForceFields);
   displayFlags->setShowInteractionForceFields(showInteractionForceFields);
   displayFlags->setShowBoundingCollisionModels(showBoundingCollisionModels);
   displayFlags->setShowCollisionModels(showCollisionModels);
   displayFlags->setShowMechanicalMappings(showMechanicalMappings);
   displayFlags->setShowMappings(showMappings);
   displayFlags->setShowNormals(showNormals);
   displayFlags->setShowWireFrame(showWireFrame);
   displayFlags->setShowVisualModels(showVisualModels);
 
   visualStyle->displayFlags.endEdit();
 }
 
 void mitk::SimulationVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
 {
   DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
-  Simulation* simulation = static_cast<Simulation*>(dataNode->GetData());
+  Simulation* simulation = dynamic_cast<Simulation*>(dataNode->GetData());
 
   if (simulation == NULL)
     return;
 
   LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
   if (localStorage->m_Mapper == NULL)
   {
     localStorage->m_Mapper = vtkSmartPointer<vtkSimulationPolyDataMapper>::New();
     localStorage->m_Mapper->SetSimulation(simulation);
 
     localStorage->m_Actor->SetMapper(localStorage->m_Mapper);
 
     SetVtkRendererVisitor setVtkRendererVisitor(renderer->GetVtkRenderer());
     simulation->GetRootNode()->executeVisitor(&setVtkRendererVisitor);
   }
 
   this->ApplySimulationProperties(renderer);
 }
 
 vtkProp* mitk::SimulationVtkMapper3D::GetVtkProp(BaseRenderer* renderer)
 {
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_Actor;
 }
diff --git a/Modules/Simulation/mitkSimulationVtkMapper3D.h b/Modules/Simulation/mitkSimulationVtkMapper3D.h
index 980c69ec1e..cf570eca70 100644
--- a/Modules/Simulation/mitkSimulationVtkMapper3D.h
+++ b/Modules/Simulation/mitkSimulationVtkMapper3D.h
@@ -1,69 +1,69 @@
 /*===================================================================
 
 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 mitkSimulationVtkMapper3D_h
 #define mitkSimulationVtkMapper3D_h
 
 #include <mitkVtkMapper.h>
 #include <vtkSmartPointer.h>
 #include <MitkSimulationExports.h>
 
 namespace mitk
 {
   class vtkSimulationPolyDataMapper;
 
   class MitkSimulation_EXPORT SimulationVtkMapper3D : public VtkMapper
   {
-    class LocalStorage
+    class LocalStorage : public Mapper::BaseLocalStorage
     {
     public:
       LocalStorage();
       ~LocalStorage();
 
       vtkSmartPointer<vtkSimulationPolyDataMapper> m_Mapper;
       vtkSmartPointer<vtkActor> m_Actor;
 
     private:
       LocalStorage(const LocalStorage&);
       LocalStorage& operator=(const LocalStorage&);
     };
 
   public:
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false);
 
     mitkClassMacro(SimulationVtkMapper3D, VtkMapper);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     void ApplyColorAndOpacityProperties(vtkActor*, BaseRenderer*);
     void ApplySimulationProperties(BaseRenderer* renderer);
     vtkProp* GetVtkProp(BaseRenderer* renderer);
 
   protected:
     void GenerateDataForRenderer(BaseRenderer* renderer);
 
   private:
     SimulationVtkMapper3D();
     ~SimulationVtkMapper3D();
 
     SimulationVtkMapper3D(const Self&);
     Self& operator=(const Self&);
 
     LocalStorageHandler<LocalStorage> m_LocalStorageHandler;
   };
 }
 
 #endif