csgo/cstrike15_src/public/fow/fow.h

//========= Copyright © 1996-2009, Valve Corporation, All rights reserved. ============//
//
// Purpose: this is the only public access point to the Fog of War routines
//
// $NoKeywords: $
//=====================================================================================//

#ifndef FOW_H
#define FOW_H
#if defined( COMPILER_MSVC )
#pragma once
#endif


#include "utlvector.h"
#include "utlmap.h"
#include "utlspheretree.h"


class CFoW_RadiusOccluder;
class CFoW_Viewer;
class CFoW_TriSoupCollection;
class CFoW_LineOccluder;
class CFoW_HorizontalSlice;
class IFileSystem;
class CPhysCollide;
class IPhysicsCollision;


// maximum number of unique visible sides / teams
#define MAX_FOW_TEAMS	2


// fow does maximum amount of safety checks for data coming into it
#define FOW_SAFETY_DANCE	1


// bit pattern for Visibility Grid
#define FOW_VG_MAX_HEIGHT_GROUP		0x07	// only support height groups from 0 to 7
#define FOW_VG_UNUSED				0x08	// unused
#define FOW_VG_DEFAULT_VISIBLE		0x10	// future optimization to mark default viewing radius
#define FOW_VG_IS_VISIBLE			0x20	// cell is currently visible
#define FOW_VG_WAS_VISIBLE			0x40	// cell has been visible at one point in the past
#define FOW_VG_INVALID				0x80	// invalid cell location


// debug flags
#define FOW_DEBUG_SHOW_VIEWERS_TEAM_0		0x00000001
#define FOW_DEBUG_SHOW_OCCLUDERS			0x00000002
#define FOW_DEBUG_SHOW_GRID					0x00000004
#define FOW_DEBUG_SHOW_VIEWERS_TEAM_1		0x00000008

#define FOW_DEBUG_VIEW_TIME			( 1.0f / 15.0f )
//#define FOW_DEBUG_VIEW_TIME			( 0 )

// fow limits
#define FOW_MAX_VIEWERS_TO_CHECK			100
#define FOW_MAX_RADIUS_OCCLUDERS_TO_CHECK	400
#define FOW_MAX_LINE_OCCLUDERS_TO_CHECK		400
#define FOW_OVER_VISIBILITY					1.5f	// keeps around a fully visibile area a bit longer
#define FOW_FADE_DELAY						0.25f;	// helps control flickering on edge cases when viewers are moving

class CFoW
{
public:
			CFoW( );
			~CFoW( );

	// setup
			// Frees all memory
	void	ClearState( );
			// Sets the number of viewer teams
	void	SetNumberOfTeams( int nCount );
			// Sets the world mins/maxs and how big the grid sizes should be
	void	SetSize( Vector &vWorldMins, Vector &vWorldMaxs, int nHorizontalGridSize, int nVerticalGridSize = -1 );
			//
	void	SetCustomVerticalLevels( float *pflHeightLevels, int nCount );
			// Sets the visibility degree fade rate ( in seconds )
	void	SetDegreeFadeRate( float flDegreeFadeRate ) { m_flDegreeFadeRate = flDegreeFadeRate; }

	// fow system info
				// are we initialized?
	bool		IsInitialized( ) { return m_bInitialized; }
				// get the world size of the FoW
	void		GetSize( Vector &vWorldMins, Vector &vWorldMaxs );
				// get the horizontal grid size
	inline int	GetHorizontalGridSize( ) { return m_nHorizontalGridSize; }
				//
	int			GetXGridUnits( ) { return m_nGridXUnits; }
				//
	int			GetYGridUnits( ) { return m_nGridYUnits; }
				// get the lower vertical coord, the grid size, and grid units
	void		GetVerticalGridInfo( int &nBottomZ, int &nGridSize, int &nGridUnits, float **pVerticalLevels );
				// snap the x/y coordinates to the grid
	void		SnapCoordsToGrid( Vector &vIn, Vector &vOut, bool bGoLower );
				// return how visible a cell is ( 0.0 = not currently visible, 1.0 = fully visible )
	float		LookupVisibilityDegree( int nXLoc, int nYLoc, int nTeam );
				// creates or returns a grid to radius table
	int			*FindRadiusTable( float flRadius );
				//
	void		CenterCoordToGrid( Vector &vCoords );

