Public Types
typedef std::map< std::string, std::string >	TerrainSettings
Public Member Functions
	DtTerrainInterface ()
	Constructor.
virtual	~DtTerrainInterface ()
	Destructor.
virtual bool	init ()
	Virtual initialization.
virtual void	addTerrainImplementation (const DtString &implementationName, DtTerrainImplementationCreatorFcn creatorFcn)
	Add a terrain implementation type to the set of terrain implementations that can be used by this interface.
virtual bool	loadTerrain (const DtString &filename, const TerrainSettings &settings=TerrainSettings())
	Settings will be merged into existing -- not replace.
virtual bool	unloadTerrain ()
virtual bool	terrainIsLoaded ()
virtual DtString	loadedFilename () const
virtual const Coordinate_System *	coordinateSystem () const
virtual Coordinate_System *	coordinateSystem ()
virtual double	terrainHeightAboveSeaLevel (const DtPoint &databaseLocation, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Returns the height above sea level for the topmost terrain intersection at databaseLocation.
virtual bool	terrainHeightAndIntersection (const DtVector &localLocation, double &height, DtChordIntersectionRecord &record, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Returns whether there is a terrain intersection and if so sets height and record from the topmost terrain intersection point.
virtual bool	closestIntersection (const DtVector &localLocation, DtPoint &intersectionPoint, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Similar to the terrainHeight functions above.
virtual bool	closestIntersection (double lat, double lon, DtPoint &intersectionPoint, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Same as above function, but accepts location in lat/lon.
virtual bool	closestIntersection (const DtVector &localLocation, DtChordIntersectionRecord &record, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Same as above function, but returns the entire intersection record, and not just the intersection point.
virtual bool	closestIntersection (double lat, double lon, DtChordIntersectionRecord &record, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Same as above function, but accepts location in lat/lon.
virtual bool	closestIntersection (const std::list< DtVector > &localLocationList, DtChordIntersectRecordList &recordList, int &numIntersections, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Returns complete intersection information about the closest terrain intersection point for each location in the list in Database Coordinates.
virtual bool	intersect (const DtChord &chord, DtPoint &intersectionPoint, double &intersectionTime, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Calculates the first terrain intersection point along a chord given in Database Coordinates.
virtual bool	intersect (const DtChord &chord, DtChordIntersectionRecord &record, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Returns complete intersection information about the first terrain intersection point along a chord given in Database Coordinates.
virtual bool	intersect (const DtSphere &sphere, DtSphereIntersectionRecord &record, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Sphere intersection test.
virtual bool	allIntersectsAlongChord (const DtChord &chord, DtChordIntersectRecordList &intList, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Computes the list of all intersections of a chord (in Database Coordinates) with the terrain database.
virtual bool	intersectList (const std::list< DtChord > &chordList, DtChordIntersectRecordList &recordList, int &numTerrainIntersections, int &numVectorNetworkIntersections, DtIntersectionRecord::DtIntersectionType irtFlag=DtIntersectionRecord::INT_ALL_DATA, bool *dataAvailable=0, bool overrideBlockingAssert=false) const
	Returns complete intersection information about the first terrain intersection points along each of a list of DtChords given in Database Coordinates.
virtual const DtVectorNetwork *	vectorNetwork () const
	Vector network accessor.
virtual void	preloadTerrainAreas (const DtTerrainPagingGeometryList &preloadGeometry)
	Specifies a list of terrain areas that should be preloaded by the terrain implementation, in the case of a paging or streaming terrain source.
virtual const DtTerrainCapabilities *	terrainCapabilities () const
virtual bool	intersectVectorNetwork (const DtChord &chord, DtVectorNetworkRecord vectorRecord, DtVectorNetworkIntersectionRecord vectorIntersectionRecord) const
	User passes in the chord to intersect the vector network and the vectorRecord defining the desired search parameters like the kind of features to be searched.
virtual bool	intersectVectorNetwork (const DtVector &localLocation, DtVectorNetworkRecord vectorRecord, DtVectorNetworkIntersectionRecord vectorIntersectionRecord) const
	User passes in the location to intersect the vector network and the vectorRecord defining the desired search parameters like the kind of features to be searched.
virtual bool	addTerrainPassThroughLayer (const DtString &layerType)
	Adds a pass though layer registered with the specified type to the currently loaded terrain implementation.
virtual void	setIntersectDataLoadExpireTime (const double &expireTime)
	Set the default expiration time for data load requests generated by intersect calls that require data that has not been loaded (paged-in).
virtual void	expireDataLoadRequestsBeforeTime (const double &currentTime)
virtual void	setDataPath (const std::string &)
	Sets the path to find for the data directory.
virtual std::string	dataPath () const
virtual void	setUserDataPath (const std::string &)
	Sets the path to find for the data directory.
virtual std::string	userDataPath () const
virtual void	trianglesInArea (DtTriangleCallbackFcn func, DtTriangleCallbackFinalizeFcn finalize, DtTerrainProcessPolygonsBox &box, void *usr) const
	Calls the function in the first argument on each triangle in the area specified by the box.

virtual void	setAssertOnBlockingTerrainCalls (bool assertBlock)
	Determines if an exception should be thrown if a blocking terrain call is made.
virtual bool	assertOnBlockingTerrainCalls () const
	Determines if an exception should be thrown if a blocking terrain call is made.
Static Public Member Functions
static void	setModelDefinitionFilePath (const DtString &fullFilePath)
static DtString	modelDefinitionFilePath ()
Protected Attributes
DtTerrainImplementation *	myTerrainImpl
bool	myTerrainIsLoaded
	Status publisher needs to keep track of when terrain is loaded and unloaded.
DtTerrainImplementationManager *	myTerrainImplManager
DtConsoleCommandManager *	myConsoleCommandManager
std::list< DtConsoleCommand * >	myCommandList
DtString	myLoadedFilename
	The last filename that was passed to loadTerrain()
TerrainSettings	mySettings
Static Protected Attributes
static DtString	theModelDefinitionFilePath
static double	theTerrainPagingMaxHeight

Member Typedef Documentation

typedef std::map<std::string, std::string> DtTerrainInterface::TerrainSettings

Constructor & Destructor Documentation

DtTerrainInterface::DtTerrainInterface ( )

Constructor.

virtual DtTerrainInterface::~DtTerrainInterface ( ) [virtual]

Destructor.

Member Function Documentation

virtual bool DtTerrainInterface::init ( ) [virtual]

Virtual initialization.

Call this after construction, and before calling any other members on the class. Creates the terrain implementation manager

virtual void DtTerrainInterface::addTerrainImplementation	(	const DtString &	implementationName,
		DtTerrainImplementationCreatorFcn	creatorFcn
	)		`[virtual]`

Add a terrain implementation type to the set of terrain implementations that can be used by this interface.

virtual bool DtTerrainInterface::loadTerrain	(	const DtString &	filename,
		const TerrainSettings &	settings = `TerrainSettings()`
	)		`[virtual]`

Settings will be merged into existing -- not replace.

virtual bool DtTerrainInterface::unloadTerrain ( ) [virtual]

virtual bool DtTerrainInterface::terrainIsLoaded ( ) [virtual]

virtual DtString DtTerrainInterface::loadedFilename ( ) const [virtual]

Returns:: The last filename that was passed to loadTerrain() and successfully loaded.

virtual const Coordinate_System* DtTerrainInterface::coordinateSystem ( ) const [virtual]

virtual Coordinate_System* DtTerrainInterface::coordinateSystem ( ) [virtual]

virtual double DtTerrainInterface::terrainHeightAboveSeaLevel	(	const DtPoint &	databaseLocation,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Returns the height above sea level for the topmost terrain intersection at databaseLocation.

Parameters:

Input
databaseLocation	the location to test
Output
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false and zero will be returned.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: terrainHeight (or zero if the terrain is not yet available)

virtual bool DtTerrainInterface::terrainHeightAndIntersection	(	const DtVector &	localLocation,
		double &	height,
		DtChordIntersectionRecord &	record,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Returns whether there is a terrain intersection and if so sets height and record from the topmost terrain intersection point.

Parameters:

Input
localLocation	the location to test
irtFlag	specifies which data should be calculated and returned for each intersection point
Output
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, height will be set to zero, and the record will not reflect any results.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	a terrain intersection was found
false	if dataAvailable was specified and returns true, then the database does not have an intersection at localLocation. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::closestIntersection	(	const DtVector &	localLocation,
		DtPoint &	intersectionPoint,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Similar to the terrainHeight functions above.

Function to determine the closest intersection to a specified location, either in local (DB) coordinates or in lat/lon. The closest intersection is defined as the closest intersection in the down or up direction from location. Thus if there are multiple terrain levels, it will not necessarily return an intersection with the topmost as the terrainHeight functions do.

Note:: Unlike the terrainHeight functions, if the vectorNetworkRecord and vectorNetworkIntersectionRecord are non-NULL, it will compute an intersection with the vector network and return the best intersection as defined by the metrics in the vectorNetworkRecord.

Return Values: True if any intersection, vector data or terrain, is found. If a vector data intersection is found, then the vecNetworkIntersectionRecord is set appropriately. If at least one terrain intersection is found, the intersectionPoint parameter is set to the closest intersection point.

Parameters:

Input
localLocation	the location to test
Output
intersectionPoint	the point of intersection, left unchanged if dataAvailable is set to false.
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, intersectionPoint will not be modified and false will be returned.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	a terrain intersection was found
false	if dataAvailable was specified and returns true, then the database does not have an intersection at localLocation. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::closestIntersection	(	double	lat,
		double	lon,
		DtPoint &	intersectionPoint,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Same as above function, but accepts location in lat/lon.

Parameters:

Input
lat	the latititude to test
lon	the longitude to test
Output
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, intersectionPoint will not be modified and false will be returned.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	a terrain intersection was found
false	if dataAvailable was specified and returns true, then the database does not have an intersection at localLocation. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::closestIntersection	(	const DtVector &	localLocation,
		DtChordIntersectionRecord &	record,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Same as above function, but returns the entire intersection record, and not just the intersection point.

Parameters:

Input
localLocation	the location to test
irtFlag	specifies which data should be calculated and returned for each intersection point
Output
record	the result of the terrain intersection
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, record will not be modified and false will be returned.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	a terrain intersection was found
false	if dataAvailable was specified and returns true, then the database does not have an intersection at localLocation. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::closestIntersection	(	double	lat,
		double	lon,
		DtChordIntersectionRecord &	record,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Same as above function, but accepts location in lat/lon.

Parameters:

Input
lat	the latititude to test
lon	the longitude to test
irtFlag	specifies which data should be calculated and returned for each intersection point
Output
record	the result of the terrain intersection
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, intersectionPoint will not be modified and false will be returned.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	a terrain intersection was found
false	if dataAvailable was specified and returns true, then the database does not have an intersection at localLocation. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::closestIntersection	(	const std::list< DtVector > &	localLocationList,
		DtChordIntersectRecordList &	recordList,
		int &	numIntersections,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Returns complete intersection information about the closest terrain intersection point for each location in the list in Database Coordinates.

Parameters:

Input
localLocationList	list of locations to test
irtFlag	specifies which data should be calculated and returned for each intersection point
Output
recordList	a DtChordIntersectionRecordList (one record for each localLocation).
numIntersections	set to the number of intersections that occur for the list of locations.
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, recordList will not represent any intersections and numIntersections will be set to 0.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	any chord intersects the terrain
false	if dataAvailable was specified and returns true, then none of the chords intersect the terrain. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::intersect	(	const DtChord &	chord,
		DtPoint &	intersectionPoint,
		double &	intersectionTime,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Calculates the first terrain intersection point along a chord given in Database Coordinates.

Parameters:

Input
chord	the chord to test
Output
intersectionPoint	location of the intersection or left unchanged if there's no intersection or the data is not yet available (see dataAvailable).
intersectionTime	time of the intersection along the input chord or left unchanged if there's no intersection or the data is not yet available (see dataAvailable).
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, and intersectionPoint and intersectionTime will be left unchanged.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	if the chord intersects the terrain
false	if dataAvailable was specified and returns true, then the chord does not intersect the terrain. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::intersect	(	const DtChord &	chord,
		DtChordIntersectionRecord &	record,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Returns complete intersection information about the first terrain intersection point along a chord given in Database Coordinates.

The irtFlag value specifies which data should be calculated and returned for each intersection point.

Parameters:

Input
chord	the chord to test
irtFlag	specifies which data should be calculated and returned for each intersection point
Output
record	the result of the terrain intersection
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, record will not reflect any terrain intersections
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	if the chord intersects the terrain
false	if dataAvailable was specified and returns true, then the chord does not intersect the terrain. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::intersect	(	const DtSphere &	sphere,
		DtSphereIntersectionRecord &	record,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Sphere intersection test.

Parameters:

Input
sphere	the sphere to test
irtFlag	specifies which data should be calculated and returned for each intersection point
Output
record	the result of the terrain intersection
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, record will not reflect any terrain intersections
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	if the sphere intersects with any terrain polygons
false	if dataAvailable was specified and returns true, then the sphere does not intersect the terrain. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::allIntersectsAlongChord	(	const DtChord &	chord,
		DtChordIntersectRecordList &	intList,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Computes the list of all intersections of a chord (in Database Coordinates) with the terrain database.

Parameters:

Input
chord	the chord to test
irtFlag	specifies which data should be calculated and returned for each intersection point

Note:: that passing an irtFlag value of INT_EXISTS will probably never return more than one intersection.

Parameters:

Output
intList	the result of the terrain intersection
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false and intList will not reflect any terrain intersections
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	if the chord intersects the terrain
false	if dataAvailable was specified and returns true, then the chord does not intersect the terrain. Otherwise false indicates that the data is not yet available.

virtual bool DtTerrainInterface::intersectList	(	const std::list< DtChord > &	chordList,
		DtChordIntersectRecordList &	recordList,
		int &	numTerrainIntersections,
		int &	numVectorNetworkIntersections,
		DtIntersectionRecord::DtIntersectionType	irtFlag = `DtIntersectionRecord::INT_ALL_DATA`,
		bool *	dataAvailable = `0`,
		bool	overrideBlockingAssert = `false`
	)		const `[virtual]`

Returns complete intersection information about the first terrain intersection points along each of a list of DtChords given in Database Coordinates.

The returned record list is a DtChordIntersectionRecordList (one record for each chord).

Parameters:

Input
chordList	the chords to test
irtFlag	specifies which data should be calculated and returned for each intersection point
Output
numTerrainIntersections	number of chords that intersected with the terrain
numVectorNetworkIntersections	number of chords that intersected with the vector network
dataAvailable	Please see "Synchronous and asynchronous calls with paged terrains" for information on how to specify that this function be blocking or non-blocking. If the data is not yet paged in, dataAvailable will be set to false, numTerrainIntersections and numVectorNetworkIntersections will be set to zero and the recordList will not reflect any intersections.
overrideBlockingAssert	when set to true this parameter will prevent an assertion from being thrown when the terrain implementation has myAssertOnBlockingTerrainCalls set to true. This should only be done when the call is being made from outside the main simulation thread and a blocking call would not cause a a problem.

Returns:: result of the terrain intersection or data availability

Return values:

true	if any chord intersected the terrain (or vector network if specified)
false	if dataAvailable was specified and returns true, then the chord does not intersect the terrain. Otherwise false indicates that the data is not yet available.

virtual const DtVectorNetwork* DtTerrainInterface::vectorNetwork ( ) const [virtual]

Vector network accessor.

virtual void DtTerrainInterface::preloadTerrainAreas ( const DtTerrainPagingGeometryList & preloadGeometry ) [virtual]

Specifies a list of terrain areas that should be preloaded by the terrain implementation, in the case of a paging or streaming terrain source.

The typical use of this is to specify parts of the terrain that are expected to be needed in the near future.

The terrain may not be loaded immediately upon making this call, and there is no guarantee that the terrain areas will be available for intersection immediately after making this call.

Parameters:

preloadGeometry A list of the geometric areas that should be preloaded. They can be specified using any of the subclasses of DtTerrainPagingGeometry.

Note:: The geometry set with this call completely replaces any geometry previously set using this call.; This call may be a noop depending on what type of terrain is loaded.

virtual const DtTerrainCapabilities* DtTerrainInterface::terrainCapabilities ( ) const [virtual]

Returns:: A class which describes the capabilities of the currently loaded terrain. This provides a guide on particular features of the terrain implementation that are supported or not supported, and should guide the user of the DtTerrainInterface API when interacting with this terrain. If no terrain is loaded, this will return a null pointer.

virtual bool DtTerrainInterface::intersectVectorNetwork	(	const DtChord &	chord,
		DtVectorNetworkRecord *	vectorRecord,
		DtVectorNetworkIntersectionRecord *	vectorIntersectionRecord
	)		const `[virtual]`

User passes in the chord to intersect the vector network and the vectorRecord defining the desired search parameters like the kind of features to be searched.

Returns the best feature intersection and associated data in the vectorIntersectionRecord.

virtual bool DtTerrainInterface::intersectVectorNetwork	(	const DtVector &	localLocation,
		DtVectorNetworkRecord *	vectorRecord,
		DtVectorNetworkIntersectionRecord *	vectorIntersectionRecord
	)		const `[virtual]`

User passes in the location to intersect the vector network and the vectorRecord defining the desired search parameters like the kind of features to be searched.

Returns the best feature intersection and associated data in the vectorIntersectionRecord. The function internally creates a chord to perform the intersection.

virtual bool DtTerrainInterface::addTerrainPassThroughLayer ( const DtString & layerType ) [virtual]

Adds a pass though layer registered with the specified type to the currently loaded terrain implementation.

This is typically a debugging or analysis activity.

virtual void DtTerrainInterface::setAssertOnBlockingTerrainCalls ( bool assertBlock ) [virtual]

Determines if an exception should be thrown if a blocking terrain call is made.

This can help to track down blocking terrain calls which are causing problems with a running simulation. Note that calling the blocking form of any terrain intersection function will cause an assertion; it is not necessary for the call to actually block and even non-paging implementations will assert. This is done to make it easier to find potential problems regardless of the particular terrain or location being used.

virtual bool DtTerrainInterface::assertOnBlockingTerrainCalls ( ) const [virtual]

Determines if an exception should be thrown if a blocking terrain call is made.

This can help to track down blocking terrain calls which are causing problems with a running simulation. Note that calling the blocking form of any terrain intersection function will cause an assertion; it is not necessary for the call to actually block and even non-paging implementations will assert. This is done to make it easier to find potential problems regardless of the particular terrain or location being used.

virtual void DtTerrainInterface::setIntersectDataLoadExpireTime ( const double & expireTime ) [virtual]

Set the default expiration time for data load requests generated by intersect calls that require data that has not been loaded (paged-in).

Parameters:

expireTime The expiration time to be assigned to data load requests generated by intersect calls on the terrain implementation.

virtual void DtTerrainInterface::expireDataLoadRequestsBeforeTime ( const double & currentTime ) [virtual]

virtual void DtTerrainInterface::setDataPath ( const std::string & ) [virtual]

Sets the path to find for the data directory.

For terrains being loaded, will substitute DataDirectory for the dataPath (default to ../data) and UserDataDirectory to the user data path (default to ../userData)

virtual std::string DtTerrainInterface::dataPath ( ) const [virtual]

virtual void DtTerrainInterface::setUserDataPath ( const std::string & ) [virtual]

Sets the path to find for the data directory.

For terrains being loaded, will substitute DataDirectory for the dataPath (default to ../data) and UserDataDirectory to the user data path (default to ../userData)

virtual std::string DtTerrainInterface::userDataPath ( ) const [virtual]

virtual void DtTerrainInterface::trianglesInArea	(	DtTriangleCallbackFcn	func,
		DtTriangleCallbackFinalizeFcn	finalize,
		DtTerrainProcessPolygonsBox &	box,
		void *	usr
	)		const `[virtual]`

Calls the function in the first argument on each triangle in the area specified by the box.

Once all of the triangles have been processed, it calls the finalize function to signify it has completed.

Parameters:

func	Function that will handle a single terrain triangle
finalize	Function that will handle when this function is completed
box	The area (in local coordinates) in which to get terrain triangles from
usr	The object that owns both the first and second argument of this function