env_render: reset entity on start round

This commit is contained in:
s1lent 2017-07-04 19:31:14 +07:00
parent f0409ce468
commit 721624bf92
No known key found for this signature in database
GPG Key ID: 0FE401DC73916B5C
10 changed files with 1648 additions and 145 deletions

View File

@ -52,16 +52,6 @@ TYPEDESCRIPTION CEnvSpark::m_SaveData[] =
#endif // HOOK_GAMEDLL
#ifdef REGAMEDLL_FIXES
TYPEDESCRIPTION CRotButton::m_SaveData[] =
{
DEFINE_FIELD(CRotButton, m_vecSpawn, FIELD_VECTOR),
};
#endif
IMPLEMENT_SAVERESTORE(CEnvGlobal, CBaseEntity)
LINK_ENTITY_TO_CLASS(env_global, CEnvGlobal, CCSEnvGlobal)
@ -842,6 +832,17 @@ void CBaseButton::ButtonBackHome()
}
}
#ifdef REGAMEDLL_FIXES
TYPEDESCRIPTION CRotButton::m_SaveData[] =
{
DEFINE_FIELD(CRotButton, m_vecSpawn, FIELD_VECTOR),
};
IMPLEMENT_SAVERESTORE(CRotButton, CBaseButton)
#endif
LINK_ENTITY_TO_CLASS(func_rot_button, CRotButton, CCSRotButton)
void CRotButton::Spawn()

View File

@ -78,7 +78,8 @@ public:
#ifdef REGAMEDLL_FIXES
virtual void Restart();
virtual int Save(CSave &save);
virtual int Restore(CRestore &restore);
public:
static TYPEDESCRIPTION m_SaveData[1];
Vector m_vecSpawn;

View File

@ -695,6 +695,7 @@ void EXT_FUNC CHalfLifeMultiplay::__API_HOOK(CleanUpMap)()
#ifdef REGAMEDLL_FIXES
UTIL_RestartOther("func_button");
UTIL_RestartOther("func_rot_button");
UTIL_RestartOther("env_render");
UTIL_RestartOther("trigger_push");
#endif

View File

@ -403,30 +403,87 @@ void CRenderFxManager::Spawn()
pev->solid = SOLID_NOT;
}
#ifdef REGAMEDLL_FIXES
void CRenderFxManager::UpdateOnRemove()
{
m_RenderGroups.RemoveAll();
}
void CRenderFxManager::Restart()
{
if (FStringNull(pev->target))
return;
edict_t *pentTarget = nullptr;
while ((pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->target))))
{
if (FNullEnt(pentTarget))
break;
entvars_t *pevTarget = VARS(pentTarget);
// find render groups in our list of backup
int index = m_RenderGroups.Find(ENTINDEX(pevTarget));
if (index == m_RenderGroups.InvalidIndex()) {
// not found
continue;
}
RenderGroup_t *pGroup = &m_RenderGroups[ index ];
if (!(pev->spawnflags & SF_RENDER_MASKFX))
pevTarget->renderfx = pGroup->renderfx;
if (!(pev->spawnflags & SF_RENDER_MASKAMT))
pevTarget->renderamt = pGroup->renderamt;
if (!(pev->spawnflags & SF_RENDER_MASKMODE))
pevTarget->rendermode = pGroup->rendermode;
if (!(pev->spawnflags & SF_RENDER_MASKCOLOR))
pevTarget->rendercolor = pGroup->rendercolor;
}
}
#endif // REGAMEDLL_FIXES
void CRenderFxManager::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
if (!FStringNull(pev->target))
if (FStringNull(pev->target))
return;
edict_t *pentTarget = nullptr;
while ((pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->target))))
{
edict_t *pentTarget = NULL;
while ((pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->target))) != NULL)
{
if (FNullEnt(pentTarget))
break;
if (FNullEnt(pentTarget))
break;
entvars_t *pevTarget = VARS(pentTarget);
entvars_t *pevTarget = VARS(pentTarget);
if (!(pev->spawnflags & SF_RENDER_MASKFX))
pevTarget->renderfx = pev->renderfx;
#ifdef REGAMEDLL_FIXES
RenderGroup_t group;
group.renderfx = pevTarget->renderfx;
group.renderamt = pevTarget->renderamt;
group.rendermode = pevTarget->rendermode;
group.rendercolor = pevTarget->rendercolor;
if (!(pev->spawnflags & SF_RENDER_MASKAMT))
pevTarget->renderamt = pev->renderamt;
if (!(pev->spawnflags & SF_RENDER_MASKMODE))
pevTarget->rendermode = pev->rendermode;
if (!(pev->spawnflags & SF_RENDER_MASKCOLOR))
pevTarget->rendercolor = pev->rendercolor;
int entityIndex = ENTINDEX(pevTarget);
if (m_RenderGroups.Find(entityIndex) == m_RenderGroups.InvalidIndex()) {
m_RenderGroups.Insert(entityIndex, group);
}
#endif
if (!(pev->spawnflags & SF_RENDER_MASKFX))
pevTarget->renderfx = pev->renderfx;
if (!(pev->spawnflags & SF_RENDER_MASKAMT))
pevTarget->renderamt = pev->renderamt;
if (!(pev->spawnflags & SF_RENDER_MASKMODE))
pevTarget->rendermode = pev->rendermode;
if (!(pev->spawnflags & SF_RENDER_MASKCOLOR))
pevTarget->rendercolor = pev->rendercolor;
}
}

