// VISU OBJECT : interactive object for VISU entities implementation
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// $Header$
#include "VISU_MeshAct.h"
-#include "SALOME_PassThroughFilter.h"
+#include "VTKViewer_PassThroughFilter.h"
+
+#include <vtkObjectFactory.h>
+#include <vtkRenderer.h>
+#include <vtkTexture.h>
#include <vtkFeatureEdges.h>
#include <vtkDataSetMapper.h>
#include <vtkDataSet.h>
+#include <vtkMatrix4x4.h>
+#include <vtkMapperCollection.h>
vtkStandardNewMacro(VISU_MeshAct);
VISU_MeshAct::VISU_MeshAct(){
+
+ vtkMatrix4x4 *m;
+ m = vtkMatrix4x4::New();
+
mySurfaceActor = VISU_Actor::New();
mySurfaceActor->SetParent(this);
mySurfaceActor->GetProperty()->FrontfaceCullingOff();
mySurfaceActor->GetProperty()->BackfaceCullingOff();
+ mySurfaceActor->SetUserMatrix(m);
mySurfaceActor->SetRepresentation(2); //SURFACE
-
+
myEdgeActor = VISU_Actor::New();
myEdgeActor->SetParent(this);
myEdgeActor->PickableOff();
myEdgeActor->GetProperty()->FrontfaceCullingOff();
myEdgeActor->GetProperty()->BackfaceCullingOff();
+ myEdgeActor->SetUserMatrix(m);
myEdgeActor->SetRepresentation(1); //WIREFRAME
-
+
myNodeActor = VISU_Actor::New();
myNodeActor->SetParent(this);
myNodeActor->PickableOff();
myNodeActor->GetProperty()->SetPointSize(SALOME_POINT_SIZE);
myNodeActor->GetProperty()->FrontfaceCullingOff();
myNodeActor->GetProperty()->BackfaceCullingOff();
+ myNodeActor->SetUserMatrix(m);
myNodeActor->SetRepresentation(0); //POINT
+ m->Delete();
SetRepresentation(2); //SURFACE
}
}
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){
+void VISU_MeshAct::SetPrs3d(VISU::Prs3d_i* thePrs3d){
if(thePrs3d){
VISU_Actor::SetPrs3d(thePrs3d);
mySurfaceActor->SetPrs3d(thePrs3d);
}
void VISU_MeshAct::AddToRender(vtkRenderer* theRenderer){
- theRenderer->AddActor(mySurfaceActor);
+ VISU_Actor::AddToRender(theRenderer);
theRenderer->AddActor(myEdgeActor);
- theRenderer->AddActor(myNodeActor);
}
void VISU_MeshAct::RemoveFromRender(vtkRenderer* theRenderer){
- theRenderer->RemoveActor(mySurfaceActor);
+ VISU_Actor::RemoveFromRender(theRenderer);
theRenderer->RemoveActor(myEdgeActor);
- theRenderer->RemoveActor(myNodeActor);
}
-void VISU_MeshAct::SetPipeLine(VISU_PipeLine* thePipeLine) throw(std::runtime_error&){
+void VISU_MeshAct::SetPipeLine(VISU_PipeLine* thePipeLine) {
VISU_Actor::SetPipeLine(thePipeLine);
mySurfaceActor->SetPipeLine(thePipeLine);
myEdgeActor->SetPipeLine(thePipeLine);
myNodeActor->SetPipeLine(thePipeLine);
}
-void VISU_MeshAct::SetTransform(SALOME_Transform* theTransform){
+void VISU_MeshAct::SetTransform(VTKViewer_Transform* theTransform){
+ VISU_Actor::SetTransform(theTransform);
mySurfaceActor->SetTransform(theTransform);
myEdgeActor->SetTransform(theTransform);
myNodeActor->SetTransform(theTransform);
myNodeActor->SetShrinkable(theIsShrinkable);
}
-vtkProperty* VISU_MeshAct::GetProperty(){
- mySurfaceActor->GetProperty();
-}
+void VISU_MeshAct::SetShrinkFactor(float theValue){
+ VISU_Actor::SetShrinkFactor(theValue);
+ mySurfaceActor->SetShrinkFactor(theValue);
+ myEdgeActor->SetShrinkFactor(theValue);
+}
-void VISU_MeshAct::SetProperty(vtkProperty* theProperty){
+vtkProperty* VISU_MeshAct::GetSurfaceProperty(){
+ return mySurfaceActor->GetProperty();
+}
+
+void VISU_MeshAct::SetSurfaceProperty(vtkProperty* theProperty){
mySurfaceActor->SetProperty(theProperty);
}
-vtkProperty* VISU_MeshAct::GetEdgeProperty(){
- myEdgeActor->GetProperty();
-}
+vtkProperty* VISU_MeshAct::GetEdgeProperty(){
+ return myEdgeActor->GetProperty();
+}
-void VISU_MeshAct::SetEdgeProperty(vtkProperty* theProperty){
+void VISU_MeshAct::SetEdgeProperty(vtkProperty* theProperty){
myEdgeActor->SetProperty(theProperty);
}
-vtkProperty* VISU_MeshAct::GetNodeProperty(){
- myNodeActor->GetProperty();
-}
+vtkProperty* VISU_MeshAct::GetNodeProperty(){
+ return myNodeActor->GetProperty();
+}
-void VISU_MeshAct::SetNodeProperty(vtkProperty* theProperty){
+void VISU_MeshAct::SetNodeProperty(vtkProperty* theProperty){
myNodeActor->SetProperty(theProperty);
}
+void VISU_MeshAct::SetOpacity(float theValue){
+ GetSurfaceProperty()->SetOpacity(theValue);
+}
+
+float VISU_MeshAct::GetOpacity(){
+ return GetSurfaceProperty()->GetOpacity();
+}
+
void VISU_MeshAct::SetLineWidth(float theLineWidth){
GetEdgeProperty()->SetLineWidth(theLineWidth);
}
return GetEdgeProperty()->GetLineWidth();
}
-void VISU_MeshAct::SetShrink(float theFactor){
- VISU_Actor::SetShrink(theFactor);
- mySurfaceActor->SetShrink(theFactor);
- myEdgeActor->SetShrink(theFactor);
- SetRepresentation(GetRepresentation());
+void VISU_MeshAct::SetShrink(){
+ if(myRepresentation == VTK_POINTS)
+ return;
+ VISU_Actor::SetShrink();
+ mySurfaceActor->SetShrink();
+ myEdgeActor->SetShrink();
+ //SetRepresentation(GetRepresentation());
}
void VISU_MeshAct::UnShrink(){
VISU_Actor::UnShrink();
mySurfaceActor->UnShrink();
myEdgeActor->UnShrink();
- SetRepresentation(GetRepresentation());
+ //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();
- switch(theMode){
- case 0: //POINTS
+ myEdgeActor->PickableOff();
+ myNodeActor->PickableOff();
+ switch (theMode) {
+ case VTK_POINTS:
myNodeActor->VisibilityOn();
+ myNodeActor->PickableOn();
break;
- case 1: //WIREFRAME
+ case VTK_WIREFRAME:
myEdgeActor->VisibilityOn();
myEdgeActor->SetRepresentation(1);
+ myEdgeActor->PickableOn();
break;
- case 2: //SURFACE
+ case VTK_SURFACE:
mySurfaceActor->VisibilityOn();
break;
case 3: //INSIDEFRAME
myEdgeActor->VisibilityOn();
myEdgeActor->SetRepresentation(3);
+ myEdgeActor->PickableOn();
break;
case 4: //SURFACEFRAME
myEdgeActor->VisibilityOn();
mySurfaceActor->VisibilityOn();
break;
}
+ if (myRepresentation == VTK_POINTS)
+ UnShrink();
}
void VISU_MeshAct::SetVisibility(int theMode){
mySurfaceActor->VisibilityOff();
}
}
+
+// From vtkLODActor
+void VISU_MeshAct::Render(vtkRenderer *ren, vtkMapper *vtkNotUsed(m))
+{
+ 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;
+ }
+ }
+ }
+ }
+
+ switch(GetRepresentation()){
+ case 0: //POINTS
+ myNodeActor->GetProperty()->Render(this, ren);
+ break;
+ case 1: //WIREFRAME
+ //PAL5268: myEdgeActor->GetProperty()->Render(this, ren);
+ break;
+ case 2: //SURFACE
+ mySurfaceActor->GetProperty()->Render(this, ren);
+ break;
+ case 3: //INSIDEFRAME
+ //PAL5268: myEdgeActor->GetProperty()->Render(this, ren);
+ break;
+ case 4: //SURFACEFRAME
+ //PAL5268: myEdgeActor->GetProperty()->Render(this, ren);
+ mySurfaceActor->GetProperty()->Render(this, ren);
+ break;
+ }
+
+ // 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 = myEdgeActor->GetUserMatrix();
+ this->GetMatrix(matrix);
+ matrix = mySurfaceActor->GetUserMatrix();
+ break;
+ }
+ this->GetMatrix(matrix);
+
+ switch(GetRepresentation()){
+ case 0: //POINTS
+ myNodeActor->Render(ren,bestMapper);
+ break;
+ case 1: //WIREFRAME
+ //PAL5268: myEdgeActor->Render(ren,bestMapper);
+ break;
+ case 2: //SURFACE
+ mySurfaceActor->Render(ren,bestMapper);
+ break;
+ case 3: //INSIDEFRAME
+ //PAL5268: myEdgeActor->Render(ren,bestMapper);
+ break;
+ case 4: //SURFACEFRAME
+ //PAL5268: myEdgeActor->Render(ren,bestMapper);
+ mySurfaceActor->Render(ren,bestMapper);
+ break;
+ }
+
+ this->EstimatedRenderTime = bestMapper->GetTimeToDraw();
+}
+
+// From vtkLODActor
+void VISU_MeshAct::Modified()
+{
+ myNodeActor->Modified();
+ //PAL5268: myEdgeActor->Modified();
+ mySurfaceActor->Modified();
+ this->vtkActor::Modified();
+}
