ENH:Sped up depth peeling by adding HasTranslucentPolygonalGeometry() and...

ENH:Sped up depth peeling by adding HasTranslucentPolygonalGeometry() and fixed it with volumes by splitting RenderTranslucentGeometry() into RenderTranslucentPolygonalGeometry() and RenderVolumetricGeometry() in all vtkProp(s)

Common/vtkProp.h

@@ -119,19 +119,34 @@ public:
   // WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
   // DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS
   // All concrete subclasses must be able to render themselves.
-  // There are three key render methods in vtk and they correspond
-  // to three different points in the rendering cycle. Any given
+  // There are four key render methods in vtk and they correspond
+  // to four different points in the rendering cycle. Any given
   // prop may implement one or more of these methods. 
   // The first method is intended for rendering all opaque geometry. The
-  // second method is intended for rendering all translucent geometry. Most
-  // volume rendering mappers draw their results during this second method.
+  // second method is intended for rendering all translucent polygonal
+  // geometry. The third one is intended for rendering all translucent
+  // volumetric geometry. Most of the volume rendering mappers draw their
+  // results during this thrid method.
   // The last method is to render any 2D annotation or overlays.
   // Each of these methods return an integer value indicating
   // whether or not this render method was applied to this data. 
   virtual int RenderOpaqueGeometry(      vtkViewport *) { return 0; }
-  virtual int RenderTranslucentGeometry( vtkViewport *) { return 0; }
+  virtual int RenderTranslucentPolygonalGeometry( vtkViewport *) { return 0; }
+  virtual int RenderVolumetricGeometry( vtkViewport *) { return 0; }
   virtual int RenderOverlay(             vtkViewport *) { return 0; }
 
+  // Description:
+  // WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
+  // DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS
+  // Does this prop have some translucent polygonal geometry?
+  // This method is called during the rendering process to know if there is
+  // some translucent polygonal geometry. A simple prop that has some
+  // translucent polygonal geometry will return true. A composite prop (like
+  // vtkAssembly) that has at least one sub-prop that has some translucent
+  // polygonal geometry will return true.
+  // Default implementation return false.
+  virtual int HasTranslucentPolygonalGeometry() { return 0; }
+  
   // Description:
   // WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
   // Release any graphics resources that are being consumed by this actor.

Filtering/vtkActor2D.cxx

@@ -19,7 +19,7 @@
 #include "vtkPropCollection.h"
 #include "vtkObjectFactory.h"
 
-vtkCxxRevisionMacro(vtkActor2D, "1.4");
+vtkCxxRevisionMacro(vtkActor2D, "1.5");
 vtkStandardNewMacro(vtkActor2D);
 
 vtkCxxSetObjectMacro(vtkActor2D,Property, vtkProperty2D);
@@ -132,11 +132,11 @@ int vtkActor2D::RenderOpaqueGeometry(vtkViewport* viewport)
   return 1;
 }
 
-//----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 // Renders an actor2D's property and then it's mapper.
-int vtkActor2D::RenderTranslucentGeometry(vtkViewport* viewport)
+int vtkActor2D::RenderTranslucentPolygonalGeometry(vtkViewport* viewport)
 {
-  vtkDebugMacro(<< "vtkActor2D::RenderTranslucentGeometry");
+  vtkDebugMacro(<< "vtkActor2D::RenderTranslucentPolygonalGeometry");
 
   if (!this->Property)
     {
@@ -153,11 +153,27 @@ int vtkActor2D::RenderTranslucentGeometry(vtkViewport* viewport)
     return 0;
     }
 
-  this->Mapper->RenderTranslucentGeometry(viewport, this);
+  this->Mapper->RenderTranslucentPolygonalGeometry(viewport, this);
 
   return 1;
 }
 
+//-----------------------------------------------------------------------------
+int vtkActor2D::HasTranslucentPolygonalGeometry()
+{
+  int result;
+  if(this->Mapper)
+    {
+    result=this->Mapper->HasTranslucentPolygonalGeometry();
+    }
+  else
+    {
+    vtkErrorMacro(<< "vtkActor2D::HasTranslucentPolygonalGeometry - No mapper set");
+    result=0;
+    }
+  return result;
+}
+  
 //----------------------------------------------------------------------------
 unsigned long int vtkActor2D::GetMTime()
 {

Filtering/vtkActor2D.h

@@ -48,8 +48,12 @@ public:
   // Support the standard render methods.
   int RenderOverlay(vtkViewport *viewport);
   int RenderOpaqueGeometry(vtkViewport *viewport);
-  int RenderTranslucentGeometry(vtkViewport *viewport);
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport *viewport);
 
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
+  
   // Description:
   // Set/Get the vtkMapper2D which defines the data to be drawn.
   virtual void SetMapper(vtkMapper2D *mapper);