	// debug info
				// 
	void		SetDebugVisibility( bool bVisible );
				// 
	void		EnableDebugFlags( unsigned nFlags );
				// 
	void		DisableDebugFlags( unsigned nFlags );
				//
	void		DrawDebugInfo( Vector &vLocation, float flViewRadius );
				//
	void		PrintStats( );

	// viewers
				// adds a new viewer to the system
	int			AddViewer( unsigned nViewerTeam );
				// removes a viewer from the system
	void		RemoveViewer( int nID );
				// updates the viewer's location
	void		UpdateViewerLocation( int nID, const Vector &vLocation );
				// updates the viewer's seeing radius
	void		UpdateViewerSize( int nID, float flRadius );
				// updates the viewer's seeing radius
	void		UpdateViewerHeightGroup( int nID, uint8 nHeightGroup );

	// radius occluders
								// adds a new radius occluder to the system
	int							AddOccluder( bool nPermanent );
								// removes an occluder from the system
	void						RemoveOccluder( int nID );
	void						EnableOccluder( int nID, bool bEnable );
								// returns the total number of radius occluders
	inline int					GetNumOccluders() { return m_Occluders.Count(); }
								// get access to the radius occluder object
	inline CFoW_RadiusOccluder	*GetOccluder( int nIndex ) { return m_Occluders[ nIndex ]; }
								// update an occluder's location
	void						UpdateOccluderLocation( int nID, Vector &vLocation );
								// update an occluder's size
	void						UpdateOccluderSize( int nID, float flRadius );
								// updates the occluder's height group
	void						UpdateOccluderHeightGroup( int nID, uint8 nHeightGroup );
								// internal function called by viewers to radius occlude nearby objects
	void						ObstructOccludersNearViewer( int nViewerID );

	// world occlusion
	void	SetWorldCollision( CPhysCollide *pCollideable, IPhysicsCollision *pPhysCollision );

	// tri soup ( line ) occluders
							// adds a tri soup collection to the system
	int						AddTriSoup( );
							// removes a tri soup collection from the system
	void					RemoveTriSoup( int nID );
							// clears all entries from the collection ( useful for hammer editing only )
	void					ClearTriSoup( int nID );
							// adds a tri to the collection.  this is immediately split up into the horizontal slices.  very slow!
	void					AddTri( int nID, Vector &vPointA, Vector &vPointB, Vector &vPointC );
							//
	int						GetNumTriSoups( ) { return m_TriSoupCollection.Count(); }
							// get access to a tri soup collection object
	CFoW_TriSoupCollection	*GetTriSoup( int nID );
							// add a line occulder from a horizontal slice
	void					AddTriSoupOccluder( CFoW_LineOccluder *pOccluder, int nSliceNum );

	// horizontal slices ( from tri soups )
								// get the slice index given the vertical position
	int							GetHorizontalSlice( float flZPos );
								//
	float						GetSliceZPosition( int nIndex ) { return m_pVerticalLevels[ nIndex ]; } 
								// get access to the slice object
	inline CFoW_HorizontalSlice	*GetSlice( int nIndex ) { return m_pHorizontalSlices[ nIndex ]; }

	// visibility
			// solve the visibility for all teams and all viewers - slow!
	void	SolveVisibility( float flFrameTime );
			// Purpose: returns the visibility info of a location to a team
	uint8	GetLocationInfo( unsigned nViewerTeam, const Vector &vLocation );
			// Purpose: returns the visibility degree of a location to a team
	float	GetLocationVisibilityDegree( unsigned nViewerTeam, const Vector &vLocation, float flRadius = 0.0f );
			// given the coords and an offset to move BACK, finds the grid location
	void	GetGridUnits( const Vector &vCoords, float flXOffset, float flYOffset, bool bGoLower, int &nGridX, int &nGridY );

