212 lines
9.4 KiB
C++
212 lines
9.4 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Revision: $
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef ISPATIALPARTITION_H
|
|
#define ISPATIALPARTITION_H
|
|
|
|
#include "tier1/interface.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class Vector;
|
|
struct Ray_t;
|
|
class IHandleEntity;
|
|
|
|
#define INTERFACEVERSION_SPATIALPARTITION "SpatialPartition001"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// These are the various partition lists. Note some are server only, some
|
|
// are client only
|
|
//-----------------------------------------------------------------------------
|
|
|
|
enum {
|
|
PARTITION_ENGINE_SOLID_EDICTS =
|
|
(1 << 0), // every edict_t that isn't SOLID_TRIGGER or SOLID_NOT (and
|
|
// static props)
|
|
PARTITION_ENGINE_TRIGGER_EDICTS =
|
|
(1 << 1), // every edict_t that IS SOLID_TRIGGER
|
|
PARTITION_CLIENT_SOLID_EDICTS = (1 << 2),
|
|
PARTITION_CLIENT_RESPONSIVE_EDICTS =
|
|
(1 << 3), // these are client-side only objects that respond to being
|
|
// forces, etc.
|
|
PARTITION_ENGINE_NON_STATIC_EDICTS =
|
|
(1 << 4), // everything in solid & trigger except the static props,
|
|
// includes SOLID_NOTs
|
|
PARTITION_CLIENT_STATIC_PROPS = (1 << 5),
|
|
PARTITION_ENGINE_STATIC_PROPS = (1 << 6),
|
|
PARTITION_CLIENT_NON_STATIC_EDICTS =
|
|
(1 << 7), // everything except the static props
|
|
};
|
|
|
|
// Use this to look for all client edicts.
|
|
#define PARTITION_ALL_CLIENT_EDICTS \
|
|
(PARTITION_CLIENT_NON_STATIC_EDICTS | PARTITION_CLIENT_STATIC_PROPS | \
|
|
PARTITION_CLIENT_RESPONSIVE_EDICTS | PARTITION_CLIENT_SOLID_EDICTS)
|
|
|
|
// These are the only handles in the spatial partition that the game is
|
|
// controlling (everything but static props) These masks are used to handle
|
|
// updating the dirty spatial partition list in each game DLL
|
|
#define PARTITION_CLIENT_GAME_EDICTS \
|
|
(PARTITION_ALL_CLIENT_EDICTS & ~PARTITION_CLIENT_STATIC_PROPS)
|
|
#define PARTITION_SERVER_GAME_EDICTS \
|
|
(PARTITION_ENGINE_SOLID_EDICTS | PARTITION_ENGINE_TRIGGER_EDICTS | \
|
|
PARTITION_ENGINE_NON_STATIC_EDICTS)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Clients that want to know about all elements within a particular
|
|
// volume must inherit from this
|
|
//-----------------------------------------------------------------------------
|
|
|
|
enum IterationRetval_t {
|
|
ITERATION_CONTINUE = 0,
|
|
ITERATION_STOP,
|
|
};
|
|
|
|
typedef unsigned short SpatialPartitionHandle_t;
|
|
|
|
// A combination of the PARTITION_ flags above.
|
|
typedef int SpatialPartitionListMask_t;
|
|
|
|
typedef int SpatialTempHandle_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Any search in the CSpatialPartition must use this to filter out entities it
|
|
// doesn't want. You're forced to use listMasks because it can filter by
|
|
// listMasks really fast. Any other filtering can be done by EnumElement.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class IPartitionEnumerator {
|
|
public:
|
|
virtual IterationRetval_t EnumElement(IHandleEntity* pHandleEntity) = 0;
|
|
// XXX(johns): This should have a virtual destructor, but would be ABI
|
|
// breaking (non-versioned interface implemented
|
|
// by the game)
|
|
// virtual ~IPartitionEnumerator(){}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Installs a callback to call right before a spatial partition query occurs
|
|
//-----------------------------------------------------------------------------
|
|
class IPartitionQueryCallback {
|
|
public:
|
|
virtual void OnPreQuery_V1() = 0;
|
|
virtual void OnPreQuery(SpatialPartitionListMask_t listMask) = 0;
|
|
virtual void OnPostQuery(SpatialPartitionListMask_t listMask) = 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is the spatial partition manager, groups objects into buckets
|
|
//-----------------------------------------------------------------------------
|
|
enum { PARTITION_INVALID_HANDLE = (SpatialPartitionHandle_t)~0 };
|
|
|
|
abstract_class ISpatialPartition {
|
|
public:
|
|
// Add a virtual destructor to silence the clang warning.
|
|
// This is harmless but not important since the only derived class
|
|
// doesn't have a destructor.
|
|
virtual ~ISpatialPartition() {}
|
|
|
|
// Create/destroy a handle for this dude in our system. Destroy
|
|
// will also remove it from all lists it happens to be in
|
|
virtual SpatialPartitionHandle_t CreateHandle(IHandleEntity *
|
|
pHandleEntity) = 0;
|
|
|
|
// A fast method of creating a handle + inserting into the tree in the right
|
|
// place
|
|
virtual SpatialPartitionHandle_t CreateHandle(
|
|
IHandleEntity * pHandleEntity, SpatialPartitionListMask_t listMask,
|
|
const Vector& mins, const Vector& maxs) = 0;
|
|
|
|
virtual void DestroyHandle(SpatialPartitionHandle_t handle) = 0;
|
|
|
|
// Adds, removes an handle from a particular spatial partition list
|
|
// There can be multiple partition lists; each has a unique id
|
|
virtual void Insert(SpatialPartitionListMask_t listMask,
|
|
SpatialPartitionHandle_t handle) = 0;
|
|
virtual void Remove(SpatialPartitionListMask_t listMask,
|
|
SpatialPartitionHandle_t handle) = 0;
|
|
|
|
// Same as calling Remove() then Insert(). For performance-sensitive areas
|
|
// where you want to save a call.
|
|
virtual void RemoveAndInsert(SpatialPartitionListMask_t removeMask,
|
|
SpatialPartitionListMask_t insertMask,
|
|
SpatialPartitionHandle_t handle) = 0;
|
|
|
|
// This will remove a particular handle from all lists
|
|
virtual void Remove(SpatialPartitionHandle_t handle) = 0;
|
|
|
|
// Call this when an entity moves...
|
|
virtual void ElementMoved(SpatialPartitionHandle_t handle,
|
|
const Vector& mins, const Vector& maxs) = 0;
|
|
|
|
// A fast method to insert + remove a handle from the tree...
|
|
// This is used to suppress collision of a single model..
|
|
virtual SpatialTempHandle_t HideElement(
|
|
SpatialPartitionHandle_t handle) = 0;
|
|
virtual void UnhideElement(SpatialPartitionHandle_t handle,
|
|
SpatialTempHandle_t tempHandle) = 0;
|
|
|
|
// Installs callbacks to get called right before a query occurs
|
|
virtual void InstallQueryCallback_V1(IPartitionQueryCallback *
|
|
pCallback) = 0;
|
|
virtual void RemoveQueryCallback(IPartitionQueryCallback * pCallback) = 0;
|
|
|
|
// Gets all entities in a particular volume...
|
|
// if coarseTest == true, it'll return all elements that are in
|
|
// spatial partitions that intersect the box
|
|
// if coarseTest == false, it'll return only elements that truly intersect
|
|
virtual void EnumerateElementsInBox(SpatialPartitionListMask_t listMask,
|
|
const Vector& mins, const Vector& maxs,
|
|
bool coarseTest,
|
|
IPartitionEnumerator* pIterator) = 0;
|
|
|
|
virtual void EnumerateElementsInSphere(
|
|
SpatialPartitionListMask_t listMask, const Vector& origin, float radius,
|
|
bool coarseTest, IPartitionEnumerator* pIterator) = 0;
|
|
|
|
virtual void EnumerateElementsAlongRay(SpatialPartitionListMask_t listMask,
|
|
const Ray_t& ray, bool coarseTest,
|
|
IPartitionEnumerator* pIterator) = 0;
|
|
|
|
virtual void EnumerateElementsAtPoint(SpatialPartitionListMask_t listMask,
|
|
const Vector& pt, bool coarseTest,
|
|
IPartitionEnumerator* pIterator) = 0;
|
|
|
|
// For debugging.... suppress queries on particular lists
|
|
virtual void SuppressLists(SpatialPartitionListMask_t nListMask,
|
|
bool bSuppress) = 0;
|
|
virtual SpatialPartitionListMask_t GetSuppressedLists() = 0;
|
|
|
|
virtual void RenderAllObjectsInTree(float flTime) = 0;
|
|
virtual void RenderObjectsInPlayerLeafs(const Vector& vecPlayerMin,
|
|
const Vector& vecPlayerMax,
|
|
float flTime) = 0;
|
|
virtual void RenderLeafsForRayTraceStart(float flTime) = 0;
|
|
virtual void RenderLeafsForRayTraceEnd(void) = 0;
|
|
virtual void RenderLeafsForHullTraceStart(float flTime) = 0;
|
|
virtual void RenderLeafsForHullTraceEnd(void) = 0;
|
|
virtual void RenderLeafsForBoxStart(float flTime) = 0;
|
|
virtual void RenderLeafsForBoxEnd(void) = 0;
|
|
virtual void RenderLeafsForSphereStart(float flTime) = 0;
|
|
virtual void RenderLeafsForSphereEnd(void) = 0;
|
|
|
|
virtual void RenderObjectsInBox(const Vector& vecMin, const Vector& vecMax,
|
|
float flTime) = 0;
|
|
virtual void RenderObjectsInSphere(const Vector& vecCenter, float flRadius,
|
|
float flTime) = 0;
|
|
virtual void RenderObjectsAlongRay(const Ray_t& ray, float flTime) = 0;
|
|
|
|
virtual void ReportStats(const char* pFileName) = 0;
|
|
|
|
virtual void InstallQueryCallback(IPartitionQueryCallback * pCallback) = 0;
|
|
};
|
|
|
|
#endif
|