//
//
// File : VISU_MeshAct.cxx
-// Author : Laurent CORNABE with the help of Nicolas REJNERI
+// Author :
// Module : VISU
// $Header$
#include "VISU_MeshAct.h"
-#include "VTKViewer_PassThroughFilter.h"
+#include "SVTK_DeviceActor.h"
#include <vtkObjectFactory.h>
#include <vtkRenderer.h>
#include <vtkMatrix4x4.h>
#include <vtkMapperCollection.h>
+
+//----------------------------------------------------------------------------
vtkStandardNewMacro(VISU_MeshAct);
-VISU_MeshAct::VISU_MeshAct(){
+//----------------------------------------------------------------------------
+VISU_MeshAct
+::VISU_MeshAct()
+{
vtkMatrix4x4 *m;
m = vtkMatrix4x4::New();
- mySurfaceActor = VISU_Actor::New();
- mySurfaceActor->GetProperty()->FrontfaceCullingOff();
- mySurfaceActor->GetProperty()->BackfaceCullingOff();
+ mySurfaceActor = SVTK_DeviceActor::New();
+ mySurfaceActor->SetRepresentation(SVTK::Representation::Surface);
mySurfaceActor->SetUserMatrix(m);
- mySurfaceActor->SetRepresentation(2); //SURFACE
- myEdgeActor = VISU_Actor::New();
- myEdgeActor->PickableOff();
- myEdgeActor->GetProperty()->FrontfaceCullingOff();
- myEdgeActor->GetProperty()->BackfaceCullingOff();
+ myEdgeActor = SVTK_DeviceActor::New();
+ myEdgeActor->SetRepresentation(SVTK::Representation::Wireframe);
myEdgeActor->SetUserMatrix(m);
- myEdgeActor->SetRepresentation(1); //WIREFRAME
- myNodeActor = VISU_Actor::New();
- myNodeActor->PickableOff();
- myNodeActor->GetProperty()->SetPointSize(SALOME_POINT_SIZE);
- myNodeActor->GetProperty()->FrontfaceCullingOff();
- myNodeActor->GetProperty()->BackfaceCullingOff();
+ myNodeActor = SVTK_DeviceActor::New();
+ myNodeActor->SetRepresentation(SVTK::Representation::Points);
myNodeActor->SetUserMatrix(m);
- myNodeActor->SetRepresentation(0); //POINT
m->Delete();
- SetRepresentation(2); //SURFACE
+ SetRepresentation(SVTK::Representation::Surface);
}
-VISU_MeshAct::~VISU_MeshAct(){
+VISU_MeshAct
+::~VISU_MeshAct()
+{
mySurfaceActor->Delete();
myEdgeActor->Delete();
myNodeActor->Delete();
}
-void VISU_MeshAct::setIO(const Handle(SALOME_InteractiveObject)& theIO){
- VISU_Actor::setIO(theIO);
- mySurfaceActor->setIO(theIO);
- myEdgeActor->setIO(theIO);
- myNodeActor->setIO(theIO);
-}
-void VISU_MeshAct::SetPrs3d(VISU::Prs3d_i* thePrs3d){
- if(thePrs3d){
- VISU_Actor::SetPrs3d(thePrs3d);
- mySurfaceActor->SetPrs3d(thePrs3d);
- myEdgeActor->SetPrs3d(thePrs3d);
- myNodeActor->SetPrs3d(thePrs3d);
- }
-}
+//----------------------------------------------------------------------------
+void
+VISU_MeshAct
+::SetMapperInput(vtkDataSet* theDataSet)
+{
+ Superclass::SetMapperInput(theDataSet);
-void VISU_MeshAct::AddToRender(vtkRenderer* theRenderer){
- VISU_Actor::AddToRender(theRenderer);
- //theRenderer->AddActor(myEdgeActor);
+ mySurfaceActor->SetInput(theDataSet);
+ myEdgeActor->SetInput(theDataSet);
+ myNodeActor->SetInput(theDataSet);
}
-void VISU_MeshAct::RemoveFromRender(vtkRenderer* theRenderer){
- VISU_Actor::RemoveFromRender(theRenderer);
- //theRenderer->RemoveActor(myEdgeActor);
-}
-void VISU_MeshAct::SetPipeLine(VISU_PipeLine* thePipeLine) {
- VISU_Actor::SetPipeLine(thePipeLine);
- mySurfaceActor->SetPipeLine(thePipeLine);
- myEdgeActor->SetPipeLine(thePipeLine);
- myNodeActor->SetPipeLine(thePipeLine);
-}
+//----------------------------------------------------------------------------
+void
+VISU_MeshAct
+::SetTransform(VTKViewer_Transform* theTransform)
+{
+ Superclass::SetTransform(theTransform);
-void VISU_MeshAct::SetTransform(VTKViewer_Transform* theTransform){
- VISU_Actor::SetTransform(theTransform);
mySurfaceActor->SetTransform(theTransform);
myEdgeActor->SetTransform(theTransform);
myNodeActor->SetTransform(theTransform);
}
-void VISU_MeshAct::SetShrinkable(bool theIsShrinkable){
- VISU_Actor::SetShrinkable(theIsShrinkable);
+
+//----------------------------------------------------------------------------
+void
+VISU_MeshAct
+::SetShrinkable(bool theIsShrinkable)
+{
+ Superclass::SetShrinkable(theIsShrinkable);
+
mySurfaceActor->SetShrinkable(theIsShrinkable);
myEdgeActor->SetShrinkable(theIsShrinkable);
- myNodeActor->SetShrinkable(theIsShrinkable);
}
-void VISU_MeshAct::SetShrinkFactor(float theValue){
- VISU_Actor::SetShrinkFactor(theValue);
+void
+VISU_MeshAct
+::SetShrinkFactor(float theValue)
+{
+ Superclass::SetShrinkFactor(theValue);
+
mySurfaceActor->SetShrinkFactor(theValue);
myEdgeActor->SetShrinkFactor(theValue);
}
-vtkProperty* VISU_MeshAct::GetSurfaceProperty(){
- return mySurfaceActor->GetProperty();
-}
-void VISU_MeshAct::SetSurfaceProperty(vtkProperty* theProperty){
- mySurfaceActor->SetProperty(theProperty);
+//----------------------------------------------------------------------------
+vtkProperty*
+VISU_MeshAct
+::GetSurfaceProperty()
+{
+ return mySurfaceActor->GetProperty();
}
-vtkProperty* VISU_MeshAct::GetEdgeProperty(){
+vtkProperty*
+VISU_MeshAct
+::GetEdgeProperty()
+{
return myEdgeActor->GetProperty();
}
-void VISU_MeshAct::SetEdgeProperty(vtkProperty* theProperty){
- myEdgeActor->SetProperty(theProperty);
-}
-
-vtkProperty* VISU_MeshAct::GetNodeProperty(){
+vtkProperty*
+VISU_MeshAct
+::GetNodeProperty()
+{
return myNodeActor->GetProperty();
}
-void VISU_MeshAct::SetNodeProperty(vtkProperty* theProperty){
- myNodeActor->SetProperty(theProperty);
-}
-
-void VISU_MeshAct::SetOpacity(float theValue){
+//----------------------------------------------------------------------------
+void
+VISU_MeshAct
+::SetOpacity(float theValue)
+{
GetSurfaceProperty()->SetOpacity(theValue);
}
-float VISU_MeshAct::GetOpacity(){
+float
+VISU_MeshAct
+::GetOpacity()
+{
return GetSurfaceProperty()->GetOpacity();
}
-void VISU_MeshAct::SetLineWidth(float theLineWidth){
+//----------------------------------------------------------------------------
+void
+VISU_MeshAct
+::SetLineWidth(float theLineWidth)
+{
GetEdgeProperty()->SetLineWidth(theLineWidth);
}
-float VISU_MeshAct::GetLineWidth(){
+float
+VISU_MeshAct::GetLineWidth()
+{
return GetEdgeProperty()->GetLineWidth();
}
-void VISU_MeshAct::SetShrink(){
+//----------------------------------------------------------------------------
+void
+VISU_MeshAct
+::SetShrink()
+{
if(myRepresentation == VTK_POINTS)
return;
- VISU_Actor::SetShrink();
+
+ Superclass::SetShrink();
+
mySurfaceActor->SetShrink();
myEdgeActor->SetShrink();
- //SetRepresentation(GetRepresentation());
}
-void VISU_MeshAct::UnShrink(){
- VISU_Actor::UnShrink();
+void
+VISU_MeshAct
+::UnShrink()
+{
+ Superclass::UnShrink();
+
mySurfaceActor->UnShrink();
myEdgeActor->UnShrink();
- //SetRepresentation(GetRepresentation());
}
-void VISU_MeshAct::SetRepresentation(int theMode)
+
+//----------------------------------------------------------------------------
+void
+VISU_MeshAct
+::SetRepresentation(int theMode)
{
- SALOME_Actor::SetRepresentation(theMode);
-
- if (!GetVisibility()) return; // Fix IPAL9555
-
- mySurfaceActor->VisibilityOff();
- myEdgeActor->VisibilityOff();
- myNodeActor->VisibilityOff();
- myEdgeActor->PickableOff();
- myNodeActor->PickableOff();
- switch (theMode) {
- case VTK_POINTS:
- myNodeActor->VisibilityOn();
- myNodeActor->PickableOn();
- break;
- case VTK_WIREFRAME:
- myEdgeActor->VisibilityOn();
- myEdgeActor->SetRepresentation(1);
- myEdgeActor->PickableOn();
- break;
- case VTK_SURFACE:
- mySurfaceActor->VisibilityOn();
- break;
- case 3: //INSIDEFRAME
- myEdgeActor->VisibilityOn();
- myEdgeActor->SetRepresentation(3);
- myEdgeActor->PickableOn();
- break;
- case 4: //SURFACEFRAME
- myEdgeActor->VisibilityOn();
- myEdgeActor->SetRepresentation(1);
- mySurfaceActor->VisibilityOn();
- break;
- }
- if (myRepresentation == VTK_POINTS)
- UnShrink();
-}
+ Superclass::SetRepresentation(theMode);
-void VISU_MeshAct::SetVisibility(int theMode){
- VISU_Actor::SetVisibility(theMode);
- if(GetVisibility())
- SetRepresentation(GetRepresentation());
- else{
- myNodeActor->VisibilityOff();
- myEdgeActor->VisibilityOff();
- mySurfaceActor->VisibilityOff();
- }
+ if(theMode == SVTK::Representation::Insideframe)
+ myEdgeActor->SetRepresentation(SVTK::Representation::Insideframe);
+ else
+ myEdgeActor->SetRepresentation(SVTK::Representation::Wireframe);
}
-// From vtkLODActor
-void VISU_MeshAct::Render(vtkRenderer *ren, vtkMapper *vtkNotUsed(m))
+//----------------------------------------------------------------------------
+int
+VISU_MeshAct
+::RenderOpaqueGeometry(vtkViewport *ren)
{
- float myTime, bestTime, tempTime;
- vtkMatrix4x4 *matrix;
- vtkMapper *mapper, *bestMapper;
-
- if (this->Mapper == NULL)
- {
- vtkErrorMacro("No mapper for actor.");
- return;
- }
-
- // first time through create lods if non have been added
- if (this->LODMappers->GetNumberOfItems() == 0)
- {
- this->CreateOwnLODs();
- }
-
- // If the actor has changed or the primary mapper has changed ...
- // Is this the correct test?
- if (this->MediumMapper)
- {
- if (this->GetMTime() > this->BuildTime ||
- this->Mapper->GetMTime() > this->BuildTime)
- {
- this->UpdateOwnLODs();
- }
- }
-
- // figure out how much time we have to render
- myTime = this->AllocatedRenderTime;
-
- // Figure out which resolution to use
- // none is a valid resolution. Do we want to have a lowest:
- // bbox, single point, ...
- // There is no order to the list, so it is assumed that mappers that take
- // longer to render are better quality.
- // Timings might become out of date, but we rely on
-
- bestMapper = this->Mapper;
- bestTime = bestMapper->GetTimeToDraw();
- if (bestTime > myTime)
- {
- this->LODMappers->InitTraversal();
- while ((mapper = this->LODMappers->GetNextItem()) != NULL &&
- bestTime != 0.0)
- {
- tempTime = mapper->GetTimeToDraw();
-
- // If the LOD has never been rendered, select it!
- if (tempTime == 0.0)
- {
- bestMapper = mapper;
- bestTime = 0.0;
- }
- else
- {
- if (bestTime > myTime && tempTime < bestTime)
- {
- bestMapper = mapper;
- bestTime = tempTime;
- }
- if (tempTime > bestTime && tempTime < myTime)
- {
- bestMapper = mapper;
- bestTime = tempTime;
- }
- }
- }
- }
-
+ using namespace SVTK::Representation;
switch(GetRepresentation()){
- case 0: //POINTS
- myNodeActor->GetProperty()->Render(this, ren);
+ case Points :
+ myNodeActor->RenderOpaqueGeometry(ren);
break;
- case 1: //WIREFRAME
- //PAL5268:
- myEdgeActor->GetProperty()->Render(this, ren);
+ case Wireframe :
+ case Insideframe :
+ myEdgeActor->RenderOpaqueGeometry(ren);
break;
- case 2: //SURFACE
- mySurfaceActor->GetProperty()->Render(this, ren);
+ case Surface :
+ mySurfaceActor->RenderOpaqueGeometry(ren);
break;
- case 3: //INSIDEFRAME
- //PAL5268:
- myEdgeActor->GetProperty()->Render(this, ren);
- break;
- case 4: //SURFACEFRAME
- //PAL5268:
- mySurfaceActor->GetProperty()->Render(this, ren);
- myEdgeActor->GetProperty()->Render(this, ren);
+ case Surfaceframe :
+ mySurfaceActor->RenderOpaqueGeometry(ren);
+ myEdgeActor->RenderOpaqueGeometry(ren);
break;
}
+ return 1;
+}
- // render the texture
- if (this->Texture)
- {
- this->Texture->Render(ren);
- }
-
- switch(GetRepresentation()){
- case 0: //POINTS
- matrix = myNodeActor->GetUserMatrix();
- break;
- case 1: //WIREFRAME
- matrix = myEdgeActor->GetUserMatrix();
- break;
- case 2: //SURFACE
- matrix = mySurfaceActor->GetUserMatrix();
- break;
- case 3: //INSIDEFRAME
- matrix = myEdgeActor->GetUserMatrix();
- break;
- case 4: //SURFACEFRAME
- matrix = mySurfaceActor->GetUserMatrix();
- this->GetMatrix(matrix);
- matrix = myEdgeActor->GetUserMatrix();
- break;
- }
- this->GetMatrix(matrix);
-
+int
+VISU_MeshAct
+::RenderTranslucentGeometry(vtkViewport *ren)
+{
+ using namespace SVTK::Representation;
switch(GetRepresentation()){
- case 0: //POINTS
- myNodeActor->Render(ren,bestMapper);
+ case Points :
+ myNodeActor->RenderTranslucentGeometry(ren);
break;
- case 1: //WIREFRAME
- //PAL5268:
- myEdgeActor->Render(ren,bestMapper);
+ case Wireframe :
+ case Insideframe :
+ myEdgeActor->RenderTranslucentGeometry(ren);
break;
- case 2: //SURFACE
- mySurfaceActor->Render(ren,bestMapper);
+ case Surface :
+ mySurfaceActor->RenderTranslucentGeometry(ren);
break;
- case 3: //INSIDEFRAME
- //PAL5268:
- myEdgeActor->Render(ren,bestMapper);
- break;
- case 4: //SURFACEFRAME
- //PAL5268:
- mySurfaceActor->Render(ren,bestMapper);
- myEdgeActor->Render(ren,bestMapper);
+ case Surfaceframe :
+ mySurfaceActor->RenderTranslucentGeometry(ren);
+ myEdgeActor->RenderTranslucentGeometry(ren);
break;
}
-
- this->EstimatedRenderTime = bestMapper->GetTimeToDraw();
-}
-
-// From vtkLODActor
-void VISU_MeshAct::Modified()
-{
- myNodeActor->Modified();
- //PAL5268:
- myEdgeActor->Modified();
- mySurfaceActor->Modified();
- this->vtkActor::Modified();
+ return 1;
}