View File

@ -32,6 +32,8 @@
#pragma once
#endif
#include "utlmap.h"
#define GRENADETYPE_SMOKE 1
#define GRENADETYPE_FLASH 2
@ -197,6 +199,22 @@ class CRenderFxManager: public CBaseEntity
public:
virtual void Spawn();
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef REGAMEDLL_FIXES
virtual void Restart();
virtual void UpdateOnRemove();
public:
struct RenderGroup_t
{
int rendermode;
float renderamt;
Vector rendercolor;
int renderfx;
};
CUtlMap<int, RenderGroup_t> m_RenderGroups;
#endif
};
class CBaseTrigger: public CBaseToggle

View File

@ -66,6 +66,8 @@ class CRotButton: public CBaseButton {
public:
virtual void Spawn() = 0;
virtual void Restart() = 0;
virtual int Save(CSave &save) = 0;
virtual int Restore(CRestore &restore) = 0;
public:
Vector m_vecSpawn;
};

View File

@ -27,6 +27,8 @@
*/
#pragma once
#include "utlmap.h"
#define GRENADETYPE_SMOKE 1
#define GRENADETYPE_FLASH 2
@ -140,7 +142,18 @@ public:
class CRenderFxManager: public CBaseEntity {
public:
virtual void Spawn() = 0;
virtual void Restart() = 0;
virtual void UpdateOnRemove() = 0;
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) = 0;
public:
struct RenderGroup_t
{
int rendermode;
float renderamt;
Vector rendercolor;
int renderfx;
};
CUtlMap<int, RenderGroup_t> m_RenderGroups;
};
class CBaseTrigger: public CBaseToggle {

261
regamedll/public/utlmap.h Normal file
View File

@ -0,0 +1,261 @@
/*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#pragma once
#include "tier0/dbg.h"
#include "utlrbtree.h"
// Purpose: An associative container. Pretty much identical to std::map.
// This is a useful macro to iterate from start to end in order in a map
#define FOR_EACH_MAP(mapName, iteratorName)\
for (int iteratorName = (mapName).FirstInorder(); (mapName).IsUtlMap && iteratorName != (mapName).InvalidIndex(); iteratorName = (mapName).NextInorder(iteratorName))
// faster iteration, but in an unspecified order
#define FOR_EACH_MAP_FAST(mapName, iteratorName)\
for (int iteratorName = 0; (mapName).IsUtlMap && iteratorName < (mapName).MaxElement(); ++iteratorName) if (!(mapName).IsValidIndex(iteratorName)) continue; else
struct base_utlmap_t
{
public:
// This enum exists so that FOR_EACH_MAP and FOR_EACH_MAP_FAST cannot accidentally
// be used on a type that is not a CUtlMap. If the code compiles then all is well.
// The check for IsUtlMap being true should be free.
// Using an enum rather than a static const bool ensures that this trick works even
// with optimizations disabled on gcc.
enum CompileTimeCheck
{
IsUtlMap = 1
};
};
template <typename K, typename T, typename I = unsigned short>
class CUtlMap: public base_utlmap_t
{
public:
typedef K KeyType_t;
typedef T ElemType_t;
typedef I IndexType_t;
// Less func typedef
// Returns true if the first parameter is "less" than the second
typedef bool (*LessFunc_t)(const KeyType_t &, const KeyType_t &);
// constructor, destructor
// Left at growSize = 0, the memory will first allocate 1 element and double in size
// at each increment.
// LessFunc_t is required, but may be set after the constructor using SetLessFunc() below
CUtlMap(int growSize = 0, int initSize = 0, LessFunc_t lessfunc = 0)
: m_Tree(growSize, initSize, CKeyLess(lessfunc))
{
if (!lessfunc) {
SetLessFunc(DefLessFunc(K));
}
}
CUtlMap(LessFunc_t lessfunc)
: m_Tree(CKeyLess(lessfunc))
{
if (!lessfunc) {
SetLessFunc(DefLessFunc(K));
}
}
void EnsureCapacity(int num) { m_Tree.EnsureCapacity(num); }
// gets particular elements
ElemType_t & Element(IndexType_t i) { return m_Tree.Element(i).elem; }
const ElemType_t & Element(IndexType_t i) const { return m_Tree.Element(i).elem; }
ElemType_t & operator[](IndexType_t i) { return m_Tree.Element(i).elem; }
const ElemType_t & operator[](IndexType_t i) const { return m_Tree.Element(i).elem; }
KeyType_t & Key(IndexType_t i) { return m_Tree.Element(i).key; }
const KeyType_t & Key(IndexType_t i) const { return m_Tree.Element(i).key; }
// Num elements
unsigned int Count() const { return m_Tree.Count(); }
// Max "size" of the vector
IndexType_t MaxElement() const { return m_Tree.MaxElement(); }
// Checks if a node is valid and in the map
bool IsValidIndex(IndexType_t i) const { return m_Tree.IsValidIndex(i); }
// Checks if the map as a whole is valid
bool IsValid() const { return m_Tree.IsValid(); }
// Invalid index
static IndexType_t InvalidIndex() { return CTree::InvalidIndex(); }
// Sets the less func
void SetLessFunc(LessFunc_t func)
{
m_Tree.SetLessFunc(CKeyLess(func));
}
// Insert method (inserts in order)
IndexType_t Insert(const KeyType_t &key, const ElemType_t &insert)
{
Node_t node;
node.key = key;
node.elem = insert;
return m_Tree.Insert(node);
}
IndexType_t Insert(const KeyType_t &key)
{
Node_t node;
node.key = key;
return m_Tree.Insert(node);
}
// Find method
IndexType_t Find(const KeyType_t &key) const
{
Node_t dummyNode;
dummyNode.key = key;
return m_Tree.Find(dummyNode);
}
// Remove methods
void RemoveAt(IndexType_t i) { m_Tree.RemoveAt(i); }
bool Remove(const KeyType_t &key)
{
Node_t dummyNode;
dummyNode.key = key;
return m_Tree.Remove(dummyNode);
}
void RemoveAll() { m_Tree.RemoveAll(); }
void Purge() { m_Tree.Purge(); }
// Purges the list and calls delete on each element in it.
void PurgeAndDeleteElements();
// Iteration
IndexType_t FirstInorder() const { return m_Tree.FirstInorder(); }
IndexType_t NextInorder(IndexType_t i) const { return m_Tree.NextInorder(i); }
IndexType_t PrevInorder(IndexType_t i) const { return m_Tree.PrevInorder(i); }
IndexType_t LastInorder() const { return m_Tree.LastInorder(); }
// If you change the search key, this can be used to reinsert the
// element into the map.
void Reinsert(const KeyType_t &key, IndexType_t i)
{
m_Tree[i].key = key;
m_Tree.Reinsert(i);
}
IndexType_t InsertOrReplace(const KeyType_t &key, const ElemType_t &insert)
{
IndexType_t i = Find(key);
if (i != InvalidIndex())
{
Element(i) = insert;
return i;
}
return Insert(key, insert);
}
void Swap(CUtlMap<K, T, I> &that)
{
m_Tree.Swap(that.m_Tree);
}
struct Node_t
{
Node_t()
{
}
Node_t(const Node_t &from)
: key(from.key),
elem(from.elem)
{
}
KeyType_t key;
ElemType_t elem;
};
class CKeyLess
{
public:
CKeyLess(LessFunc_t lessFunc) : m_LessFunc(lessFunc) {}
bool operator!() const
{
return !m_LessFunc;
}
bool operator()(const Node_t &left, const Node_t &right) const
{
return m_LessFunc(left.key, right.key);
}
LessFunc_t m_LessFunc;
};
typedef CUtlRBTree<Node_t, I, CKeyLess> CTree;
CTree *AccessTree() { return &m_Tree; }
protected:
CTree m_Tree;
};
// Purges the list and calls delete on each element in it.
template <typename K, typename T, typename I>
inline void CUtlMap<K, T, I>::PurgeAndDeleteElements()
{
for (I i = 0; i < MaxElement(); ++i)
{
if (!IsValidIndex(i))
continue;
delete Element(i);
}
Purge();
}
// This is horrible and slow and meant to be used only when you're dealing with really
// non-time/memory-critical code and desperately want to copy a whole map element-by-element
// for whatever reason.
template <typename K, typename T, typename I>
void DeepCopyMap(const CUtlMap<K, T, I> &pmapIn, CUtlMap<K, T, I> *out_pmapOut)
{
Assert(out_pmapOut);
out_pmapOut->Purge();
FOR_EACH_MAP_FAST(pmapIn, i)
{
out_pmapOut->Insert(pmapIn.Key(i), pmapIn.Element(i));
}
}

View File

@ -26,12 +26,7 @@
*
*/
#ifndef UTLMEMORY_H
#define UTLMEMORY_H
#ifdef _WIN32
#pragma once
#endif
#include "osconfig.h"
#include "tier0/dbg.h"
@ -40,55 +35,56 @@
#pragma warning (disable:4100)
#pragma warning (disable:4514)
/*template <class T>
inline void Construct(T *pMemory)
{
::new(pMemory) T;
}
template <class T>
inline void CopyConstruct(T *pMemory,T const& src)
{
::new(pMemory) T(src);
}
template <class T>
inline void Destruct(T *pMemory)
{
pMemory->~T();
#ifdef _DEBUG
memset(pMemory,0xDD,sizeof(T));
#endif
}*/
//-----------------------------------------------------------------------------
// The CUtlMemory class:
// A growable memory class which doubles in size by default.
//-----------------------------------------------------------------------------
template< class T >
template <class T, class I = int>
class CUtlMemory
{
public:
// constructor, destructor
CUtlMemory(int nGrowSize = 0, int nInitSize = 0);
CUtlMemory(T* pMemory, int numElements);
CUtlMemory(T *pMemory, int numElements);
~CUtlMemory();
// Set the size by which the memory grows
void Init(int nGrowSize = 0, int nInitSize = 0);
class Iterator_t
{
public:
Iterator_t(I i) : m_index(i) {}
I m_index;
bool operator==(const Iterator_t it) const { return m_index == it.m_index; }
bool operator!=(const Iterator_t it) const { return m_index != it.m_index; }
};
Iterator_t First() const { return Iterator_t(IsIdxValid(0) ? 0 : InvalidIndex()); }
Iterator_t Next(const Iterator_t &it) const { return Iterator_t(IsIdxValid(it.index + 1) ? it.index + 1 : InvalidIndex()); }
I GetIndex(const Iterator_t &it) const { return it.index; }
bool IsIdxAfter(I i, const Iterator_t &it) const { return i > it.index; }
bool IsValidIterator(const Iterator_t &it) const { return IsIdxValid(it.index); }
Iterator_t InvalidIterator() const { return Iterator_t(InvalidIndex()); }
// element access
T& operator[](int i);
T const& operator[](int i) const;
T& Element(int i);
T const& Element(int i) const;
T& Element(I i);
T const& Element(I i) const;
T& operator[](I i);
T const& operator[](I i) const;
// Can we use this index?
bool IsIdxValid(int i) const;
bool IsIdxValid(I i) const;
// Specify the invalid ('null') index that we'll only return on failure
static const I INVALID_INDEX = (I)-1; // For use with COMPILE_TIME_ASSERT
static I InvalidIndex() { return INVALID_INDEX; }
// Gets the base address (can change when adding elements!)
T* Base();
T const* Base() const;
T *Base();
T const *Base() const;
// Attaches the buffer to external memory....
void SetExternalBuffer(T* pMemory, int numElements);
void SetExternalBuffer(T *pMemory, int numElements);
// Size
int NumAllocated() const;
@ -115,46 +111,54 @@ private:
EXTERNAL_BUFFER_MARKER = -1,
};
T* m_pMemory;
T *m_pMemory;
int m_nAllocationCount;
int m_nGrowSize;
};
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
template< class T >
CUtlMemory<T>::CUtlMemory(int nGrowSize, int nInitAllocationCount) : m_pMemory(0),
m_nAllocationCount(nInitAllocationCount), m_nGrowSize(nGrowSize)
template <class T, class I>
CUtlMemory<T, I>::CUtlMemory(int nGrowSize, int nInitSize) : m_pMemory(0),
m_nAllocationCount(nInitSize), m_nGrowSize(nGrowSize)
{
Assert((nGrowSize >= 0) && (nGrowSize != EXTERNAL_BUFFER_MARKER));
if (m_nAllocationCount)
{
m_pMemory = (T*)malloc(m_nAllocationCount * sizeof(T));
m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T));
}
}
template< class T >
CUtlMemory<T>::CUtlMemory(T* pMemory, int numElements) : m_pMemory(pMemory),
template <class T, class I>
CUtlMemory<T, I>::CUtlMemory(T *pMemory, int numElements) : m_pMemory(pMemory),
m_nAllocationCount(numElements)
{
// Special marker indicating externally supplied memory
m_nGrowSize = EXTERNAL_BUFFER_MARKER;
}
template< class T >
CUtlMemory<T>::~CUtlMemory()
template <class T, class I>
CUtlMemory<T, I>::~CUtlMemory()
{
Purge();
}
template <class T, class I>
void CUtlMemory<T,I>::Init(int nGrowSize, int nInitSize)
{
Purge();
m_nGrowSize = nGrowSize;
m_nAllocationCount = nInitSize;
Assert(nGrowSize >= 0);
if (m_nAllocationCount)
{
m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T));
}
}
//-----------------------------------------------------------------------------
// Attaches the buffer to external memory....
//-----------------------------------------------------------------------------
template< class T >
void CUtlMemory<T>::SetExternalBuffer(T* pMemory, int numElements)
template <class T, class I>
void CUtlMemory<T, I>::SetExternalBuffer(T *pMemory, int numElements)
{
// Blow away any existing allocated memory
Purge();
@ -166,110 +170,91 @@ void CUtlMemory<T>::SetExternalBuffer(T* pMemory, int numElements)
m_nGrowSize = EXTERNAL_BUFFER_MARKER;
}
//-----------------------------------------------------------------------------
// element access
//-----------------------------------------------------------------------------
template< class T >
inline T& CUtlMemory<T>::operator[](int i)
template <class T, class I>
inline T& CUtlMemory<T, I>::operator[](I i)
{
Assert(IsIdxValid(i));
return m_pMemory[i];
}
template< class T >
inline T const& CUtlMemory<T>::operator[](int i) const
template <class T, class I>
inline T const& CUtlMemory<T, I>::operator[](I i) const
{
Assert(IsIdxValid(i));
return m_pMemory[i];
}
template< class T >
inline T& CUtlMemory<T>::Element(int i)
template <class T, class I>
inline T& CUtlMemory<T, I>::Element(I i)
{
Assert(IsIdxValid(i));
return m_pMemory[i];
}
template< class T >
inline T const& CUtlMemory<T>::Element(int i) const
template <class T, class I>
inline T const& CUtlMemory<T, I>::Element(I i) const
{
Assert(IsIdxValid(i));
return m_pMemory[i];
}
//-----------------------------------------------------------------------------
// is the memory externally allocated?
//-----------------------------------------------------------------------------
template< class T >
bool CUtlMemory<T>::IsExternallyAllocated() const
template <class T, class I>
bool CUtlMemory<T, I>::IsExternallyAllocated() const
{
return m_nGrowSize == EXTERNAL_BUFFER_MARKER;
}
template< class T >
void CUtlMemory<T>::SetGrowSize(int nSize)
template <class T, class I>
void CUtlMemory<T, I>::SetGrowSize(int nSize)
{
Assert((nSize >= 0) && (nSize != EXTERNAL_BUFFER_MARKER));
m_nGrowSize = nSize;
}
//-----------------------------------------------------------------------------
// Gets the base address (can change when adding elements!)
//-----------------------------------------------------------------------------
template< class T >
inline T* CUtlMemory<T>::Base()
template <class T, class I>
inline T *CUtlMemory<T, I>::Base()
{
return m_pMemory;
}
template< class T >
inline T const* CUtlMemory<T>::Base() const
template <class T, class I>
inline T const *CUtlMemory<T, I>::Base() const
{
return m_pMemory;
}
//-----------------------------------------------------------------------------
// Size
//-----------------------------------------------------------------------------
template< class T >
inline int CUtlMemory<T>::NumAllocated() const
template <class T, class I>
inline int CUtlMemory<T, I>::NumAllocated() const
{
return m_nAllocationCount;
}
template< class T >
inline int CUtlMemory<T>::Count() const
template <class T, class I>
inline int CUtlMemory<T, I>::Count() const
{
return m_nAllocationCount;
}
//-----------------------------------------------------------------------------
// Is element index valid?
//-----------------------------------------------------------------------------
template< class T >
inline bool CUtlMemory<T>::IsIdxValid(int i) const
template <class T, class I>
inline bool CUtlMemory<T, I>::IsIdxValid(I i) const
{
return (i >= 0) && (i < m_nAllocationCount);
return (((int)i) >= 0) && (((int) i) < m_nAllocationCount);
}
//-----------------------------------------------------------------------------
// Grows the memory
//-----------------------------------------------------------------------------
template< class T >
void CUtlMemory<T>::Grow(int num)
template <class T, class I>
void CUtlMemory<T, I>::Grow(int num)
{
Assert(num > 0);
if (IsExternallyAllocated())
{
// Can't grow a buffer whose memory was externally allocated
// Can't grow a buffer whose memory was externally allocated
Assert(0);
return;
}
@ -300,27 +285,24 @@ void CUtlMemory<T>::Grow(int num)
if (m_pMemory)
{
m_pMemory = (T*)realloc(m_pMemory, m_nAllocationCount * sizeof(T));
m_pMemory = (T *)realloc(m_pMemory, m_nAllocationCount * sizeof(T));
}
else
{
m_pMemory = (T*)malloc(m_nAllocationCount * sizeof(T));
m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T));
}
}
//-----------------------------------------------------------------------------
// Makes sure we've got at least this much memory
//-----------------------------------------------------------------------------
template< class T >
inline void CUtlMemory<T>::EnsureCapacity(int num)
template <class T, class I>
inline void CUtlMemory<T, I>::EnsureCapacity(int num)
{
if (m_nAllocationCount >= num)
return;
if (IsExternallyAllocated())
{
// Can't grow a buffer whose memory was externally allocated
// Can't grow a buffer whose memory was externally allocated
Assert(0);
return;
}
@ -328,30 +310,25 @@ inline void CUtlMemory<T>::EnsureCapacity(int num)
m_nAllocationCount = num;
if (m_pMemory)
{
m_pMemory = (T*)realloc(m_pMemory, m_nAllocationCount * sizeof(T));
m_pMemory = (T *)realloc(m_pMemory, m_nAllocationCount * sizeof(T));
}
else
{
m_pMemory = (T*)malloc(m_nAllocationCount * sizeof(T));
m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T));
}
}
//-----------------------------------------------------------------------------
// Memory deallocation
//-----------------------------------------------------------------------------
template< class T >
void CUtlMemory<T>::Purge()
template <class T, class I>
void CUtlMemory<T, I>::Purge()
{
if (!IsExternallyAllocated())
{
if (m_pMemory)
{
free((void*)m_pMemory);
free((void *)m_pMemory);
m_pMemory = 0;
}
m_nAllocationCount = 0;
}
}
#endif // UTLMEMORY_H

1172
regamedll/public/utlrbtree.h Normal file

File diff suppressed because it is too large Load Diff