chordIntersectionRecord.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: chrdIntRec.h,v $ $Revision: 1.14 $ $State: Exp $
*********************************************************************/
#ifndef chordIntersectionRecord_H_
#define chordIntersectionRecord_H_

// \file chrdIntRec.h
// \brief Contains the DtChordIntersectionRecord class declaration.

#include "geometry/intersectionRecord.h"
#include "geometry/geometryDefines.h"
#include "geometry/point.h"
#include "geometry/surface.h"
#include <matrix/vlVector.h>


// Instances of DtChordIntersectionRecord are used to record the 
// results of chord/primitive intersection attempts.
class DT_DLL_geometry DtChordIntersectionRecord : public DtIntersectionRecord
{
public:

   // default constructor
   DtChordIntersectionRecord();

   //additional constructor 
   DtChordIntersectionRecord(DtPoint& intersectionPoint, 
                             double intersectionTime,
                             DtVector& normal, 
                             DtSurface* surface);

   // destructor
   virtual ~DtChordIntersectionRecord();

   // copy constructor
   DtChordIntersectionRecord(const DtChordIntersectionRecord& orig);

   // assignment operator
   // Note: if "orig" owns its own polygon, this will make a copy of the
   // polygon so that this object can own it's own copy.
   DtChordIntersectionRecord& operator=(const DtChordIntersectionRecord& orig);

   // clone this object
   virtual DtIntersectionRecord* clone() const;

   // The type of record used for the intersection query. Returns
   // CHORD_TYPE
   virtual DtRecordType type() const;

   //debugging aid
   virtual void dump() const;

   //set/get intersectionPoint
   const DtPoint intersectionPoint() const;
   const DtVector intersectionVector() const;
   void setIntersectionPoint(const DtPoint& pt);

   //set/get intersectionTime
   const double intersectionTime() const;
   void setIntersectionTime(double t);

   //set/get normal to intersecting terrain element
   const DtVector normal() const;
   void setNormal(const DtVector& v);

   //set/get intersecting surface
   const DtSurface surface() const;
   void setSurface(const DtSurface& s);

   // The number of intersection tests that were performed in order to fill in
   // this class can be kept, for instrumentation purposes.  These are the 
   // accessor functions.
   // @{
   // @returns The number of intersection tests associated with this record.
   inline unsigned int numberOfIntersectionTests() const;
   // Increments the current number of intersection tests by one.
   inline void incrementNumberOfIntersectionTests();
   // Set outright the number of intersection tests.
   inline void setNumberOfIntersectionTests(unsigned int newNumberOfTests);
   // @}

protected:

   DtPoint        myIntersectionPoint;
   DtVector       myIntersectionVector;
   double         myIntersectionTime;
   DtVector       myNormal;
   DtSurface      mySurface;


   // This represents the total number of intersection tests that were 
   // performed to fill in this intersection record.  This is intended to 
   // be used for instrumentation purposes, and is included because of the
   // very low overhead.
   unsigned int   myNumberOfIntersectionTests;
};

inline const DtPoint DtChordIntersectionRecord::intersectionPoint() const
{
   return myIntersectionPoint;
}

inline const DtVector DtChordIntersectionRecord::intersectionVector() const
{
   return myIntersectionVector;
}

inline void DtChordIntersectionRecord::setIntersectionPoint(
   const DtPoint& pt)
{
   myIntersectionPoint = pt;

   myIntersectionVector[0] = pt.x();
   myIntersectionVector[1] = pt.y();
   myIntersectionVector[2] = pt.z();
}

inline const double DtChordIntersectionRecord::intersectionTime() const
{
   return myIntersectionTime;
}

inline void DtChordIntersectionRecord::setIntersectionTime(double t)
{
   myIntersectionTime = t;
}

inline const DtVector DtChordIntersectionRecord::normal() const
{
   return myNormal;
}

inline void DtChordIntersectionRecord::setNormal(const DtVector& v)
{
   myNormal = v;
}

inline const DtSurface DtChordIntersectionRecord::surface() const
{
   return mySurface;
}

inline void DtChordIntersectionRecord::setSurface(const DtSurface& s)
{
   mySurface = s;
}

inline unsigned int DtChordIntersectionRecord::numberOfIntersectionTests() const
{
   return myNumberOfIntersectionTests;
}

inline void DtChordIntersectionRecord::incrementNumberOfIntersectionTests()
{
   ++myNumberOfIntersectionTests;
}

inline void DtChordIntersectionRecord::setNumberOfIntersectionTests(unsigned int newNumberOfTests)
{
   myNumberOfIntersectionTests = newNumberOfTests;
}


#endif