diff --git a/Modules/Core/include/mitkVtkMapper.h b/Modules/Core/include/mitkVtkMapper.h index 7d494b662d..0ddd7616f8 100644 --- a/Modules/Core/include/mitkVtkMapper.h +++ b/Modules/Core/include/mitkVtkMapper.h @@ -1,170 +1,170 @@ /*=================================================================== 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. ===================================================================*/ // change number #ifndef VTKMAPPER_H_HEADER_INCLUDED_C1C5453B #define VTKMAPPER_H_HEADER_INCLUDED_C1C5453B #include "mitkBaseRenderer.h" #include "mitkDataNode.h" #include "mitkLocalStorageHandler.h" #include "mitkMapper.h" #include "mitkVtkPropRenderer.h" #include #include #include #include #include #include #include #include #include #include class vtkProp; class vtkProp3D; class vtkActor; namespace mitk { /** \brief Base class of all Vtk Mappers in order to display primitives * by exploiting Vtk functionality. * * Rendering of opaque, translucent or volumetric geometry and overlays * is done in consecutive render passes. * * \ingroup Mapper */ class MITKCORE_EXPORT VtkMapper : public Mapper { public: mitkClassMacro(VtkMapper, Mapper); virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) = 0; /** \brief Re-issues all drawing commands required to describe * the entire scene each time a new frame is required, * regardless of actual changes. */ static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper); /** * \brief Returns whether this is an vtk-based mapper * \deprecatedSince{2013_03} All mappers of superclass VTKMapper are vtk based, use a dynamic_cast instead */ DEPRECATED(virtual bool IsVtkBased() const override); /** \brief Determines which geometry should be rendered * (opaque, translucent, volumetric, overlay) * and calls the appropriate function. * * Called by mitk::VtkPropRenderer::Render */ void MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type) override; /** \brief Checks visibility and renders the overlay */ virtual void MitkRenderOverlay(BaseRenderer *renderer); /** \brief Checks visibility and renders untransparent geometry */ virtual void MitkRenderOpaqueGeometry(BaseRenderer *renderer); /** \brief Checks visiblity and renders transparent geometry */ virtual void MitkRenderTranslucentGeometry(BaseRenderer *renderer); /** \brief Checks visibility and renders volumes */ virtual void MitkRenderVolumetricGeometry(BaseRenderer *renderer); /** \brief Returns true if this mapper owns the specified vtkProp for * the given BaseRenderer. * * Note: returns false by default; should be implemented for VTK-based * Mapper subclasses. */ virtual bool HasVtkProp(const vtkProp *prop, BaseRenderer *renderer); /** \brief Set the vtkTransform of the m_Prop3D for * the current time step of \a renderer * * Called by mitk::VtkPropRenderer::Update before rendering. This * method will transform all actors (e.g. of an vtkAssembly) according * the geometry. * * \warning This method transforms only props which derive * from vtkProp3D. Make sure to use vtkAssembly, if you have * multiple props. vtkPropAssembly does not work, since it derives * from vtkProp. */ virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer); /** * \brief Apply color and opacity properties read from the PropertyList * \deprecatedSince{2013_03} Use ApplyColorAndOpacityProperties(mitk::BaseRenderer* renderer, vtkActor * actor) * instead */ DEPRECATED(inline virtual void ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer)) { ApplyColorAndOpacityProperties(renderer, actor); } /** - * \brief SHADERTODO + * \deprecatedSince{2017_08} */ - void ApplyShaderProperties(mitk::BaseRenderer *); + DEPRECATED(void ApplyShaderProperties(mitk::BaseRenderer *)){} /** * \brief Apply color and opacity properties read from the PropertyList. * Called by mapper subclasses. */ virtual void ApplyColorAndOpacityProperties(mitk::BaseRenderer *renderer, vtkActor *actor) override; /** * \brief Release vtk-based graphics resources that are being consumed by this mapper. * * Method called by mitk::VtkPropRenderer. The parameter renderer could be used to * determine which graphic resources to release. The local storage is accessible * by the parameter renderer. Should be overwritten in subclasses. */ virtual void ReleaseGraphicsResources(mitk::BaseRenderer * /*renderer*/) {} class VtkMapperLocalStorage : public mitk::Mapper::BaseLocalStorage { public: itk::TimeStamp m_ModifiedTimeStamp; VtkMapperLocalStorage() { } ~VtkMapperLocalStorage() {} }; mitk::LocalStorageHandler m_VtkMapperLSH; protected: /** constructor */ VtkMapper(); /** virtual destructor in order to derive from this class */ virtual ~VtkMapper(); private: /** copy constructor */ VtkMapper(const VtkMapper &); /** assignment operator */ VtkMapper &operator=(const VtkMapper &); }; } // namespace mitk #endif /* VTKMAPPER_H_HEADER_INCLUDED_C1C5453B */ diff --git a/Modules/Core/src/DataManagement/mitkShaderProperty.cpp b/Modules/Core/src/DataManagement/mitkShaderProperty.cpp deleted file mode 100644 index ac7782cc43..0000000000 --- a/Modules/Core/src/DataManagement/mitkShaderProperty.cpp +++ /dev/null @@ -1,118 +0,0 @@ -/*=================================================================== - -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 "mitkShaderProperty.h" -#include - -#include "mitkCoreServices.h" -#include "mitkIShaderRepository.h" - -#include -#include - -mitk::ShaderProperty::ShaderProperty() -{ - AddShaderTypes(); - SetShader((IdType)0); -} - -mitk::ShaderProperty::ShaderProperty(const ShaderProperty &other) - : mitk::EnumerationProperty(other), shaderList(other.shaderList) -{ -} - -mitk::ShaderProperty::ShaderProperty(const IdType &value) -{ - AddShaderTypes(); - SetShader(value); -} - -mitk::ShaderProperty::ShaderProperty(const std::string &value) -{ - AddShaderTypes(); - SetShader(value); -} - -void mitk::ShaderProperty::SetShader(const IdType &value) -{ - if (IsValidEnumerationValue(value)) - SetValue(value); - else - SetValue((IdType)0); -} - -void mitk::ShaderProperty::SetShader(const std::string &value) -{ - if (IsValidEnumerationValue(value)) - SetValue(value); - else - SetValue((IdType)0); -} - -mitk::EnumerationProperty::IdType mitk::ShaderProperty::GetShaderId() -{ - return GetValueAsId(); -} - -std::string mitk::ShaderProperty::GetShaderName() -{ - return GetValueAsString(); -} - -void mitk::ShaderProperty::AddShaderTypes() -{ - AddEnum("fixed"); - - IShaderRepository *shaderRepo = CoreServices::GetShaderRepository(); - if (shaderRepo == nullptr) - return; - - std::list l = shaderRepo->GetShaders(); - std::list::const_iterator i = l.begin(); - - while (i != l.end()) - { - AddEnum((*i)->GetName()); - ++i; - } -} - -bool mitk::ShaderProperty::AddEnum(const std::string &name, const IdType & /*id*/) -{ - Element e; - - e.name = name; - - bool success = Superclass::AddEnum(e.name, (IdType)shaderList.size()); - - shaderList.push_back(e); - - return success; -} - -bool mitk::ShaderProperty::Assign(const BaseProperty &property) -{ - Superclass::Assign(property); - this->shaderList = static_cast(property).shaderList; - return true; -} - -itk::LightObject::Pointer mitk::ShaderProperty::InternalClone() const -{ - itk::LightObject::Pointer result(new Self(*this)); - result->UnRegister(); - return result; -} diff --git a/Modules/Core/src/Rendering/mitkSurfaceVtkMapper3D.cpp b/Modules/Core/src/Rendering/mitkSurfaceVtkMapper3D.cpp index 70653e9154..bc15a7a8ed 100644 --- a/Modules/Core/src/Rendering/mitkSurfaceVtkMapper3D.cpp +++ b/Modules/Core/src/Rendering/mitkSurfaceVtkMapper3D.cpp @@ -1,531 +1,522 @@ /*=================================================================== 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 "mitkSurfaceVtkMapper3D.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // VTK #include #include #include #include #include #include #include #include const mitk::Surface *mitk::SurfaceVtkMapper3D::GetInput() { return static_cast(GetDataNode()->GetData()); } mitk::SurfaceVtkMapper3D::SurfaceVtkMapper3D() { m_GenerateNormals = false; } mitk::SurfaceVtkMapper3D::~SurfaceVtkMapper3D() { } void mitk::SurfaceVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer) { LocalStorage *ls = m_LSH.GetLocalStorage(renderer); bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) { ls->m_Actor->VisibilityOff(); return; } // // set the input-object at time t for the mapper // mitk::Surface::Pointer input = const_cast(this->GetInput()); vtkSmartPointer polydata = input->GetVtkPolyData(this->GetTimestep()); if (polydata == nullptr) { ls->m_Actor->VisibilityOff(); return; } if (m_GenerateNormals) { ls->m_VtkPolyDataNormals->SetInputData(polydata); ls->m_VtkPolyDataMapper->SetInputConnection(ls->m_VtkPolyDataNormals->GetOutputPort()); } else { bool depthsorting = false; GetDataNode()->GetBoolProperty("Depth Sorting", depthsorting); if (depthsorting) { ls->m_DepthSort->SetInputData(polydata); ls->m_DepthSort->SetCamera(renderer->GetVtkRenderer()->GetActiveCamera()); ls->m_DepthSort->SetDirectionToBackToFront(); ls->m_DepthSort->Update(); ls->m_VtkPolyDataMapper->SetInputConnection(ls->m_DepthSort->GetOutputPort()); } else { ls->m_VtkPolyDataMapper->SetInputData(polydata); } } // // apply properties read from the PropertyList // ApplyAllProperties(renderer, ls->m_Actor); if (visible) ls->m_Actor->VisibilityOn(); } void mitk::SurfaceVtkMapper3D::ResetMapper(BaseRenderer *renderer) { LocalStorage *ls = m_LSH.GetLocalStorage(renderer); ls->m_Actor->VisibilityOff(); } void mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(mitk::DataNode *node, vtkProperty *property, mitk::BaseRenderer *renderer) { // Backface culling { mitk::BoolProperty::Pointer p; node->GetProperty(p, "Backface Culling", renderer); bool useCulling = false; if (p.IsNotNull()) useCulling = p->GetValue(); property->SetBackfaceCulling(useCulling); } // Colors { double ambient[3] = {0.5, 0.5, 0.0}; double diffuse[3] = {0.5, 0.5, 0.0}; double specular[3] = {1.0, 1.0, 1.0}; float coeff_ambient = 0.5f; float coeff_diffuse = 0.5f; float coeff_specular = 0.5f; float power_specular = 10.0f; // Color { mitk::ColorProperty::Pointer p; node->GetProperty(p, "color", renderer); if (p.IsNotNull()) { mitk::Color c = p->GetColor(); ambient[0] = c.GetRed(); ambient[1] = c.GetGreen(); ambient[2] = c.GetBlue(); diffuse[0] = c.GetRed(); diffuse[1] = c.GetGreen(); diffuse[2] = c.GetBlue(); // Setting specular color to the same, make physically no real sense, however vtk rendering slows down, if these // colors are different. specular[0] = c.GetRed(); specular[1] = c.GetGreen(); specular[2] = c.GetBlue(); } } // Ambient { mitk::ColorProperty::Pointer p; node->GetProperty(p, "material.ambientColor", renderer); if (p.IsNotNull()) { mitk::Color c = p->GetColor(); ambient[0] = c.GetRed(); ambient[1] = c.GetGreen(); ambient[2] = c.GetBlue(); } } // Diffuse { mitk::ColorProperty::Pointer p; node->GetProperty(p, "material.diffuseColor", renderer); if (p.IsNotNull()) { mitk::Color c = p->GetColor(); diffuse[0] = c.GetRed(); diffuse[1] = c.GetGreen(); diffuse[2] = c.GetBlue(); } } // Specular { mitk::ColorProperty::Pointer p; node->GetProperty(p, "material.specularColor", renderer); if (p.IsNotNull()) { mitk::Color c = p->GetColor(); specular[0] = c.GetRed(); specular[1] = c.GetGreen(); specular[2] = c.GetBlue(); } } // Ambient coeff { node->GetFloatProperty("material.ambientCoefficient", coeff_ambient, renderer); } // Diffuse coeff { node->GetFloatProperty("material.diffuseCoefficient", coeff_diffuse, renderer); } // Specular coeff { node->GetFloatProperty("material.specularCoefficient", coeff_specular, renderer); } // Specular power { node->GetFloatProperty("material.specularPower", power_specular, renderer); } property->SetAmbient(coeff_ambient); property->SetDiffuse(coeff_diffuse); property->SetSpecular(coeff_specular); property->SetSpecularPower(power_specular); property->SetAmbientColor(ambient); property->SetDiffuseColor(diffuse); property->SetSpecularColor(specular); } // Render mode { // Opacity { float opacity = 1.0f; if (node->GetOpacity(opacity, renderer)) property->SetOpacity(opacity); } // Wireframe line width { float lineWidth = 1; node->GetFloatProperty("material.wireframeLineWidth", lineWidth, renderer); property->SetLineWidth(lineWidth); } // Point size { float pointSize = 1.0f; node->GetFloatProperty("material.pointSize", pointSize, renderer); property->SetPointSize(pointSize); } // Representation { mitk::VtkRepresentationProperty::Pointer p; node->GetProperty(p, "material.representation", renderer); if (p.IsNotNull()) property->SetRepresentation(p->GetVtkRepresentation()); } // Interpolation { mitk::VtkInterpolationProperty::Pointer p; node->GetProperty(p, "material.interpolation", renderer); if (p.IsNotNull()) property->SetInterpolation(p->GetVtkInterpolation()); } } } void mitk::SurfaceVtkMapper3D::ApplyAllProperties(mitk::BaseRenderer *renderer, vtkActor * /*actor*/) { LocalStorage *ls = m_LSH.GetLocalStorage(renderer); - // Applying shading properties Superclass::ApplyColorAndOpacityProperties(renderer, ls->m_Actor); - this->ApplyShaderProperties(renderer); // VTK Properties ApplyMitkPropertiesToVtkProperty(this->GetDataNode(), ls->m_Actor->GetProperty(), renderer); mitk::TransferFunctionProperty::Pointer transferFuncProp; this->GetDataNode()->GetProperty(transferFuncProp, "Surface.TransferFunction", renderer); if (transferFuncProp.IsNotNull()) { ls->m_VtkPolyDataMapper->SetLookupTable(transferFuncProp->GetValue()->GetColorTransferFunction()); } mitk::LookupTableProperty::Pointer lookupTableProp; this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer); if (lookupTableProp.IsNotNull()) { ls->m_VtkPolyDataMapper->SetLookupTable(lookupTableProp->GetLookupTable()->GetVtkLookupTable()); } mitk::LevelWindow levelWindow; if (this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelWindow")) { ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound()); } else if (this->GetDataNode()->GetLevelWindow(levelWindow, renderer)) { ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound()); } bool scalarVisibility = false; this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility); ls->m_VtkPolyDataMapper->SetScalarVisibility((scalarVisibility ? 1 : 0)); if (scalarVisibility) { mitk::VtkScalarModeProperty *scalarMode; if (this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer)) ls->m_VtkPolyDataMapper->SetScalarMode(scalarMode->GetVtkScalarMode()); else ls->m_VtkPolyDataMapper->SetScalarModeToDefault(); bool colorMode = false; this->GetDataNode()->GetBoolProperty("color mode", colorMode); ls->m_VtkPolyDataMapper->SetColorMode((colorMode ? 1 : 0)); double scalarsMin = 0; this->GetDataNode()->GetDoubleProperty("ScalarsRangeMinimum", scalarsMin, renderer); double scalarsMax = 1.0; this->GetDataNode()->GetDoubleProperty("ScalarsRangeMaximum", scalarsMax, renderer); ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin, scalarsMax); } mitk::SmartPointerProperty::Pointer imagetextureProp = dynamic_cast(GetDataNode()->GetProperty("Surface.Texture", renderer)); if (imagetextureProp.IsNotNull()) { mitk::Image *miktTexture = dynamic_cast(imagetextureProp->GetSmartPointer().GetPointer()); vtkSmartPointer vtkTxture = vtkSmartPointer::New(); // Either select the first slice of a volume if (miktTexture->GetDimension(2) > 1) { MITK_WARN << "3D Textures are not supported by VTK and MITK. The first slice of the volume will be used instead!"; mitk::ImageSliceSelector::Pointer sliceselector = mitk::ImageSliceSelector::New(); sliceselector->SetSliceNr(0); sliceselector->SetChannelNr(0); sliceselector->SetTimeNr(0); sliceselector->SetInput(miktTexture); sliceselector->Update(); vtkTxture->SetInputData(sliceselector->GetOutput()->GetVtkImageData()); } else // or just use the 2D image { vtkTxture->SetInputData(miktTexture->GetVtkImageData()); } // pass the texture to the actor ls->m_Actor->SetTexture(vtkTxture); if (ls->m_VtkPolyDataMapper->GetInput()->GetPointData()->GetTCoords() == nullptr) { MITK_ERROR << "Surface.Texture property was set, but there are no texture coordinates. Please provide texture " "coordinates for the vtkPolyData via vtkPolyData->GetPointData()->SetTCoords()."; } // if no texture is set, this will also remove a previously used texture // and reset the actor to it's default behaviour } else { ls->m_Actor->SetTexture(0); } // deprecated settings bool deprecatedUseCellData = false; this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", deprecatedUseCellData); bool deprecatedUsePointData = false; this->GetDataNode()->GetBoolProperty("deprecated usePointDataForColouring", deprecatedUsePointData); if (deprecatedUseCellData) { ls->m_VtkPolyDataMapper->SetColorModeToDefault(); ls->m_VtkPolyDataMapper->SetScalarRange(0, 255); ls->m_VtkPolyDataMapper->ScalarVisibilityOn(); ls->m_VtkPolyDataMapper->SetScalarModeToUseCellData(); ls->m_Actor->GetProperty()->SetSpecular(1); ls->m_Actor->GetProperty()->SetSpecularPower(50); ls->m_Actor->GetProperty()->SetInterpolationToPhong(); } else if (deprecatedUsePointData) { float scalarsMin = 0; if (dynamic_cast(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != nullptr) scalarsMin = dynamic_cast(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue(); float scalarsMax = 0.1; if (dynamic_cast(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != nullptr) scalarsMax = dynamic_cast(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue(); ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin, scalarsMax); ls->m_VtkPolyDataMapper->SetColorModeToMapScalars(); ls->m_VtkPolyDataMapper->ScalarVisibilityOn(); ls->m_Actor->GetProperty()->SetSpecular(1); ls->m_Actor->GetProperty()->SetSpecularPower(50); ls->m_Actor->GetProperty()->SetInterpolationToPhong(); } int deprecatedScalarMode = VTK_COLOR_MODE_DEFAULT; if (this->GetDataNode()->GetIntProperty("deprecated scalar mode", deprecatedScalarMode, renderer)) { ls->m_VtkPolyDataMapper->SetScalarMode(deprecatedScalarMode); ls->m_VtkPolyDataMapper->ScalarVisibilityOn(); ls->m_Actor->GetProperty()->SetSpecular(1); ls->m_Actor->GetProperty()->SetSpecularPower(50); } // Check whether one or more ClippingProperty objects have been defined for // this node. Check both renderer specific and global property lists, since // properties in both should be considered. const PropertyList::PropertyMap *rendererProperties = this->GetDataNode()->GetPropertyList(renderer)->GetMap(); const PropertyList::PropertyMap *globalProperties = this->GetDataNode()->GetPropertyList(nullptr)->GetMap(); // Add clipping planes (if any) ls->m_ClippingPlaneCollection->RemoveAllItems(); PropertyList::PropertyMap::const_iterator it; for (it = rendererProperties->begin(); it != rendererProperties->end(); ++it) { this->CheckForClippingProperty(renderer, (*it).second.GetPointer()); } for (it = globalProperties->begin(); it != globalProperties->end(); ++it) { this->CheckForClippingProperty(renderer, (*it).second.GetPointer()); } if (ls->m_ClippingPlaneCollection->GetNumberOfItems() > 0) { ls->m_VtkPolyDataMapper->SetClippingPlanes(ls->m_ClippingPlaneCollection); } else { ls->m_VtkPolyDataMapper->RemoveAllClippingPlanes(); } } vtkProp *mitk::SurfaceVtkMapper3D::GetVtkProp(mitk::BaseRenderer *renderer) { LocalStorage *ls = m_LSH.GetLocalStorage(renderer); return ls->m_Actor; } void mitk::SurfaceVtkMapper3D::CheckForClippingProperty(mitk::BaseRenderer *renderer, mitk::BaseProperty *property) { LocalStorage *ls = m_LSH.GetLocalStorage(renderer); ClippingProperty *clippingProperty = dynamic_cast(property); if ((clippingProperty != nullptr) && (clippingProperty->GetClippingEnabled())) { const Point3D &origin = clippingProperty->GetOrigin(); const Vector3D &normal = clippingProperty->GetNormal(); vtkSmartPointer clippingPlane = vtkSmartPointer::New(); clippingPlane->SetOrigin(origin[0], origin[1], origin[2]); clippingPlane->SetNormal(normal[0], normal[1], normal[2]); ls->m_ClippingPlaneCollection->AddItem(clippingPlane); } } void mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite) { // Shading { node->AddProperty("material.wireframeLineWidth", mitk::FloatProperty::New(1.0f), renderer, overwrite); node->AddProperty("material.pointSize", mitk::FloatProperty::New(1.0f), renderer, overwrite); node->AddProperty("material.ambientCoefficient", mitk::FloatProperty::New(0.05f), renderer, overwrite); node->AddProperty("material.diffuseCoefficient", mitk::FloatProperty::New(0.9f), renderer, overwrite); node->AddProperty("material.specularCoefficient", mitk::FloatProperty::New(1.0f), renderer, overwrite); node->AddProperty("material.specularPower", mitk::FloatProperty::New(16.0f), renderer, overwrite); node->AddProperty("material.representation", mitk::VtkRepresentationProperty::New(), renderer, overwrite); node->AddProperty("material.interpolation", mitk::VtkInterpolationProperty::New(), renderer, overwrite); } - -// // Shaders -// IShaderRepository *shaderRepo = CoreServices::GetShaderRepository(); -// if (shaderRepo) -// { -// shaderRepo->AddDefaultProperties(node, renderer, overwrite); -// } } void mitk::SurfaceVtkMapper3D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite) { node->AddProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 1.0f), renderer, overwrite); node->AddProperty("opacity", mitk::FloatProperty::New(1.0), renderer, overwrite); mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node, renderer, overwrite); // Shading node->AddProperty("scalar visibility", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("color mode", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("scalar mode", mitk::VtkScalarModeProperty::New(), renderer, overwrite); mitk::Surface::Pointer surface = dynamic_cast(node->GetData()); if (surface.IsNotNull()) { if ((surface->GetVtkPolyData() != 0) && (surface->GetVtkPolyData()->GetPointData() != nullptr) && (surface->GetVtkPolyData()->GetPointData()->GetScalars() != 0)) { node->AddProperty("scalar visibility", mitk::BoolProperty::New(true), renderer, overwrite); node->AddProperty("color mode", mitk::BoolProperty::New(true), renderer, overwrite); } } // Backface culling node->AddProperty("Backface Culling", mitk::BoolProperty::New(false), renderer, overwrite); node->AddProperty("Depth Sorting", mitk::BoolProperty::New(false), renderer, overwrite); mitk::CoreServices::GetPropertyDescriptions()->AddDescription( "Depth Sorting", "Enables correct rendering for transparent objects by ordering polygons according to the distance " "to the camera. It is not recommended to enable this property for large surfaces (rendering might " "be slow)."); Superclass::SetDefaultProperties(node, renderer, overwrite); } diff --git a/Modules/Core/src/Rendering/mitkVtkMapper.cpp b/Modules/Core/src/Rendering/mitkVtkMapper.cpp index aad99fa7f3..6dd8eb2cba 100644 --- a/Modules/Core/src/Rendering/mitkVtkMapper.cpp +++ b/Modules/Core/src/Rendering/mitkVtkMapper.cpp @@ -1,144 +1,140 @@ /*=================================================================== 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 "mitkVtkMapper.h" mitk::VtkMapper::VtkMapper() { } mitk::VtkMapper::~VtkMapper() { } void mitk::VtkMapper::MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type) { switch (type) { case mitk::VtkPropRenderer::Opaque: this->MitkRenderOpaqueGeometry(renderer); break; case mitk::VtkPropRenderer::Translucent: this->MitkRenderTranslucentGeometry(renderer); break; case mitk::VtkPropRenderer::Overlay: this->MitkRenderOverlay(renderer); break; case mitk::VtkPropRenderer::Volumetric: this->MitkRenderVolumetricGeometry(renderer); break; } } bool mitk::VtkMapper::IsVtkBased() const { return true; } void mitk::VtkMapper::MitkRenderOverlay(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (this->GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer()); } } void mitk::VtkMapper::MitkRenderOpaqueGeometry(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (this->GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderOpaqueGeometry(renderer->GetVtkRenderer()); } } void mitk::VtkMapper::MitkRenderTranslucentGeometry(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (this->GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer()); } } -void mitk::VtkMapper::ApplyShaderProperties(mitk::BaseRenderer *) -{ -} - void mitk::VtkMapper::MitkRenderVolumetricGeometry(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderVolumetricGeometry(renderer->GetVtkRenderer()); } } bool mitk::VtkMapper::HasVtkProp(const vtkProp *prop, BaseRenderer *renderer) { vtkProp *myProp = this->GetVtkProp(renderer); // TODO: check if myProp is a vtkAssembly and if so, check if prop is contained in its leafs return (prop == myProp); } void mitk::VtkMapper::SetVtkMapperImmediateModeRendering(vtkMapper *mapper) { if (mapper) mapper->SetImmediateModeRendering(mitk::VtkPropRenderer::useImmediateModeRendering()); } void mitk::VtkMapper::UpdateVtkTransform(mitk::BaseRenderer *renderer) { vtkLinearTransform *vtktransform = GetDataNode()->GetVtkTransform(this->GetTimestep()); vtkProp3D *prop = dynamic_cast(GetVtkProp(renderer)); if (prop) prop->SetUserTransform(vtktransform); } void mitk::VtkMapper::ApplyColorAndOpacityProperties(BaseRenderer *renderer, vtkActor *actor) { float rgba[4] = {1.0f, 1.0f, 1.0f, 1.0f}; DataNode *node = GetDataNode(); // check for color prop and use it for rendering if it exists node->GetColor(rgba, renderer, "color"); // check for opacity prop and use it for rendering if it exists node->GetOpacity(rgba[3], renderer, "opacity"); double drgba[4] = {rgba[0], rgba[1], rgba[2], rgba[3]}; actor->GetProperty()->SetColor(drgba); actor->GetProperty()->SetOpacity(drgba[3]); } diff --git a/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping.xml b/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping.xml deleted file mode 100644 index da3da5b910..0000000000 --- a/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping.xml +++ /dev/null @@ -1,56 +0,0 @@ - - - - - varying vec3 positionWorld; - varying vec3 color; - - void main(void) - { - color = gl_Color.rgb; - positionWorld = vec3(gl_Vertex); - gl_Position = ftransform(); - } - - - - uniform vec4 slicingPlane; - uniform float fiberThickness; - uniform int fiberFadingON; - uniform float fiberOpacity; - - varying vec3 positionWorld; - varying vec3 color; - - void main(void) - { - float r1 = dot(positionWorld, slicingPlane.xyz) - slicingPlane.w; - - if ( abs(r1) > fiberThickness ) - discard; - - if (fiberFadingON != 0) - { - float x = (r1+fiberThickness)/(fiberThickness*2.0); - x = 1.0 - x; - gl_FragColor = vec4(color*x, fiberOpacity); - }else{ - gl_FragColor = vec4(color, fiberOpacity); - } - - } - - - - - - - - - diff --git a/Modules/DiffusionImaging/FiberTracking/files.cmake b/Modules/DiffusionImaging/FiberTracking/files.cmake index 92512547a1..4649890eb3 100644 --- a/Modules/DiffusionImaging/FiberTracking/files.cmake +++ b/Modules/DiffusionImaging/FiberTracking/files.cmake @@ -1,94 +1,91 @@ set(CPP_FILES mitkFiberTrackingModuleActivator.cpp ## IO datastructures IODataStructures/FiberBundle/mitkFiberBundle.cpp IODataStructures/FiberBundle/mitkTrackvis.cpp IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp IODataStructures/mitkTractographyForest.cpp # Interactions # Tractography Algorithms/GibbsTracking/mitkParticleGrid.cpp Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.cpp Algorithms/GibbsTracking/mitkEnergyComputer.cpp Algorithms/GibbsTracking/mitkGibbsEnergyComputer.cpp Algorithms/GibbsTracking/mitkFiberBuilder.cpp Algorithms/GibbsTracking/mitkSphereInterpolator.cpp Algorithms/itkStreamlineTrackingFilter.cpp Algorithms/TrackingHandlers/mitkTrackingDataHandler.cpp Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.cpp Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.cpp Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp ) set(H_FILES # DataStructures -> FiberBundle IODataStructures/FiberBundle/mitkFiberBundle.h IODataStructures/FiberBundle/mitkTrackvis.h IODataStructures/mitkFiberfoxParameters.h IODataStructures/mitkTractographyForest.h # Algorithms Algorithms/itkTractDensityImageFilter.h Algorithms/itkTractsToFiberEndingsImageFilter.h Algorithms/itkTractsToRgbaImageFilter.h Algorithms/itkTractsToVectorImageFilter.h Algorithms/itkEvaluateDirectionImagesFilter.h Algorithms/itkEvaluateTractogramDirectionsFilter.h Algorithms/itkFiberCurvatureFilter.h # Tractography Algorithms/TrackingHandlers/mitkTrackingDataHandler.h Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h Algorithms/itkGibbsTrackingFilter.h Algorithms/itkStochasticTractographyFilter.h Algorithms/GibbsTracking/mitkParticle.h Algorithms/GibbsTracking/mitkParticleGrid.h Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.h Algorithms/GibbsTracking/mitkSimpSamp.h Algorithms/GibbsTracking/mitkEnergyComputer.h Algorithms/GibbsTracking/mitkGibbsEnergyComputer.h Algorithms/GibbsTracking/mitkSphereInterpolator.h Algorithms/GibbsTracking/mitkFiberBuilder.h Algorithms/itkStreamlineTrackingFilter.h # Fiberfox Fiberfox/itkFibersFromPlanarFiguresFilter.h Fiberfox/itkTractsToDWIImageFilter.h Fiberfox/itkKspaceImageFilter.h Fiberfox/itkDftImageFilter.h Fiberfox/itkFieldmapGeneratorFilter.h Fiberfox/SignalModels/mitkDiffusionSignalModel.h Fiberfox/SignalModels/mitkTensorModel.h Fiberfox/SignalModels/mitkBallModel.h Fiberfox/SignalModels/mitkDotModel.h Fiberfox/SignalModels/mitkAstroStickModel.h Fiberfox/SignalModels/mitkStickModel.h Fiberfox/SignalModels/mitkRawShModel.h Fiberfox/SignalModels/mitkDiffusionNoiseModel.h Fiberfox/SignalModels/mitkRicianNoiseModel.h Fiberfox/SignalModels/mitkChiSquareNoiseModel.h Fiberfox/Sequences/mitkAcquisitionType.h Fiberfox/Sequences/mitkSingleShotEpi.h Fiberfox/Sequences/mitkCartesianReadout.h ) set(RESOURCE_FILES # Binary directory resources FiberTrackingLUTBaryCoords.bin FiberTrackingLUTIndices.bin - - # Shaders - Shaders/mitkShaderFiberClipping.xml ) diff --git a/Modules/VtkShaders/src/mitkVtkShaderProgram.cpp b/Modules/VtkShaders/src/mitkVtkShaderProgram.cpp deleted file mode 100644 index 218ed05f38..0000000000 --- a/Modules/VtkShaders/src/mitkVtkShaderProgram.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/*=================================================================== - -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 "mitkVtkShaderProgram.h" - -#include "vtkShader2.h" - -mitk::VtkShaderProgram::VtkShaderProgram() : m_VtkShaderProgram(nullptr) -{ -} - -mitk::VtkShaderProgram::~VtkShaderProgram() -{ -} - -void mitk::VtkShaderProgram::Activate() -{ - if (m_VtkShaderProgram) - { - m_VtkShaderProgram->Use(); - } -} - -void mitk::VtkShaderProgram::Deactivate() -{ - if (m_VtkShaderProgram) - { - m_VtkShaderProgram->Restore(); - } -} - -void mitk::VtkShaderProgram::SetVtkShaderProgram(vtkSmartPointer p) -{ - m_VtkShaderProgram = p; -} - -vtkSmartPointer mitk::VtkShaderProgram::GetVtkShaderProgram() const -{ - return m_VtkShaderProgram; -} - -itk::TimeStamp &mitk::VtkShaderProgram::GetShaderTimestampUpdate() -{ - return m_ShaderTimestampUpdate; -} diff --git a/Modules/VtkShaders/src/mitkVtkShaderRepository.cpp b/Modules/VtkShaders/src/mitkVtkShaderRepository.cpp deleted file mode 100644 index ac71216d6f..0000000000 --- a/Modules/VtkShaders/src/mitkVtkShaderRepository.cpp +++ /dev/null @@ -1,644 +0,0 @@ -/*=================================================================== - -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. - -===================================================================*/ - -#define SR_INFO MITK_INFO("shader.repository") -#define SR_WARN MITK_WARN("shader.repository") -#define SR_ERROR MITK_ERROR("shader.repository") - -#include "mitkVtkShaderRepository.h" -#include "mitkDataNode.h" -#include "mitkProperties.h" -#include "mitkShaderProperty.h" -#include "mitkVtkShaderProgram.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -int mitk::VtkShaderRepository::shaderId = 0; -const bool mitk::VtkShaderRepository::debug = false; - -mitk::VtkShaderRepository::VtkShaderRepository() -{ - LoadShaders(); -} - -mitk::VtkShaderRepository::~VtkShaderRepository() -{ -} - -mitk::IShaderRepository::ShaderProgram::Pointer mitk::VtkShaderRepository::CreateShaderProgram() -{ - mitk::IShaderRepository::ShaderProgram::Pointer shaderProg = (mitk::VtkShaderProgram::New()).GetPointer(); - return shaderProg; -} - -void mitk::VtkShaderRepository::LoadShaders() -{ - itk::Directory::Pointer dir = itk::Directory::New(); - - std::string dirPath = "./vtk_shader"; - - if (dir->Load(dirPath.c_str())) - { - int n = dir->GetNumberOfFiles(); - for (int r = 0; r < n; r++) - { - const char *filename = dir->GetFile(r); - - std::string extension = itksys::SystemTools::GetFilenameExtension(filename); - - if (extension.compare(".xml") == 0) - { - Shader::Pointer element = Shader::New(); - - element->SetName(itksys::SystemTools::GetFilenameWithoutExtension(filename)); - std::string filePath = dirPath + std::string("/") + element->GetName() + std::string(".xml"); - - SR_INFO(debug) << "found shader '" << element->GetName() << "'"; - - std::ifstream fileStream(filePath.c_str()); - element->LoadXmlShader(fileStream); - - shaders.push_back(element); - } - } - } -} - -mitk::VtkShaderRepository::Shader::Pointer mitk::VtkShaderRepository::GetShaderImpl(const std::string &name) const -{ - std::list::const_iterator i = shaders.begin(); - - while (i != shaders.end()) - { - if ((*i)->GetName() == name) - return (*i); - - i++; - } - - return Shader::Pointer(); -} - -int mitk::VtkShaderRepository::LoadShader(std::istream &stream, const std::string &filename) -{ - Shader::Pointer element = Shader::New(); - element->SetName(filename); - element->SetId(shaderId++); - element->LoadXmlShader(stream); - shaders.push_back(element); - SR_INFO(debug) << "found shader '" << element->GetName() << "'"; - return element->GetId(); -} - -bool mitk::VtkShaderRepository::UnloadShader(int id) -{ - for (std::list::iterator i = shaders.begin(); i != shaders.end(); ++i) - { - if ((*i)->GetId() == id) - { - shaders.erase(i); - return true; - } - } - return false; -} - -mitk::VtkShaderRepository::Shader::Shader() -{ -} - -mitk::VtkShaderRepository::Shader::~Shader() -{ -} - -void mitk::VtkShaderRepository::Shader::SetVertexShaderCode(const std::string &code) -{ - this->m_VertexShaderCode = code; -} - -std::string mitk::VtkShaderRepository::Shader::GetVertexShaderCode() const -{ - return this->m_VertexShaderCode; -} - -void mitk::VtkShaderRepository::Shader::SetFragmentShaderCode(const std::string &code) -{ - this->m_FragmentShaderCode = code; -} - -std::string mitk::VtkShaderRepository::Shader::GetFragmentShaderCode() const -{ - return this->m_FragmentShaderCode; -} - -void mitk::VtkShaderRepository::Shader::SetGeometryShaderCode(const std::string &code) -{ - this->m_GeometryShaderCode = code; -} - -std::string mitk::VtkShaderRepository::Shader::GetGeometryShaderCode() const -{ - return this->m_GeometryShaderCode; -} - -std::list mitk::VtkShaderRepository::Shader::GetUniforms() const -{ - return uniforms; -} - -void mitk::VtkShaderRepository::Shader::LoadXmlShader(std::istream &stream) -{ - std::string content; - content.reserve(2048); - char buffer[2048]; - while (stream.read(buffer, sizeof(buffer))) - { - content.append(buffer, sizeof(buffer)); - } - content.append(buffer, static_cast(stream.gcount())); - - if (content.empty()) - return; - - this->SetMaterialXml(content); - - vtkXMLMaterialParser *parser = vtkXMLMaterialParser::New(); - vtkXMLMaterial *material = vtkXMLMaterial::New(); - parser->SetMaterial(material); - parser->Parse(content.c_str()); - parser->Delete(); - if (material == nullptr) - return; - - // Vertexshader uniforms - { - vtkXMLShader *s = material->GetVertexShader(); - if (s) - { - SetVertexShaderCode(s->GetCode()); - vtkXMLDataElement *x = s->GetRootElement(); - int n = x->GetNumberOfNestedElements(); - for (int r = 0; r < n; r++) - { - vtkXMLDataElement *y = x->GetNestedElement(r); - if (strcmp(y->GetName(), "ApplicationUniform") == 0 || strcmp(y->GetName(), "Uniform") == 0) - { - Uniform::Pointer element = Uniform::New(); - element->LoadFromXML(y); - uniforms.push_back(element); - } - } - } - } - - // Fragmentshader uniforms - { - vtkXMLShader *s = material->GetFragmentShader(); - if (s) - { - SetFragmentShaderCode(s->GetCode()); - vtkXMLDataElement *x = s->GetRootElement(); - int n = x->GetNumberOfNestedElements(); - for (int r = 0; r < n; r++) - { - vtkXMLDataElement *y = x->GetNestedElement(r); - if (strcmp(y->GetName(), "ApplicationUniform") == 0 || strcmp(y->GetName(), "Uniform") == 0) - { - Uniform::Pointer element = Uniform::New(); - element->LoadFromXML(y); - uniforms.push_back(element); - } - } - } - } - - // Geometryshader uniforms - { - vtkXMLShader *s = material->GetGeometryShader(); - if (s) - { - SetGeometryShaderCode(s->GetCode()); - vtkXMLDataElement *x = s->GetRootElement(); - int n = x->GetNumberOfNestedElements(); - for (int r = 0; r < n; r++) - { - vtkXMLDataElement *y = x->GetNestedElement(r); - if (strcmp(y->GetName(), "ApplicationUniform") == 0 || strcmp(y->GetName(), "Uniform") == 0) - { - Uniform::Pointer element = Uniform::New(); - element->LoadFromXML(y); - uniforms.push_back(element); - } - } - } - } - material->Delete(); -} - -mitk::VtkShaderRepository::Shader::Uniform::Uniform() -{ -} - -mitk::VtkShaderRepository::Shader::Uniform::~Uniform() -{ -} - -void mitk::VtkShaderRepository::Shader::Uniform::LoadFromXML(vtkXMLDataElement *y) -{ - // MITK_INFO << "found uniform '" << y->GetAttribute("name") << "' type=" << y->GetAttribute("type");// << " default=" - // << y->GetAttribute("value"); - - name = y->GetAttribute("name"); - - const char *sType = y->GetAttribute("type"); - - if (!strcmp(sType, "float")) - type = glsl_float; - else if (!strcmp(sType, "vec2")) - type = glsl_vec2; - else if (!strcmp(sType, "vec3")) - type = glsl_vec3; - else if (!strcmp(sType, "vec4")) - type = glsl_vec4; - else if (!strcmp(sType, "int")) - type = glsl_int; - else if (!strcmp(sType, "ivec2")) - type = glsl_ivec2; - else if (!strcmp(sType, "ivec3")) - type = glsl_ivec3; - else if (!strcmp(sType, "ivec4")) - type = glsl_ivec4; - else - { - type = glsl_none; - SR_WARN << "unknown type for uniform '" << name << "'"; - } - - defaultFloat[0] = defaultFloat[1] = defaultFloat[2] = defaultFloat[3] = 0; - - const char *sDefault = y->GetAttribute("value"); - - if (sDefault) - { - switch (type) - { - case glsl_float: - sscanf(sDefault, "%f", &defaultFloat[0]); - break; - - case glsl_vec2: - sscanf(sDefault, "%f %f", &defaultFloat[0], &defaultFloat[1]); - break; - - case glsl_vec3: - sscanf(sDefault, "%f %f %f", &defaultFloat[0], &defaultFloat[1], &defaultFloat[2]); - break; - - case glsl_vec4: - sscanf(sDefault, "%f %f %f %f", &defaultFloat[0], &defaultFloat[1], &defaultFloat[2], &defaultFloat[3]); - break; - - case glsl_int: - sscanf(sDefault, "%d", &defaultInt[0]); - break; - - case glsl_ivec2: - sscanf(sDefault, "%d %d", &defaultInt[0], &defaultInt[1]); - break; - - case glsl_ivec3: - sscanf(sDefault, "%d %d %d", &defaultInt[0], &defaultInt[1], &defaultInt[2]); - break; - - case glsl_ivec4: - sscanf(sDefault, "%d %d %d %d", &defaultInt[0], &defaultInt[1], &defaultInt[2], &defaultInt[3]); - break; - - case glsl_none: - break; - } - } -} - -void mitk::VtkShaderRepository::AddDefaultProperties(mitk::DataNode *node, - mitk::BaseRenderer *renderer, - bool overwrite) const -{ - node->AddProperty("shader", mitk::ShaderProperty::New(), renderer, overwrite); - - std::list::const_iterator i = shaders.begin(); - - while (i != shaders.end()) - { - std::list uniforms = (*i)->GetUniforms(); - - std::string shaderName = (*i)->GetName(); - - std::list::const_iterator j = uniforms.begin(); - - while (j != uniforms.end()) - { - std::string propertyName = "shader." + shaderName + "." + (*j)->name; - - switch ((*j)->type) - { - case Shader::Uniform::glsl_float: - node->AddProperty(propertyName.c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_vec2: - node->AddProperty( - (propertyName + ".x").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); - node->AddProperty( - (propertyName + ".y").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[1]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_vec3: - node->AddProperty( - (propertyName + ".x").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); - node->AddProperty( - (propertyName + ".y").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[1]), renderer, overwrite); - node->AddProperty( - (propertyName + ".z").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[2]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_vec4: - node->AddProperty( - (propertyName + ".x").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); - node->AddProperty( - (propertyName + ".y").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[1]), renderer, overwrite); - node->AddProperty( - (propertyName + ".z").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[2]), renderer, overwrite); - node->AddProperty( - (propertyName + ".w").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[3]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_int: - node->AddProperty(propertyName.c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_ivec2: - node->AddProperty( - (propertyName + ".x").c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); - node->AddProperty( - (propertyName + ".y").c_str(), mitk::IntProperty::New((*j)->defaultInt[1]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_ivec3: - node->AddProperty( - (propertyName + ".x").c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); - node->AddProperty( - (propertyName + ".y").c_str(), mitk::IntProperty::New((*j)->defaultInt[1]), renderer, overwrite); - node->AddProperty( - (propertyName + ".z").c_str(), mitk::IntProperty::New((*j)->defaultInt[2]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_ivec4: - node->AddProperty( - (propertyName + ".x").c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); - node->AddProperty( - (propertyName + ".y").c_str(), mitk::IntProperty::New((*j)->defaultInt[1]), renderer, overwrite); - node->AddProperty( - (propertyName + ".z").c_str(), mitk::IntProperty::New((*j)->defaultInt[2]), renderer, overwrite); - node->AddProperty( - (propertyName + ".w").c_str(), mitk::IntProperty::New((*j)->defaultInt[3]), renderer, overwrite); - break; - - case Shader::Uniform::glsl_none: - break; - } - - j++; - } - - i++; - } -} - -std::list mitk::VtkShaderRepository::GetShaders() const -{ - std::list result; - for (std::list::const_iterator i = shaders.begin(); i != shaders.end(); ++i) - { - result.push_back(i->GetPointer()); - } - return result; -} - -mitk::IShaderRepository::Shader::Pointer mitk::VtkShaderRepository::GetShader(const std::string &name) const -{ - for (std::list::const_iterator i = shaders.begin(); i != shaders.end(); ++i) - { - if ((*i)->GetName() == name) - return i->GetPointer(); - } - return IShaderRepository::Shader::Pointer(); -} - -mitk::IShaderRepository::Shader::Pointer mitk::VtkShaderRepository::GetShader(int id) const -{ - for (std::list::const_iterator i = shaders.begin(); i != shaders.end(); ++i) - { - if ((*i)->GetId() == id) - return i->GetPointer(); - } - return IShaderRepository::Shader::Pointer(); -} - -void mitk::VtkShaderRepository::UpdateShaderProgram(ShaderProgram *shaderProgram, - DataNode *node, - BaseRenderer *renderer) const -{ - VtkShaderProgram *mitkVtkShaderProgram = dynamic_cast(shaderProgram); - mitk::ShaderProperty *sep = dynamic_cast(node->GetProperty("shader", renderer)); - if (!sep) - { - mitkVtkShaderProgram->SetVtkShaderProgram(0); - return; - } - - Shader::Pointer s = GetShaderImpl(sep->GetValueAsString()); - - // Need update pipeline mode - if (sep->GetMTime() > mitkVtkShaderProgram->GetShaderTimestampUpdate().GetMTime()) - { - if (s.IsNull()) - { - mitkVtkShaderProgram->SetVtkShaderProgram(0); - mitkVtkShaderProgram->GetShaderTimestampUpdate().Modified(); - return; - } - - vtkSmartPointer program = vtkSmartPointer::New(); -#if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) - program->SetContext(dynamic_cast(renderer->GetRenderWindow())); -#else - program->SetContext(renderer->GetRenderWindow()); -#endif - // The vertext shader - vtkShader2 *shader = vtkShader2::New(); - shader->SetType(VTK_SHADER_TYPE_VERTEX); - shader->SetSourceCode(s->GetVertexShaderCode().c_str()); -#if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) - shader->SetContext(dynamic_cast(renderer->GetRenderWindow())); -#else - shader->SetContext(renderer->GetRenderWindow()); -#endif - program->GetShaders()->AddItem(shader); - shader->Delete(); - - // The fragment shader - shader = vtkShader2::New(); - shader->SetType(VTK_SHADER_TYPE_FRAGMENT); - shader->SetSourceCode(s->GetFragmentShaderCode().c_str()); -#if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) - shader->SetContext(dynamic_cast(renderer->GetRenderWindow())); -#else - shader->SetContext(renderer->GetRenderWindow()); -#endif - program->GetShaders()->AddItem(shader); - shader->Delete(); - - if (s->GetGeometryShaderCode().size() > 0) - { - // The Geometry shader - shader = vtkShader2::New(); - shader->SetType(VTK_SHADER_TYPE_GEOMETRY); - shader->SetSourceCode(s->GetGeometryShaderCode().c_str()); -#if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) - shader->SetContext(dynamic_cast(renderer->GetRenderWindow())); -#else - shader->SetContext(renderer->GetRenderWindow()); -#endif - program->GetShaders()->AddItem(shader); - shader->Delete(); - } - - program->Build(); - - mitkVtkShaderProgram->SetVtkShaderProgram(program); - - mitkVtkShaderProgram->GetShaderTimestampUpdate().Modified(); - } - - if (s.IsNull()) - return; - - // update uniforms - vtkShaderProgram2 *p = mitkVtkShaderProgram->GetVtkShaderProgram(); - - if (!p) - return; - - std::list::const_iterator j = s->uniforms.begin(); - - while (j != s->uniforms.end()) - { - std::string propertyName = "shader." + s->GetName() + "." + (*j)->name; - - // MITK_INFO << "querying property: " << propertyName; - - // mitk::BaseProperty *p = node->GetProperty( propertyName.c_str(), renderer ); - - // if( p && p->GetMTime() > MTime.GetMTime() ) - { - float fval[4]; - int ival[4]; - - // MITK_INFO << "copying property " << propertyName << " ->->- " << (*j)->name << " type=" << (*j)->type ; - - switch ((*j)->type) - { - case Shader::Uniform::glsl_float: - node->GetFloatProperty(propertyName.c_str(), fval[0], renderer); - p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 1, fval); - break; - - case Shader::Uniform::glsl_vec2: - node->GetFloatProperty((propertyName + ".x").c_str(), fval[0], renderer); - node->GetFloatProperty((propertyName + ".y").c_str(), fval[1], renderer); - p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 2, fval); - break; - - case Shader::Uniform::glsl_vec3: - node->GetFloatProperty((propertyName + ".x").c_str(), fval[0], renderer); - node->GetFloatProperty((propertyName + ".y").c_str(), fval[1], renderer); - node->GetFloatProperty((propertyName + ".z").c_str(), fval[2], renderer); - // p->SetUniform3f( (*j)->name.c_str(), fval ); - p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 3, fval); - break; - - case Shader::Uniform::glsl_vec4: - node->GetFloatProperty((propertyName + ".x").c_str(), fval[0], renderer); - node->GetFloatProperty((propertyName + ".y").c_str(), fval[1], renderer); - node->GetFloatProperty((propertyName + ".z").c_str(), fval[2], renderer); - node->GetFloatProperty((propertyName + ".w").c_str(), fval[3], renderer); - p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 4, fval); - break; - - case Shader::Uniform::glsl_int: - node->GetIntProperty(propertyName.c_str(), ival[0], renderer); - p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 1, ival); - break; - - case Shader::Uniform::glsl_ivec2: - node->GetIntProperty((propertyName + ".x").c_str(), ival[0], renderer); - node->GetIntProperty((propertyName + ".y").c_str(), ival[1], renderer); - p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 2, ival); - break; - - case Shader::Uniform::glsl_ivec3: - node->GetIntProperty((propertyName + ".x").c_str(), ival[0], renderer); - node->GetIntProperty((propertyName + ".y").c_str(), ival[1], renderer); - node->GetIntProperty((propertyName + ".z").c_str(), ival[2], renderer); - // p->SetUniform3f( (*j)->name.c_str(), fval ); - p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 3, ival); - break; - - case Shader::Uniform::glsl_ivec4: - node->GetIntProperty((propertyName + ".x").c_str(), ival[0], renderer); - node->GetIntProperty((propertyName + ".y").c_str(), ival[1], renderer); - node->GetIntProperty((propertyName + ".z").c_str(), ival[2], renderer); - node->GetIntProperty((propertyName + ".w").c_str(), ival[3], renderer); - p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 4, ival); - break; - - case Shader::Uniform::glsl_none: - break; - } - } - - j++; - } - - return; -} diff --git a/Modules/VtkShaders/src/mitkVtkShadersActivator.cpp b/Modules/VtkShaders/src/mitkVtkShadersActivator.cpp deleted file mode 100644 index 7d3951823a..0000000000 --- a/Modules/VtkShaders/src/mitkVtkShadersActivator.cpp +++ /dev/null @@ -1,48 +0,0 @@ -/*=================================================================== - -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 -#include -#include -#include -#include -#include -#include -#include - -namespace mitk -{ - class VtkShadersActivator : public us::ModuleActivator - { - public: - VtkShadersActivator() {} - ~VtkShadersActivator() {} - void Load(us::ModuleContext *context) override - { - m_VtkShaderRepository.reset(new VtkShaderRepository); - context->RegisterService(m_VtkShaderRepository.get()); - } - - void Unload(us::ModuleContext *) override { m_VtkShaderRepository.reset(nullptr); } - private: - VtkShadersActivator(const VtkShadersActivator &); - VtkShadersActivator &operator=(const VtkShadersActivator &); - - std::unique_ptr m_VtkShaderRepository; - }; -} - -US_EXPORT_MODULE_ACTIVATOR(mitk::VtkShadersActivator)