Filtering/vtkMapper2D.h

@@ -36,7 +36,8 @@ public:
   
   virtual void RenderOverlay(vtkViewport*, vtkActor2D*) {};
   virtual void RenderOpaqueGeometry(vtkViewport*, vtkActor2D*) {};
-  virtual void RenderTranslucentGeometry(vtkViewport*, vtkActor2D*) {};
+  virtual void RenderTranslucentPolygonalGeometry(vtkViewport*, vtkActor2D*) {}
+  virtual int HasTranslucentPolygonalGeometry() { return 0; }
 
 protected:
   vtkMapper2D() {};

Filtering/vtkPropAssembly.cxx

@@ -23,7 +23,7 @@
 #include "vtkPropCollection.h"
 #include "vtkViewport.h"
 
-vtkCxxRevisionMacro(vtkPropAssembly, "1.2");
+vtkCxxRevisionMacro(vtkPropAssembly, "1.3");
 vtkStandardNewMacro(vtkPropAssembly);
 
 // Construct object with no children.
@@ -66,7 +66,7 @@ vtkPropCollection *vtkPropAssembly::GetParts()
 }
 
 // Render this assembly and all of its Parts. The rendering process is recursive.
-int vtkPropAssembly::RenderTranslucentGeometry(vtkViewport *ren)
+int vtkPropAssembly::RenderTranslucentPolygonalGeometry(vtkViewport *ren)
 {
   vtkProp *prop;
   vtkAssemblyPath *path;
@@ -85,7 +85,57 @@ int vtkPropAssembly::RenderTranslucentGeometry(vtkViewport *ren)
       {
       prop->SetAllocatedRenderTime(fraction, ren);
       prop->PokeMatrix(path->GetLastNode()->GetMatrix());
-      renderedSomething += prop->RenderTranslucentGeometry(ren);
+      renderedSomething += prop->RenderTranslucentPolygonalGeometry(ren);
+      prop->PokeMatrix(NULL);
+      }
+    }
+
+  return renderedSomething;
+}
+
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkPropAssembly::HasTranslucentPolygonalGeometry()
+{
+  vtkProp *prop;
+  vtkAssemblyPath *path;
+  int result=0;
+  
+  // render the Paths
+  vtkCollectionSimpleIterator sit;
+  for ( this->Paths->InitTraversal(sit); !result && (path = this->Paths->GetNextPath(sit)); )
+    {
+    prop = path->GetLastNode()->GetViewProp();
+    if ( prop->GetVisibility() )
+      {
+      result=prop->HasTranslucentPolygonalGeometry();
+      }
+    }
+  return result;
+}
+
+
+// Render this assembly and all of its Parts. The rendering process is recursive.
+int vtkPropAssembly::RenderVolumetricGeometry(vtkViewport *ren)
+{
+  vtkProp *prop;
+  vtkAssemblyPath *path;
+  double fraction;
+  int renderedSomething=0;
+
+  fraction = this->AllocatedRenderTime / 
+             (double)this->Parts->GetNumberOfItems();
+  
+  // render the Paths
+  vtkCollectionSimpleIterator sit;
+  for ( this->Paths->InitTraversal(sit); (path = this->Paths->GetNextPath(sit)); )
+    {
+    prop = path->GetLastNode()->GetViewProp();
+    if ( prop->GetVisibility() )
+      {
+      prop->SetAllocatedRenderTime(fraction, ren);
+      prop->PokeMatrix(path->GetLastNode()->GetMatrix());
+      renderedSomething += prop->RenderVolumetricGeometry(ren);
       prop->PokeMatrix(NULL);
       }
     }

Filtering/vtkPropAssembly.h

@@ -70,9 +70,14 @@ public:
   // recursive. The parts of each assembly are rendered only if the
   // visibility for the prop is turned on.
   int RenderOpaqueGeometry(vtkViewport *ren);
-  int RenderTranslucentGeometry(vtkViewport *ren);
-  int RenderOverlay(vtkViewport *);
+  virtual int RenderTranslucentPolygonalGeometry( vtkViewport *ren);
+  virtual int RenderVolumetricGeometry( vtkViewport *ren);
+  int RenderOverlay(vtkViewport *ren);
 
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
+  
   // Description:
   // Release any graphics resources that are being consumed by this actor.
   // The parameter window could be used to determine which graphic

Hybrid/vtkAnnotatedCubeActor.cxx

@@ -30,7 +30,7 @@
 #include "vtkTransformFilter.h"
 #include "vtkVectorText.h"
 
-vtkCxxRevisionMacro(vtkAnnotatedCubeActor, "1.3");
+vtkCxxRevisionMacro(vtkAnnotatedCubeActor, "1.4");
 vtkStandardNewMacro(vtkAnnotatedCubeActor);
 
 vtkAnnotatedCubeActor::vtkAnnotatedCubeActor()
@@ -257,33 +257,63 @@ int vtkAnnotatedCubeActor::RenderOpaqueGeometry(vtkViewport *vp)
   return renderedSomething;
 }
 
