Commit d13e5ea2 authored by Francois Bertel's avatar Francois Bertel
Browse files

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)
parent eb4103de
......@@ -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.
......
......@@ -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()
{
......
......@@ -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);
......
......@@ -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() {};
......
......@@ -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);
}
}
......
......@@ -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
......
......@@ -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 );
......
......@@ -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);
......
......@@ -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;
......
......@@ -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);
......
......@@ -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)
{
......
......@@ -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:
......
......@@ -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])
{
......
......@@ -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
......
......@@ -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],
......
......@@ -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
......
......@@ -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)
{
......
......@@ -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:
......
......@@ -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()
{
......
......@@ -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
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment