You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
269 lines
11 KiB
269 lines
11 KiB
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: $RCSfile: vtkProp.h,v $
|
|
|
|
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
// .NAME vtkProp - abstract superclass for all actors, volumes and annotations
|
|
// .SECTION Description
|
|
// vtkProp is an abstract superclass for any objects that can exist in a
|
|
// rendered scene (either 2D or 3D). Instances of vtkProp may respond to
|
|
// various render methods (e.g., RenderOpaqueGeometry()). vtkProp also
|
|
// defines the API for picking, LOD manipulation, and common instance
|
|
// variables that control visibility, picking, and dragging.
|
|
// .SECTION See Also
|
|
// vtkActor2D vtkActor vtkVolume vtkProp3D
|
|
|
|
#ifndef __vtkProp_h
|
|
#define __vtkProp_h
|
|
|
|
#include "vtkObject.h"
|
|
|
|
class vtkAssemblyPath;
|
|
class vtkAssemblyPaths;
|
|
class vtkMatrix4x4;
|
|
class vtkPropCollection;
|
|
class vtkViewport;
|
|
class vtkWindow;
|
|
|
|
class VTK_COMMON_EXPORT vtkProp : public vtkObject
|
|
{
|
|
public:
|
|
vtkTypeRevisionMacro(vtkProp,vtkObject);
|
|
void PrintSelf(ostream& os, vtkIndent indent);
|
|
|
|
// Description:
|
|
// For some exporters and other other operations we must be
|
|
// able to collect all the actors or volumes. These methods
|
|
// are used in that process.
|
|
virtual void GetActors(vtkPropCollection *) {}
|
|
virtual void GetActors2D(vtkPropCollection *) {}
|
|
virtual void GetVolumes(vtkPropCollection *) {}
|
|
|
|
// Description:
|
|
// Set/Get visibility of this vtkProp.
|
|
vtkSetMacro(Visibility, int);
|
|
vtkGetMacro(Visibility, int);
|
|
vtkBooleanMacro(Visibility, int);
|
|
|
|
// Description:
|
|
// Set/Get the pickable instance variable. This determines if the vtkProp
|
|
// can be picked (typically using the mouse). Also see dragable.
|
|
vtkSetMacro(Pickable,int);
|
|
vtkGetMacro(Pickable,int);
|
|
vtkBooleanMacro(Pickable,int);
|
|
|
|
// Description:
|
|
// Method fires PickEvent if the prop is picked.
|
|
virtual void Pick();
|
|
|
|
// Description:
|
|
// Set/Get the value of the dragable instance variable. This determines if
|
|
// an Prop, once picked, can be dragged (translated) through space.
|
|
// This is typically done through an interactive mouse interface.
|
|
// This does not affect methods such as SetPosition, which will continue
|
|
// to work. It is just intended to prevent some vtkProp'ss from being
|
|
// dragged from within a user interface.
|
|
vtkSetMacro(Dragable,int);
|
|
vtkGetMacro(Dragable,int);
|
|
vtkBooleanMacro(Dragable,int);
|
|
|
|
// Description:
|
|
// Return the mtime of anything that would cause the rendered image to
|
|
// appear differently. Usually this involves checking the mtime of the
|
|
// prop plus anything else it depends on such as properties, textures
|
|
// etc.
|
|
virtual unsigned long GetRedrawMTime() {return this->GetMTime();}
|
|
|
|
// Description:
|
|
// Get the bounds for this Prop as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).
|
|
// in world coordinates. NULL means that the bounds are not defined.
|
|
virtual double *GetBounds() {return NULL;}
|
|
|
|
// Description:
|
|
// Shallow copy of this vtkProp.
|
|
virtual void ShallowCopy(vtkProp *prop);
|
|
|
|
// Description:
|
|
// vtkProp and its subclasses can be picked by subclasses of
|
|
// vtkAbstractPicker (e.g., vtkPropPicker). The following methods interface
|
|
// with the picking classes and return "pick paths". A pick path is a
|
|
// hierarchical, ordered list of props that form an assembly. Most often,
|
|
// when a vtkProp is picked, its path consists of a single node (i.e., the
|
|
// prop). However, classes like vtkAssembly and vtkPropAssembly can return
|
|
// more than one path, each path being several layers deep. (See
|
|
// vtkAssemblyPath for more information.) To use these methods - first
|
|
// invoke InitPathTraversal() followed by repeated calls to GetNextPath().
|
|
// GetNextPath() returns a NULL pointer when the list is exhausted.
|
|
virtual void InitPathTraversal();
|
|
virtual vtkAssemblyPath *GetNextPath();
|
|
virtual int GetNumberOfPaths() {return 1;}
|
|
|
|
// Description:
|
|
// These methods are used by subclasses to place a matrix (if any) in the
|
|
// prop prior to rendering. Generally used only for picking. See vtkProp3D
|
|
// for more information.
|
|
virtual void PokeMatrix(vtkMatrix4x4 *vtkNotUsed(matrix)) {}
|
|
virtual vtkMatrix4x4 *GetMatrix() {return NULL;}
|
|
|
|
//BTX
|
|
// Description:
|
|
// 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
|
|
// 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.
|
|
// 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 RenderOverlay( vtkViewport *) { return 0; }
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// Release any graphics resources that are being consumed by this actor.
|
|
// The parameter window could be used to determine which graphic
|
|
// resources to release.
|
|
virtual void ReleaseGraphicsResources(vtkWindow *) {}
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS
|
|
// The EstimatedRenderTime may be used to select between different props,
|
|
// for example in LODProp it is used to select the level-of-detail.
|
|
// The value is returned in seconds. For simple geometry the accuracy may
|
|
// not be great due to buffering. For ray casting, which is already
|
|
// multi-resolution, the current resolution of the image is factored into
|
|
// the time. We need the viewport for viewing parameters that affect timing.
|
|
// The no-arguments version simply returns the value of the variable with
|
|
// no estimation.
|
|
virtual double GetEstimatedRenderTime( vtkViewport * )
|
|
{ return this->EstimatedRenderTime; }
|
|
virtual double GetEstimatedRenderTime(){ return this->EstimatedRenderTime; }
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS
|
|
// This method is used by, for example, the vtkLODProp3D in order to
|
|
// initialize the estimated render time at start-up to some user defined
|
|
// value.
|
|
virtual void SetEstimatedRenderTime(double t)
|
|
{this->EstimatedRenderTime = t; this->SavedEstimatedRenderTime = t;}
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS
|
|
// When the EstimatedRenderTime is first set to 0.0 (in the
|
|
// SetAllocatedRenderTime method) the old value is saved. This
|
|
// method is used to restore that old value should the render be
|
|
// aborted.
|
|
virtual void RestoreEstimatedRenderTime()
|
|
{ this->EstimatedRenderTime = this->SavedEstimatedRenderTime; }
|
|
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS
|
|
// This method is intended to allow the renderer to add to the
|
|
// EstimatedRenderTime in props that require information that
|
|
// the renderer has in order to do this. For example, props
|
|
// that are rendered with a ray casting method do not know
|
|
// themselves how long it took for them to render. We don't want to
|
|
// cause a this->Modified() when we set this value since it is not
|
|
// really a modification to the object. (For example, we don't want
|
|
// to rebuild matrices at every render because the estimated render time
|
|
// is changing)
|
|
virtual void AddEstimatedRenderTime(double t, vtkViewport *vtkNotUsed(vp))
|
|
{this->EstimatedRenderTime+=t;}
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS
|
|
// The renderer may use the allocated rendering time to determine
|
|
// how to render this actor. Therefore it might need the information
|
|
// provided in the viewport.
|
|
// A side effect of this method is to reset the EstimatedRenderTime to
|
|
// 0.0. This way, each of the ways that this prop may be rendered can
|
|
// be timed and added together into this value.
|
|
virtual void SetAllocatedRenderTime(double t, vtkViewport *vtkNotUsed(v))
|
|
{
|
|
this->AllocatedRenderTime = t;
|
|
this->SavedEstimatedRenderTime = this->EstimatedRenderTime;
|
|
this->EstimatedRenderTime = 0.0;
|
|
}
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS
|
|
vtkGetMacro(AllocatedRenderTime, double);
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS
|
|
// Get/Set the multiplier for the render time. This is used
|
|
// for culling and is a number between 0 and 1. It is used
|
|
// to create the allocated render time value.
|
|
void SetRenderTimeMultiplier( double t ) { this->RenderTimeMultiplier = t; }
|
|
vtkGetMacro(RenderTimeMultiplier, double);
|
|
|
|
// Description:
|
|
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
|
|
// DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS
|
|
// Used to construct assembly paths and perform part traversal.
|
|
virtual void BuildPaths(vtkAssemblyPaths *paths, vtkAssemblyPath *path);
|
|
|
|
// Description:
|
|
// Get the number of consumers
|
|
vtkGetMacro(NumberOfConsumers,int);
|
|
|
|
// Description:
|
|
// Add or remove or get or check a consumer,
|
|
void AddConsumer(vtkObject *c);
|
|
void RemoveConsumer(vtkObject *c);
|
|
vtkObject *GetConsumer(int i);
|
|
int IsConsumer(vtkObject *c);
|
|
|
|
//ETX
|
|
|
|
protected:
|
|
vtkProp();
|
|
~vtkProp();
|
|
|
|
int Visibility;
|
|
int Pickable;
|
|
int Dragable;
|
|
|
|
double AllocatedRenderTime;
|
|
double EstimatedRenderTime;
|
|
double SavedEstimatedRenderTime;
|
|
double RenderTimeMultiplier;
|
|
|
|
// how many consumers does this object have
|
|
int NumberOfConsumers;
|
|
vtkObject **Consumers;
|
|
|
|
// support multi-part props and access to paths of prop
|
|
// stuff that follows is used to build the assembly hierarchy
|
|
vtkAssemblyPaths *Paths;
|
|
|
|
private:
|
|
vtkProp(const vtkProp&); // Not implemented.
|
|
void operator=(const vtkProp&); // Not implemented.
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|