-int vtkAnnotatedCubeActor::RenderTranslucentGeometry(vtkViewport *vp)
+//-----------------------------------------------------------------------------
+int vtkAnnotatedCubeActor::RenderTranslucentPolygonalGeometry(vtkViewport *vp)
 {
   this->UpdateProps();
   int renderedSomething = 0;
 
   if ( this->Cube )
     {
-    renderedSomething += this->CubeActor->RenderTranslucentGeometry( vp );
+    renderedSomething += this->CubeActor->RenderTranslucentPolygonalGeometry( vp );
     }
   if ( this->FaceText )
     {
-    renderedSomething += this->XPlusFaceActor->RenderTranslucentGeometry( vp );
-    renderedSomething += this->XMinusFaceActor->RenderTranslucentGeometry( vp );
-    renderedSomething += this->YPlusFaceActor->RenderTranslucentGeometry( vp );
-    renderedSomething += this->YMinusFaceActor->RenderTranslucentGeometry( vp );
-    renderedSomething += this->ZPlusFaceActor->RenderTranslucentGeometry( vp );
-    renderedSomething += this->ZMinusFaceActor->RenderTranslucentGeometry( vp );
+    renderedSomething += this->XPlusFaceActor->RenderTranslucentPolygonalGeometry( vp );
+    renderedSomething += this->XMinusFaceActor->RenderTranslucentPolygonalGeometry( vp );
+    renderedSomething += this->YPlusFaceActor->RenderTranslucentPolygonalGeometry( vp );
+    renderedSomething += this->YMinusFaceActor->RenderTranslucentPolygonalGeometry( vp );
+    renderedSomething += this->ZPlusFaceActor->RenderTranslucentPolygonalGeometry( vp );
+    renderedSomething += this->ZMinusFaceActor->RenderTranslucentPolygonalGeometry( vp );
     }
   if ( this->TextEdges )
     {
-    renderedSomething += this->TextEdgesActor->RenderTranslucentGeometry( vp );
+    renderedSomething += this->TextEdgesActor->RenderTranslucentPolygonalGeometry( vp );
     }
 
   renderedSomething = (renderedSomething > 0)?(1):(0);
   return renderedSomething;
 }
 
+//-----------------------------------------------------------------------------
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkAnnotatedCubeActor::HasTranslucentPolygonalGeometry()
+{
+  this->UpdateProps();
+  int result=0;
+
+  if ( this->Cube )
+    {
+    result |= this->CubeActor->HasTranslucentPolygonalGeometry();
+    }
+  if ( this->FaceText )
+    {
+    result |= this->XPlusFaceActor->HasTranslucentPolygonalGeometry();
+    result |= this->XMinusFaceActor->HasTranslucentPolygonalGeometry();
+    result |= this->YPlusFaceActor->HasTranslucentPolygonalGeometry();
+    result |= this->YMinusFaceActor->HasTranslucentPolygonalGeometry();
+    result |= this->ZPlusFaceActor->HasTranslucentPolygonalGeometry();
+    result |= this->ZMinusFaceActor->HasTranslucentPolygonalGeometry();
+    }
+  if ( this->TextEdges )
+    {
+    result |= this->TextEdgesActor->HasTranslucentPolygonalGeometry();
+    }
+  return result;
+}
+
+//-----------------------------------------------------------------------------
 void vtkAnnotatedCubeActor::ReleaseGraphicsResources(vtkWindow *win)
 {
   this->CubeActor->ReleaseGraphicsResources( win );

Hybrid/vtkAnnotatedCubeActor.h

@@ -65,8 +65,12 @@ public:
   // Description:
   // Support the standard render methods.
   virtual int RenderOpaqueGeometry(vtkViewport *viewport);
-  virtual int RenderTranslucentGeometry(vtkViewport *viewport);
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport *viewport);
 
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
+  
   // Description:
   // Shallow copy of an axes actor. Overloads the virtual vtkProp method.
   void ShallowCopy(vtkProp *prop);

Hybrid/vtkAxesActor.cxx

@@ -31,7 +31,7 @@
 #include "vtkTextProperty.h"
 #include "vtkTransform.h"
 
-vtkCxxRevisionMacro(vtkAxesActor, "1.4");
+vtkCxxRevisionMacro(vtkAxesActor, "1.5");
 vtkStandardNewMacro(vtkAxesActor);
 
 vtkCxxSetObjectMacro( vtkAxesActor, UserDefinedTip, vtkPolyData );
@@ -236,31 +236,59 @@ int vtkAxesActor::RenderOpaqueGeometry(vtkViewport *vp)
   return renderedSomething;
 }
 
-int vtkAxesActor::RenderTranslucentGeometry(vtkViewport *vp)
+//-----------------------------------------------------------------------------
+int vtkAxesActor::RenderTranslucentPolygonalGeometry(vtkViewport *vp)
 {
   int renderedSomething = 0;
 
   this->UpdateProps();
 
-  renderedSomething += this->XAxisShaft->RenderTranslucentGeometry( vp );
-  renderedSomething += this->YAxisShaft->RenderTranslucentGeometry( vp );
-  renderedSomething += this->ZAxisShaft->RenderTranslucentGeometry( vp );
+  renderedSomething += this->XAxisShaft->RenderTranslucentPolygonalGeometry( vp );
+  renderedSomething += this->YAxisShaft->RenderTranslucentPolygonalGeometry( vp );
+  renderedSomething += this->ZAxisShaft->RenderTranslucentPolygonalGeometry( vp );
 
-  renderedSomething += this->XAxisTip->RenderTranslucentGeometry( vp );
-  renderedSomething += this->YAxisTip->RenderTranslucentGeometry( vp );
-  renderedSomething += this->ZAxisTip->RenderTranslucentGeometry( vp );
+  renderedSomething += this->XAxisTip->RenderTranslucentPolygonalGeometry( vp );
+  renderedSomething += this->YAxisTip->RenderTranslucentPolygonalGeometry( vp );
+  renderedSomething += this->ZAxisTip->RenderTranslucentPolygonalGeometry( vp );
 
   if ( this->AxisLabels )
     {
-    renderedSomething += this->XAxisLabel->RenderTranslucentGeometry( vp );
-    renderedSomething += this->YAxisLabel->RenderTranslucentGeometry( vp );
-    renderedSomething += this->ZAxisLabel->RenderTranslucentGeometry( vp );
+    renderedSomething += this->XAxisLabel->RenderTranslucentPolygonalGeometry( vp );
+    renderedSomething += this->YAxisLabel->RenderTranslucentPolygonalGeometry( vp );
+    renderedSomething += this->ZAxisLabel->RenderTranslucentPolygonalGeometry( vp );
     }
 
   renderedSomething = (renderedSomething > 0)?(1):(0);
   return renderedSomething;
 }
 