	// debug
			// Generates a vmf file based upon the current viewers and occluders
	void	GenerateVMF( IFileSystem *pFileSystem, const char *pszFileName );

private:
			// adds an occluder to the sphere tree
	void	InsertViewerIntoTree( int nIndex );
			// removes an occluder from the sphere tree
	void	RemoveViewerFromTree( int nIndex, Vector *pvOldLocation = NULL );
			//
	void	DirtyViewers( Vector &vLocation, float flRadius );
			// adds all occluders back into the visibility tree
	void	RepopulateOccluders( );
			// adds an occluder to the sphere tree
	void	InsertOccluderIntoTree( int nIndex );
			// removes an occluder from the sphere tree
	void	RemoveOccluderFromTree( int nIndex );
			// defaults the viewing grids
	void	PrepVisibility( );
			// updates the viewer grids
	void	UpdateVisibleAmounts( float flFrameTime );
			// given the coords and an offset to move BACK, finds the grid index
	int		GetGridIndex( const Vector &vCoords, float flXOffset, float flYOffset, bool bGoLower );
			// merge a local viewer's visibility to the global grid
	void	MergeViewerVisibility( int nID );

private:
	bool	m_bInitialized;				// fow system is ready
	int		m_nNumberOfTeams;			// number of teams
	Vector	m_vWorldMins;				// world mins
	Vector	m_vWorldMaxs;				// world maxs
	float	m_flDegreeFadeRate;			// fade in rate for visibility degree
	int		m_nHorizontalGridSize;		// the horizontal ( x y ) grid size
	int		m_nVerticalGridSize;		// the vertical ( z ) grid size
	int		m_nGridXUnits;				// number of X grid pieces ( world X size / horizontal grid size ) rounded up
	int		m_nGridYUnits;				// number of Y grid pieces ( world Y size / horizontal grid size ) rounded up
	int		m_nTotalHorizontalUnits;	// X * Y grid pieces
	int		m_nGridZUnits;				// number of Z grid pieces ( world Z size / vertical grid size ) rounded up

	float32					*m_pVisibilityGridDegree[ MAX_FOW_TEAMS ];	// the degree of visibility ( 0.0 = not visible, 1.0 = visible )
	float32					*m_pVisibilityFadeTimer[ MAX_FOW_TEAMS ];	// the delay before visibility starts to fade
	uint8					*m_pVisibilityGridFlags[ MAX_FOW_TEAMS ];	// flags to indicate visibility status
	CFoW_HorizontalSlice	**m_pHorizontalSlices;						// horizontal line occluder slices from tri soups
	float32					*m_pVerticalLevels;

	CUtlVector< CFoW_Viewer	* >				m_Viewers;					// the list of all viewers
	CUtlVector< CFoW_RadiusOccluder * >		m_Occluders;				// the list of all radius occluders
	CUtlSphereTree							m_ViewerTree;				// sphere tree for quick finding of nearby viewers
	CUtlSphereTree							m_OccluderTree;				// sphere tree for quick finding of nearby radius occluders
	CUtlVector< CFoW_TriSoupCollection * >	m_TriSoupCollection;		// the list of all tri soups
	CUtlMap< float, int * >					m_RadiusTables;				// the cached visibility tables to go from grid to radius

	// debug info
	bool					m_bDebugVisible;
	unsigned				m_nDebugFlags;
	size_t					m_nHorizontalGridAllocationSize;
	size_t					m_nVerticalGridAllocationSize;
	size_t					m_nRadiusTableSize;

	friend void PrepVisibilityThreaded( CFoW *pFoW );
};


#endif // FOW_H