(2)vtkAbstractMapper

/*=========================================================================

Program: Visualization Toolkit
Module: $RCSfile: vtkAbstractMapper.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 vtkAbstractMapper - abstract class specifies interface to map data
// .SECTION Description
// vtkAbstractMapper is an abstract class to specify interface between data and
// graphics primitives or software rendering techniques. Subclasses of
// vtkAbstractMapper can be used for rendering 2D data, geometry, or volumetric
// data.
//
// .SECTION See Also
// vtkAbstractMapper3D vtkMapper vtkPolyDataMapper vtkVolumeMapper

#ifndef __vtkAbstractMapper_h
#define __vtkAbstractMapper_h

#include "vtkAlgorithm.h"

#define VTK_SCALAR_MODE_DEFAULT 0
#define VTK_SCALAR_MODE_USE_POINT_DATA 1
#define VTK_SCALAR_MODE_USE_CELL_DATA 2
#define VTK_SCALAR_MODE_USE_POINT_FIELD_DATA 3
#define VTK_SCALAR_MODE_USE_CELL_FIELD_DATA 4
#define VTK_SCALAR_MODE_USE_FIELD_DATA 5

#define VTK_GET_ARRAY_BY_ID 0
#define VTK_GET_ARRAY_BY_NAME 1

class vtkDataArray;
class vtkDataSet;
class vtkPlane;
class vtkPlaneCollection;
class vtkPlanes;
class vtkTimerLog;//Time stamp
class vtkWindow;

class VTK_FILTERING_EXPORT vtkAbstractMapper : public vtkAlgorithm
{
public://vtkAlgorithm,vtkAbstractMapper
vtkTypeRevisionMacro(vtkAbstractMapper,vtkAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent);

// Description:
// Override Modifiedtime as we have added Clipping planes
virtual unsigned long GetMTime();//时间戳,做一个时间标记,记录下修改时间

// Description:
// Release any graphics resources that are being consumed by this mapper.
// The parameter window could be used to determine which graphic
// resources to release.
virtual void ReleaseGraphicsResources(vtkWindow *) {};//释放图形资源

// Description:
// Get the time required to draw the geometry last time it was rendered
vtkGetMacro( TimeToDraw, double );

// Description:
// Specify clipping planes to be applied when the data is mapped
// (at most 6 clipping planes can be specified).
void AddClippingPlane(vtkPlane *plane);//增加剪切平面,当把几何数据映射成图元
void RemoveClippingPlane(vtkPlane *plane);
void RemoveAllClippingPlanes();

// Description:
// Get/Set the vtkPlaneCollection which specifies the
// clipping planes.
virtual void SetClippingPlanes(vtkPlaneCollection*);//设置剪切平面
vtkGetObjectMacro(ClippingPlanes,vtkPlaneCollection);

// Description:
// An alternative way to set clipping planes: use up to six planes found
// in the supplied instance of the implicit function vtkPlanes.
void SetClippingPlanes(vtkPlanes *planes);

// Description:
// Make a shallow copy of this mapper.
void ShallowCopy(vtkAbstractMapper *m);

// Description:
// Internal helper function for getting the active scalars. The scalar
// mode indicates where the scalars come from. The cellFlag is a
// return value that is set when the scalars actually are cell scalars.
// (0 for point scalars, 1 for cell scalars, 2 for field scalars)
// The arrayAccessMode is used to indicate how to retrieve the scalars from
// field data, per id or per name (if the scalarMode indicates that).
static vtkDataArray *GetScalars(vtkDataSet *input, int scalarMode,
int arrayAccessMode, int arrayId,
const char *arrayName, int& cellFlag);

protected:
vtkAbstractMapper();
~vtkAbstractMapper();

vtkTimerLog *Timer;
double TimeToDraw;
vtkWindow *LastWindow; // Window used for the previous render
vtkPlaneCollection *ClippingPlanes;

private:
vtkAbstractMapper(const vtkAbstractMapper&); // Not implemented.
void operator=(const vtkAbstractMapper&); // Not implemented.
};

/*=========================================================================

Program: Visualization Toolkit
Module: $RCSfile: vtkAbstractMapper.cxx,v $

Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

=========================================================================*/
#include "vtkAbstractMapper.h"

#include "vtkCellData.h"
#include "vtkDataSet.h"
#include "vtkObjectFactory.h"
#include "vtkPlaneCollection.h"
#include "vtkPlanes.h"
#include "vtkPointData.h"
#include "vtkTimerLog.h"

vtkCxxRevisionMacro(vtkAbstractMapper, "$Revision: 1.6 $");

vtkCxxSetObjectMacro(vtkAbstractMapper,ClippingPlanes,vtkPlaneCollection);

// Construct object.
vtkAbstractMapper::vtkAbstractMapper()
{
this->TimeToDraw = 0.0;
this->LastWindow = NULL;
this->ClippingPlanes = NULL;
this->Timer = vtkTimerLog::New();//
this->SetNumberOfOutputPorts(0);//
没有输出,直接映射成图元,也就是说,直接执行了
glBegin(GL_VERTEX)
glEnd()
函数
this->SetNumberOfInputPorts(1);//this->SetNumberOfInputPorts(1)
}