+//-----------------------------------------------------------------------------
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkAxesActor::HasTranslucentPolygonalGeometry()
+{
+  int result = 0;
+
+  this->UpdateProps();
+
+  result |= this->XAxisShaft->HasTranslucentPolygonalGeometry();
+  result |= this->YAxisShaft->HasTranslucentPolygonalGeometry();
+  result |= this->ZAxisShaft->HasTranslucentPolygonalGeometry();
+
+  result |= this->XAxisTip->HasTranslucentPolygonalGeometry();
+  result |= this->YAxisTip->HasTranslucentPolygonalGeometry();
+  result |= this->ZAxisTip->HasTranslucentPolygonalGeometry();
+
+  if ( this->AxisLabels )
+    {
+    result |= this->XAxisLabel->HasTranslucentPolygonalGeometry();
+    result |= this->YAxisLabel->HasTranslucentPolygonalGeometry();
+    result |= this->ZAxisLabel->HasTranslucentPolygonalGeometry();
+    }
+  return result;
+}
+
+//-----------------------------------------------------------------------------
 int vtkAxesActor::RenderOverlay(vtkViewport *vp)
 {
   int renderedSomething = 0;

Hybrid/vtkAxesActor.h

@@ -74,9 +74,13 @@ public:
   // Description:
   // Support the standard render methods.
   virtual int RenderOpaqueGeometry(vtkViewport *viewport);
-  virtual int RenderTranslucentGeometry(vtkViewport *viewport);
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport *viewport);
   virtual int RenderOverlay(vtkViewport *viewport);
 
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
+  
   // Description:
   // Shallow copy of an axes actor. Overloads the virtual vtkProp method.
   void ShallowCopy(vtkProp *prop);

Hybrid/vtkCaptionActor2D.cxx

@@ -32,7 +32,7 @@
 #include "vtkTextProperty.h"
 #include "vtkViewport.h"
 
-vtkCxxRevisionMacro(vtkCaptionActor2D, "1.34");
+vtkCxxRevisionMacro(vtkCaptionActor2D, "1.35");
 vtkStandardNewMacro(vtkCaptionActor2D);
 
 vtkCxxSetObjectMacro(vtkCaptionActor2D,LeaderGlyph,vtkPolyData);
@@ -458,6 +458,14 @@ int vtkCaptionActor2D::RenderOpaqueGeometry(vtkViewport *viewport)
   return renderedSomething;
 }
 
+//-----------------------------------------------------------------------------
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkCaptionActor2D::HasTranslucentPolygonalGeometry()
+{
+  return 0;
+}
+
 //----------------------------------------------------------------------------
 void vtkCaptionActor2D::PrintSelf(ostream& os, vtkIndent indent)
 {

Hybrid/vtkCaptionActor2D.h

@@ -163,8 +163,12 @@ public:
   // DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS.
   // Draw the legend box to the screen.
   int RenderOpaqueGeometry(vtkViewport* viewport);
-  int RenderTranslucentGeometry(vtkViewport* ) {return 0;}
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport* ) {return 0;}
   int RenderOverlay(vtkViewport* viewport);
+  
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
 //ETX
 
 protected:

Hybrid/vtkCornerAnnotation.cxx

@@ -27,7 +27,7 @@
 
 //----------------------------------------------------------------------------
 vtkStandardNewMacro(vtkCornerAnnotation);
-vtkCxxRevisionMacro(vtkCornerAnnotation, "1.14");
+vtkCxxRevisionMacro(vtkCornerAnnotation, "1.15");
 
 vtkSetObjectImplementationMacro(vtkCornerAnnotation,ImageActor,vtkImageActor);
 vtkSetObjectImplementationMacro(vtkCornerAnnotation,WindowLevel,
@@ -597,6 +597,14 @@ int vtkCornerAnnotation::RenderOpaqueGeometry(vtkViewport *viewport)
   return 1;
 }
 
+//-----------------------------------------------------------------------------
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkCornerAnnotation::HasTranslucentPolygonalGeometry()
+{
+  return 0;
+}
+
 //----------------------------------------------------------------------------
 void vtkCornerAnnotation::SetTextActorsPosition(int vsize[2])
 {

Hybrid/vtkCornerAnnotation.h

@@ -44,9 +44,13 @@ public:
   // Description:
   // Draw the scalar bar and annotation text to the screen.
   int RenderOpaqueGeometry(vtkViewport* viewport);
-  int RenderTranslucentGeometry(vtkViewport* ) {return 0;};
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport* ) {return 0;};
   int RenderOverlay(vtkViewport* viewport);
 
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
+  
   // Description:
   // Set/Get the maximum height of a line of text as a 
   // percentage of the vertical area allocated to this

Hybrid/vtkCubeAxesActor2D.cxx

@@ -22,7 +22,7 @@
 #include "vtkTextProperty.h"
 #include "vtkViewport.h"
 
-vtkCxxRevisionMacro(vtkCubeAxesActor2D, "1.53");
+vtkCxxRevisionMacro(vtkCubeAxesActor2D, "1.54");
 vtkStandardNewMacro(vtkCubeAxesActor2D);
 
 vtkCxxSetObjectMacro(vtkCubeAxesActor2D,Input, vtkDataSet);
@@ -462,6 +462,14 @@ int vtkCubeAxesActor2D::RenderOpaqueGeometry(vtkViewport *viewport)
   return renderedSomething;
 }
 
+//-----------------------------------------------------------------------------
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkCubeAxesActor2D::HasTranslucentPolygonalGeometry()
+{
+  return 0;
+}
+
 //----------------------------------------------------------------------------
 // Do final adjustment of axes to control offset, etc.
 void vtkCubeAxesActor2D::AdjustAxes(double pts[8][3], double bounds[6],

Hybrid/vtkCubeAxesActor2D.h

@@ -69,8 +69,12 @@ public:
   // Draw the axes as per the vtkProp superclass' API.
   int RenderOverlay(vtkViewport*);
   int RenderOpaqueGeometry(vtkViewport*);
-  int RenderTranslucentGeometry(vtkViewport *) {return 0;}
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport *) {return 0;}
 
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
+  
   // Description:
   // Use the bounding box of this input dataset to draw the cube axes. If this
   // is not specified, then the class will attempt to determine the bounds from

Hybrid/vtkLegendBoxActor.cxx

@@ -28,7 +28,7 @@
 #include "vtkTransformPolyDataFilter.h"
 #include "vtkViewport.h"
 
-vtkCxxRevisionMacro(vtkLegendBoxActor, "1.30");
+vtkCxxRevisionMacro(vtkLegendBoxActor, "1.31");
 vtkStandardNewMacro(vtkLegendBoxActor);
 
 vtkCxxSetObjectMacro(vtkLegendBoxActor,EntryTextProperty,vtkTextProperty);
@@ -665,6 +665,14 @@ int vtkLegendBoxActor::RenderOpaqueGeometry(vtkViewport *viewport)
   return renderedSomething;
 }
 
+//-----------------------------------------------------------------------------
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkLegendBoxActor::HasTranslucentPolygonalGeometry()
+{
+  return 0;
+}
+
 //----------------------------------------------------------------------------
 void vtkLegendBoxActor::PrintSelf(ostream& os, vtkIndent indent)
 {

Hybrid/vtkLegendBoxActor.h

@@ -150,8 +150,12 @@ public:
   // DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS.
   // Draw the legend box to the screen.
   int RenderOpaqueGeometry(vtkViewport* viewport);
-  int RenderTranslucentGeometry(vtkViewport* ) {return 0;};
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport* ) {return 0;};
   int RenderOverlay(vtkViewport* viewport);
+  
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
 //ETX
 
 protected:

Hybrid/vtkXYPlotActor.cxx

@@ -39,7 +39,7 @@
 
 #define VTK_MAX_PLOTS 50
 
-vtkCxxRevisionMacro(vtkXYPlotActor, "1.66");
+vtkCxxRevisionMacro(vtkXYPlotActor, "1.67");
 vtkStandardNewMacro(vtkXYPlotActor);
 
 vtkCxxSetObjectMacro(vtkXYPlotActor,TitleTextProperty,vtkTextProperty);
@@ -775,6 +775,14 @@ int vtkXYPlotActor::RenderOpaqueGeometry(vtkViewport *viewport)
   return renderedSomething;
 }
 
+//-----------------------------------------------------------------------------
+// Description:
+// Does this prop have some translucent polygonal geometry?
+int vtkXYPlotActor::HasTranslucentPolygonalGeometry()
+{
+  return 0;
+}
+
 //----------------------------------------------------------------------------
 const char *vtkXYPlotActor::GetXValuesAsString()
 {

Hybrid/vtkXYPlotActor.h

@@ -503,8 +503,12 @@ public:
   // Draw the x-y plot.
   int RenderOpaqueGeometry(vtkViewport*);
   int RenderOverlay(vtkViewport*);
-  int RenderTranslucentGeometry(vtkViewport *) {return 0;}
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport *) {return 0;}
 
+  // Description:
+  // Does this prop have some translucent polygonal geometry?
+  virtual int HasTranslucentPolygonalGeometry();
+  
   // Description:
   // Release any graphics resources that are being consumed by this actor.
   // The parameter window could be used to determine which graphic