include/gdb/spatialSubdivisionTerrainIntersector.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2008 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: spatialSubdivisionTerrainIntersector.h,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/


#ifndef spatialSubdivisionTerrainIntersector_h
#define spatialSubdivisionTerrainIntersector_h

#include "gdb/terrainIntersector.h"
#include "geometry/spatialSubdivision.h"

#include "gdb/gdbNode.h"

// Enable this to test the spatial subdivision against the spatial index 
// Causes a significant performance hit
#define TEST_SPATIAL_SUBDIVISION 0

#if TEST_SPATIAL_SUBDIVISION
class DtSpatialIndex;
#endif

class DtSpatialSubdivisionTerrainIntersectorDescriptor;

// An intersector for DtTerrainDatabase class.
// Uses the spatial subdivision methodology for providing fast terrain
// intersections

// This is the descriptor class that will set up some basic information for the spatial
// subdivision

class DT_DLL_gdb DtSpatialSubdivisionTerrainIntersector : public DtTerrainIntersector
{
private:
   // Not implemented.
   DtSpatialSubdivisionTerrainIntersector();
   // Not implemented.
   DtSpatialSubdivisionTerrainIntersector(const DtSpatialSubdivisionTerrainIntersector& orig);
   // Not implemented.
   DtSpatialSubdivisionTerrainIntersector& operator=(const DtSpatialSubdivisionTerrainIntersector& orig);

public:
   DtSpatialSubdivisionTerrainIntersector(DtTerrainDatabase* db,
      const DtTerrainIntersectorDescriptor* desc);
   virtual ~DtSpatialSubdivisionTerrainIntersector();

   virtual bool init();

   // Calls init()
   virtual bool reinitialize();

   // \return The total number of bytes of memory used by this intersector
   // and any of its internal indexing into the terrain.
   virtual unsigned int memoryUsage() const;

   virtual bool chordIntersect(const DtChord& chord,
      DtChordIntersectionRecord& record,
      DtGdbNode::DtIntersectRecordType irtFlag = DtGdbNode::IRT_ALL_DATA_TERRAIN) const;

   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtChordIntersectRecordList& intList,
      DtGdbNode::DtIntersectRecordType irtFlag = DtGdbNode::IRT_ALL_DATA_TERRAIN) const;

   virtual bool sphereIntersect(const DtSphere& sphere, DtSphereIntersectionRecord& record,
      DtGdbNode::DtIntersectRecordType irtFlag = DtGdbNode::IRT_ALL_DATA_TERRAIN) const;

   virtual int terrainIntersectorType() const;

   // \return A new instance of a descriptor for this terrain intersector.
   static DtSpatialSubdivisionTerrainIntersectorDescriptor* createDescriptor();

public:

   virtual DtSpatialSubdivision<DtGdbNode*>* spatialSubdivision();
   virtual const DtSpatialSubdivision<DtGdbNode*>* spatialSubdivision() const;

   // These are only used during init or reinitialization.  If you set
   // one (or more) of these values, be sure to call reinitialize after
   // you are done changing values
   int cellCountX() const { return myCellCountX; };
   void setCellCountX(int x) { myCellCountX = x ;};

   int cellCountY() const { return myCellCountY; };
   void setCellCountY(int y) { myCellCountY = y; };

   int cellCountZ() const { return myCellCountZ; };
   void setCellCountZ(int z) { myCellCountZ = z; };

protected:
   virtual void buildSpatialSubdivision(unsigned int cellCountX, 
                                        unsigned int cellCountY,
                                        unsigned int cellCountZ = 1);

#if TEST_SPATIAL_SUBDIVISION
public:
   DtSpatialIndex* spatialIndex();
   void setSpatialIndex(DtSpatialIndex* spatialIndex);
protected:
#endif

protected:
   DtSpatialSubdivision<DtGdbNode*>* myTerrainSpatialSubdivision;

   // These are only used during initialization.
   int myCellCountX;
   int myCellCountY;
   int myCellCountZ;

private:
#if TEST_SPATIAL_SUBDIVISION
   DtSpatialIndex* mySpatialIndex;
#endif
};

inline DtSpatialSubdivision<DtGdbNode*>* DtSpatialSubdivisionTerrainIntersector::spatialSubdivision()
{
   return myTerrainSpatialSubdivision;
}

inline const DtSpatialSubdivision<DtGdbNode*>* DtSpatialSubdivisionTerrainIntersector::spatialSubdivision() const
{
   return myTerrainSpatialSubdivision;
}

#if TEST_SPATIAL_SUBDIVISION
inline DtSpatialIndex* DtTerrainDatabase::spatialIndex()
{
   return mySpatialIndex;
}
inline void DtTerrainDatabase::setSpatialIndex(DtSpatialIndex* newSpatialIndex)
{
   mySpatialIndex = newSpatialIndex;
}
#endif

#endif