vtkAbstractMapper::~vtkAbstractMapper()
{
this->Timer->Delete();
if (this->ClippingPlanes)
    {
    this->ClippingPlanes->UnRegister(this);
    }
}

// Description:
// Override Modifiedtime as we have added Clipping planes//
unsigned long vtkAbstractMapper::GetMTime()
{
unsigned long mTime = this->Superclass::GetMTime();
unsigned long clipMTime;

if ( this->ClippingPlanes != NULL )
    {
    clipMTime = this->ClippingPlanes->GetMTime();
    mTime = ( clipMTime > mTime ? clipMTime : mTime );
    }

return mTime;
}

void vtkAbstractMapper::AddClippingPlane(vtkPlane *plane)//增加一个剪切面
{
if (this->ClippingPlanes == NULL)
    {
    this->ClippingPlanes = vtkPlaneCollection::New();
    this->ClippingPlanes->Register(this);
    this->ClippingPlanes->Delete();
    }

this->ClippingPlanes->AddItem(plane);
this->Modified();
}

void vtkAbstractMapper::RemoveClippingPlane(vtkPlane *plane)
{
if (this->ClippingPlanes == NULL)
    {
    vtkErrorMacro(<< "Cannot remove clipping plane: mapper has none");
    }
this->ClippingPlanes->RemoveItem(plane);
this->Modified();
}

void vtkAbstractMapper::RemoveAllClippingPlanes()
{
if ( this->ClippingPlanes )
    {
    this->ClippingPlanes->RemoveAllItems();
    }
}

void vtkAbstractMapper::SetClippingPlanes(vtkPlanes *planes)
{
vtkPlane *plane;
if (!planes)
    {
    return;
    }

int numPlanes = planes->GetNumberOfPlanes();

this->RemoveAllClippingPlanes();
for (int i=0; i<numPlanes && i<6; i++)
    {
    plane = vtkPlane::New();
    planes->GetPlane(i, plane);
    this->AddClippingPlane(plane);
    plane->Delete();
    }
}

vtkDataArray *vtkAbstractMapper::GetScalars(vtkDataSet *input,
                                            int scalarMode,
                                            int arrayAccessMode,
                                            int arrayId,
                                            const char *arrayName,
                                            int& cellFlag)
{
vtkDataArray *scalars=NULL;
vtkPointData *pd;
vtkCellData *cd;
vtkFieldData *fd;

// make sure we have an input
if ( !input )
    {
    return NULL;
    }

// get and scalar data according to scalar mode
if ( scalarMode == VTK_SCALAR_MODE_DEFAULT )
    {
    scalars = input->GetPointData()->GetScalars();
    cellFlag = 0;
    if (!scalars)
      {
      scalars = input->GetCellData()->GetScalars();
      cellFlag = 1;
      }
    }
else if ( scalarMode == VTK_SCALAR_MODE_USE_POINT_DATA )
    {
    scalars = input->GetPointData()->GetScalars();
    cellFlag = 0;
    }
else if ( scalarMode == VTK_SCALAR_MODE_USE_CELL_DATA )
    {
    scalars = input->GetCellData()->GetScalars();
    cellFlag = 1;
    }
else if ( scalarMode == VTK_SCALAR_MODE_USE_POINT_FIELD_DATA )
    {
    pd = input->GetPointData();
    if (arrayAccessMode == VTK_GET_ARRAY_BY_ID)
      {
      scalars = pd->GetArray(arrayId);
      }
    else
      {
      scalars = pd->GetArray(arrayName);
      }
    cellFlag = 0;
    }
else if ( scalarMode == VTK_SCALAR_MODE_USE_CELL_FIELD_DATA )
    {
    cd = input->GetCellData();
    if (arrayAccessMode == VTK_GET_ARRAY_BY_ID)
      {
      scalars = cd->GetArray(arrayId);
      }
    else
      {
      scalars = cd->GetArray(arrayName);
      }
    cellFlag = 1;
    }
else if ( scalarMode == VTK_SCALAR_MODE_USE_FIELD_DATA )
    {
    fd = input->GetFieldData();
    if (arrayAccessMode == VTK_GET_ARRAY_BY_ID)
      {
      scalars = fd->GetArray(arrayId);
      }
    else
      {
      scalars = fd->GetArray(arrayName);
      }
    cellFlag = 2;
    }

return scalars;
}

// Shallow copy of vtkProp.
void vtkAbstractMapper::ShallowCopy(vtkAbstractMapper *mapper)
{
this->SetClippingPlanes( mapper->GetClippingPlanes() );
}

void vtkAbstractMapper::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os,indent);

os << indent << "TimeToDraw: " << this->TimeToDraw << "\n";

if ( this->ClippingPlanes )
    {
    os << indent << "ClippingPlanes:\n";
    this->ClippingPlanes->PrintSelf(os,indent.GetNextIndent());
    }
else
    {
    os << indent << "ClippingPlanes: (none)\n";
    }
}