Merge pull request #6 from mq1n/mem-leak-fix

fix some memory leaks

src/EterLib/DibBar.cpp

@@ -155,9 +155,17 @@ bool CDibBar::Create(HDC hdc, DWORD dwWidth, DWORD dwHeight)
 	return true;
 }
 
-CDibBar::CDibBar()
+CDibBar::CDibBar() :
+	m_dwWidth(0),
+	m_dwHeight(0)
 {
 }
+
 CDibBar::~CDibBar()
 {
+	for (size_t i = 0; i < m_kVec_pkBlockTexture.size(); ++i)
+	{
+		CBlockTexture * pTexture = m_kVec_pkBlockTexture[i];
+		delete pTexture;
+	}
 }

src/EterLib/GrpObjectInstance.cpp

@@ -283,7 +283,8 @@ void CGraphicObjectInstance::Initialize()
 
 	D3DXMatrixIdentity(&m_worldMatrix);
 	D3DXMatrixIdentity(&m_mRotation);
-	
+
+	ClearCollision();
 	OnInitialize();
 }
 

src/GameLib/ActorInstance.h

@@ -11,6 +11,7 @@
 #include "PhysicsObject.h"
 #include "ActorInstanceInterface.h"
 #include "Interface.h"
+#include "../SpeedTreeLib/SpeedTreeForest.h"
 //#include "../eterGrnLib/ThingInstance.h"
 
 class CItemData;
@@ -808,7 +809,7 @@ class CActorInstance : public IActorInstance, public IFlyTargetableObject
 		THitDataMap					m_HitDataMap;
 
 		CActorInstance *			m_pkHorse;
-		CSpeedTreeWrapper *			m_pkTree;
+		CSpeedTreeForest::SpeedTreeWrapperPtr	m_pkTree;
 
 
 	protected:

src/GameLib/Area.h

@@ -4,6 +4,7 @@
 #include "../eterGrnLib/ThingInstance.h"
 #include "MapType.h"
 #include "DungeonBlock.h"
+#include "../SpeedTreeLib/SpeedTreeForest.h"
 
 class CMapOutdoor;
 class CEffectInstance;
@@ -90,7 +91,7 @@ class CArea
 			CAttributeInstance *		pAttributeInstance;
 
 			// Data For Tree
-			CSpeedTreeWrapper *			pTree;
+			CSpeedTreeForest::SpeedTreeWrapperPtr			pTree;
 
 			// Data For Normal Object or Building
 			BOOL						isShadowFlag;
@@ -152,7 +153,7 @@ class CArea
 			}
 		} TObjectInstance;
 
-		typedef std::vector<CSpeedTreeWrapper *>			TTreeInstanceVector;
+		typedef std::vector<CSpeedTreeForest::SpeedTreeWrapperPtr>			TTreeInstanceVector;
 		typedef std::vector<CGraphicThingInstance *>		TThingInstanceVector;
 		typedef std::vector<CDungeonBlock *>				TDungeonBlockInstanceVector;
 		typedef std::vector<TObjectInstance *>				TObjectInstanceVector;

src/GameLib/MapOutdoor.h

@@ -723,7 +723,7 @@ class CMapOutdoor : public CMapBase
 	private:
 		struct SXMasTree
 		{
-			CSpeedTreeWrapper* m_pkTree;
+			CSpeedTreeForest::SpeedTreeWrapperPtr m_pkTree;
 			int m_iEffectID;
 		} m_kXMas;
 

src/SpeedTreeLib/SpeedTreeForest.cpp

@@ -20,7 +20,13 @@ using namespace std;
 ///////////////////////////////////////////////////////////////////////  
 //	CSpeedTreeForest constructor
 
-CSpeedTreeForest::CSpeedTreeForest() : m_fWindStrength(0.0f)
+CSpeedTreeForest::CSpeedTreeForest() :
+	m_fWindStrength(0.0f),
+	m_afFog{ 0.0f, 0.0f, 0.0f, 0.0f },
+	m_fAccumTime(0.0f),
+	m_afLighting{ 0.0f, 0.0f, 0.0f, 1.0f,  // direction
+					0.2f, 0.2f, 0.2f, 1.0f,  // ambient
+					0.8f, 0.8f, 0.8f, 1.0f } // diffuse
 {
 	CSpeedTreeRT::SetNumWindMatrices(c_nNumWindMatrices);
 
@@ -39,24 +45,26 @@ CSpeedTreeForest::~CSpeedTreeForest()
 
 void CSpeedTreeForest::Clear()
 {
-	TTreeMap::iterator itor = m_pMainTreeMap.begin();
+	for (auto tr : m_pMainTreeMap)
-	UINT uiCount;
-
-	while (itor != m_pMainTreeMap.end())
 	{
-		CSpeedTreeWrapper * pMainTree = (itor++)->second;
+		SpeedTreeWrapperPtr pMainTree = tr.second;
-		CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
 
-		for (UINT i = 0; i < uiCount; ++i)
+		UINT uiCount;
-			delete ppInstances[i];
+		auto ppInstances = pMainTree->GetInstances(uiCount);
 
-		delete pMainTree;
+		for (auto it : ppInstances)
+			it->Clear();
+
+		pMainTree->Clear();
 	}
 
-	m_pMainTreeMap.clear();
+	if (m_pMainTreeMap.begin() != m_pMainTreeMap.end())
+	{
+		m_pMainTreeMap.clear();
+	}
 }
 
-CSpeedTreeWrapper * CSpeedTreeForest::GetMainTree(DWORD dwCRC)
+CSpeedTreeForest::SpeedTreeWrapperPtr CSpeedTreeForest::GetMainTree(DWORD dwCRC)
 {
 	TTreeMap::iterator itor = m_pMainTreeMap.find(dwCRC);
 
@@ -66,11 +74,11 @@ CSpeedTreeWrapper * CSpeedTreeForest::GetMainTree(DWORD dwCRC)
 	return itor->second;
 }
 
-BOOL CSpeedTreeForest::GetMainTree(DWORD dwCRC, CSpeedTreeWrapper ** ppMainTree, const char * c_pszFileName)
+BOOL CSpeedTreeForest::GetMainTree(DWORD dwCRC, SpeedTreeWrapperPtr &ppMainTree, const char * c_pszFileName)
 {
 	TTreeMap::iterator itor = m_pMainTreeMap.find(dwCRC);
 
-	CSpeedTreeWrapper * pTree;
+	SpeedTreeWrapperPtr pTree;
 
 	if (itor != m_pMainTreeMap.end())
 		pTree = itor->second;
@@ -82,40 +90,43 @@ BOOL CSpeedTreeForest::GetMainTree(DWORD dwCRC, CSpeedTreeWrapper ** ppMainTree,
 		if (!CEterPackManager::Instance().Get(file, c_pszFileName, &c_pvData))
 			return FALSE;
 
-		pTree = new CSpeedTreeWrapper;
+		pTree = std::make_shared<CSpeedTreeWrapper>();
 
-		if (!pTree->LoadTree(c_pszFileName, (const BYTE*)c_pvData, file.Size()))
+		if (!pTree->LoadTree(c_pszFileName, (const BYTE *) c_pvData, file.Size()))
 		{
-			delete pTree;
+			pTree.reset();
 			return FALSE;
 		}
 
-		m_pMainTreeMap.insert(std::map<DWORD, CSpeedTreeWrapper*>::value_type(dwCRC, pTree));
+		m_pMainTreeMap.insert(std::map<DWORD, SpeedTreeWrapperPtr>::value_type(dwCRC, pTree));
+
 		file.Destroy();
 	}
 
-	*ppMainTree = pTree;
+	ppMainTree = pTree;
 	return TRUE;
 }
 
-CSpeedTreeWrapper* CSpeedTreeForest::CreateInstance(float x, float y, float z, DWORD dwTreeCRC, const char * c_szTreeName)
+CSpeedTreeForest::SpeedTreeWrapperPtr CSpeedTreeForest::CreateInstance(float x, float y, float z, DWORD dwTreeCRC, const char* c_szTreeName)
 {
-	CSpeedTreeWrapper * pMainTree;
+	SpeedTreeWrapperPtr pMainTree;
-	if (!GetMainTree(dwTreeCRC, &pMainTree, c_szTreeName))
+	if (!GetMainTree(dwTreeCRC, pMainTree, c_szTreeName))
+	{
 		return NULL;
+	}
 
-	CSpeedTreeWrapper* pTreeInst = pMainTree->MakeInstance();	
+	SpeedTreeWrapperPtr pTreeInst = pMainTree->MakeInstance();
 	pTreeInst->SetPosition(x, y, z);
 	pTreeInst->RegisterBoundingSphere();
 	return pTreeInst;
 }
 
-void CSpeedTreeForest::DeleteInstance(CSpeedTreeWrapper * pInstance)
+void CSpeedTreeForest::DeleteInstance(SpeedTreeWrapperPtr pInstance)
 {
 	if (!pInstance)
 		return;
-	
+
-	CSpeedTreeWrapper * pParentTree = pInstance->InstanceOf();
+	SpeedTreeWrapperPtr pParentTree = pInstance->InstanceOf();
 
 	if (!pParentTree)
 		return;
@@ -163,11 +174,11 @@ void CSpeedTreeForest::SetWindStrength(float fStrength)
 
 	while (itor != m_pMainTreeMap.end())
 	{
-		CSpeedTreeWrapper * pMainTree = (itor++)->second;
+		auto pMainTree = (itor++)->second;
-		CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
+		auto ppInstances = pMainTree->GetInstances(uiCount);
 
-		for (UINT i = 0; i < uiCount; ++i)
+		for (auto it : ppInstances)
-			ppInstances[i]->GetSpeedTree()->SetWindStrength(m_fWindStrength);
+			it->GetSpeedTree()->SetWindStrength(m_fWindStrength);
 	}
 }
 

src/SpeedTreeLib/SpeedTreeForest.h

@@ -57,7 +57,8 @@
 class CSpeedTreeForest
 {
 	public:
-		typedef std::map<DWORD, CSpeedTreeWrapper *> TTreeMap;
+		using SpeedTreeWrapperPtr = std::shared_ptr <CSpeedTreeWrapper>;
+		using TTreeMap = std::map <DWORD, SpeedTreeWrapperPtr>;
 
 	public:
 		CSpeedTreeForest();
@@ -65,13 +66,13 @@ class CSpeedTreeForest
 		
 		void						ClearMainTree();
 
-		
+
-		BOOL						GetMainTree(DWORD dwCRC, CSpeedTreeWrapper ** ppMainTree, const char * c_pszFileName);
+		BOOL						GetMainTree(DWORD dwCRC, SpeedTreeWrapperPtr& ppMainTree, const char* c_pszFileName);
-		CSpeedTreeWrapper *			GetMainTree(DWORD dwCRC);
+		SpeedTreeWrapperPtr			GetMainTree(DWORD dwCRC);
 		void						DeleteMainTree(DWORD dwCRC);
 
-		CSpeedTreeWrapper *			CreateInstance(float x, float y, float z, DWORD dwTreeCRC, const char * c_pszTreeName);
+		SpeedTreeWrapperPtr			CreateInstance(float x, float y, float z, DWORD dwTreeCRC, const char* c_pszTreeName);
-		void						DeleteInstance(CSpeedTreeWrapper * pTree);
+		void						DeleteInstance(SpeedTreeWrapperPtr pTree);
 
 		//void						SetLodLimits(void);
 

src/SpeedTreeLib/SpeedTreeForestDirectX8.cpp

@@ -165,13 +165,11 @@ void CSpeedTreeForestDirectX8::Render(unsigned long ulRenderBitVector)
 
 	while (itor != m_pMainTreeMap.end())
 	{
-		CSpeedTreeWrapper * pMainTree = (itor++)->second;
+		auto pMainTree = (itor++)->second;
-		CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
+		auto ppInstances = pMainTree->GetInstances(uiCount);
 
-		for (UINT i = 0; i < uiCount; ++i)
+		for (auto it : ppInstances)
-		{
+			it->Advance();
-			ppInstances[i]->Advance();
-		}
 	}
 
 	STATEMANAGER.SetVertexShaderConstant(c_nVertexShader_Light,	m_afLighting, 3);
@@ -226,8 +224,8 @@ void CSpeedTreeForestDirectX8::Render(unsigned long ulRenderBitVector)
 
 		while (itor != m_pMainTreeMap.end())
 		{
-			CSpeedTreeWrapper * pMainTree = (itor++)->second;
+			auto pMainTree = (itor++)->second;
-			CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
+			auto ppInstances = pMainTree->GetInstances(uiCount);
 			
 			pMainTree->SetupBranchForTreeType();
 
@@ -247,17 +245,19 @@ void CSpeedTreeForestDirectX8::Render(unsigned long ulRenderBitVector)
 
 		while (itor != m_pMainTreeMap.end())
 		{
-			CSpeedTreeWrapper * pMainTree = (itor++)->second;
+			auto pMainTree = (itor++)->second;
-			CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
+			auto ppInstances = pMainTree->GetInstances(uiCount);
 
 			pMainTree->SetupFrondForTreeType();
 
-			for (UINT i = 0; i < uiCount; ++i)
+			for (auto it : ppInstances)
-				if (ppInstances[i]->isShow())
+			{
-					ppInstances[i]->RenderFronds();
+				if (it->isShow())
+					it->RenderFronds();
+			}
 		}
 	}
-	
+
 	// render leaves
 	if (ulRenderBitVector & Forest_RenderLeaves)
 	{
@@ -281,14 +281,16 @@ void CSpeedTreeForestDirectX8::Render(unsigned long ulRenderBitVector)
 
 		while (itor != m_pMainTreeMap.end())
 		{
-			CSpeedTreeWrapper * pMainTree = (itor++)->second;
+			auto pMainTree = (itor++)->second;
-			CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
+			auto ppInstances = pMainTree->GetInstances(uiCount);
 
 			pMainTree->SetupLeafForTreeType();
 
-			for (UINT i = 0; i < uiCount; ++i)
+			for (auto it : ppInstances)
-				if (ppInstances[i]->isShow())
+			{
-					ppInstances[i]->RenderLeaves();
+				if (it->isShow())
+					it->RenderLeaves();
+			}
 		}
 
 		while (itor != m_pMainTreeMap.end())
@@ -313,14 +315,16 @@ void CSpeedTreeForestDirectX8::Render(unsigned long ulRenderBitVector)
 
 			while (itor != m_pMainTreeMap.end())
 			{
-				CSpeedTreeWrapper * pMainTree = (itor++)->second;
+				auto pMainTree = (itor++)->second;
-				CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
+				auto ppInstances = pMainTree->GetInstances(uiCount);
 
-				pMainTree->SetupBranchForTreeType();
+				pMainTree->SetupLeafForTreeType();
 
-				for (UINT i = 0; i < uiCount; ++i)
+				for (auto it : ppInstances)
-					if (ppInstances[i]->isShow())
+				{
-						ppInstances[i]->RenderBillboards();
+					if (it->isShow())
+						it->RenderBillboards();
+				}
 			}
 		}
 	#endif

src/SpeedTreeLib/SpeedTreeWrapper.cpp

@@ -743,80 +743,85 @@ void CSpeedTreeWrapper::Advance(void)
 
 ///////////////////////////////////////////////////////////////////////  
 //	CSpeedTreeWrapper::MakeInstance
-CSpeedTreeWrapper * CSpeedTreeWrapper::MakeInstance()
+CSpeedTreeWrapper::SpeedTreeWrapperPtr CSpeedTreeWrapper::MakeInstance()
 {
-	CSpeedTreeWrapper * pInstance = new CSpeedTreeWrapper;
+	auto spInstance = std::make_shared<CSpeedTreeWrapper>();
 	
 	// make an instance of this object's SpeedTree
-	pInstance->m_bIsInstance = true;
+	spInstance->m_bIsInstance = true;
 
-	SAFE_DELETE(pInstance->m_pSpeedTree);
+	SAFE_DELETE(spInstance->m_pSpeedTree);
-	pInstance->m_pSpeedTree = m_pSpeedTree->MakeInstance();
+	spInstance->m_pSpeedTree = m_pSpeedTree->MakeInstance();
 	
-	if (pInstance->m_pSpeedTree)
+	if (spInstance->m_pSpeedTree)
     {
 		// use the same materials
-		pInstance->m_cBranchMaterial = m_cBranchMaterial;
+		spInstance->m_cBranchMaterial = m_cBranchMaterial;
-		pInstance->m_cLeafMaterial = m_cLeafMaterial;
+		spInstance->m_cLeafMaterial = m_cLeafMaterial;
-		pInstance->m_cFrondMaterial = m_cFrondMaterial;
+		spInstance->m_cFrondMaterial = m_cFrondMaterial;
-		pInstance->m_CompositeImageInstance.SetImagePointer(m_CompositeImageInstance.GetGraphicImagePointer());
+		spInstance->m_CompositeImageInstance.SetImagePointer(m_CompositeImageInstance.GetGraphicImagePointer());
-		pInstance->m_BranchImageInstance.SetImagePointer(m_BranchImageInstance.GetGraphicImagePointer());
+		spInstance->m_BranchImageInstance.SetImagePointer(m_BranchImageInstance.GetGraphicImagePointer());
 		
 		if (!m_ShadowImageInstance.IsEmpty())
-			pInstance->m_ShadowImageInstance.SetImagePointer(m_ShadowImageInstance.GetGraphicImagePointer());
+			spInstance->m_ShadowImageInstance.SetImagePointer(m_ShadowImageInstance.GetGraphicImagePointer());
 		
-		pInstance->m_pTextureInfo = m_pTextureInfo;
+		spInstance->m_pTextureInfo = m_pTextureInfo;
 		
 		// use the same geometry cache
-		pInstance->m_pGeometryCache = m_pGeometryCache;
+		spInstance->m_pGeometryCache = m_pGeometryCache;
 		
 		// use the same buffers
-		pInstance->m_pBranchIndexBuffer = m_pBranchIndexBuffer;
+		spInstance->m_pBranchIndexBuffer = m_pBranchIndexBuffer;
-		pInstance->m_pBranchIndexCounts = m_pBranchIndexCounts;
+		spInstance->m_pBranchIndexCounts = m_pBranchIndexCounts;
-		pInstance->m_pBranchVertexBuffer = m_pBranchVertexBuffer;
+		spInstance->m_pBranchVertexBuffer = m_pBranchVertexBuffer;
-		pInstance->m_unBranchVertexCount = m_unBranchVertexCount;
+		spInstance->m_unBranchVertexCount = m_unBranchVertexCount;
 		
-		pInstance->m_pFrondIndexBuffer = m_pFrondIndexBuffer;
+		spInstance->m_pFrondIndexBuffer = m_pFrondIndexBuffer;
-		pInstance->m_pFrondIndexCounts = m_pFrondIndexCounts;
+		spInstance->m_pFrondIndexCounts = m_pFrondIndexCounts;
-		pInstance->m_pFrondVertexBuffer = m_pFrondVertexBuffer;
+		spInstance->m_pFrondVertexBuffer = m_pFrondVertexBuffer;
-		pInstance->m_unFrondVertexCount = m_unFrondVertexCount;
+		spInstance->m_unFrondVertexCount = m_unFrondVertexCount;
 		
-		pInstance->m_pLeafVertexBuffer = m_pLeafVertexBuffer;
+		spInstance->m_pLeafVertexBuffer = m_pLeafVertexBuffer;
-		pInstance->m_usNumLeafLods = m_usNumLeafLods;
+		spInstance->m_usNumLeafLods = m_usNumLeafLods;
-		pInstance->m_pLeavesUpdatedByCpu = m_pLeavesUpdatedByCpu;
+		spInstance->m_pLeavesUpdatedByCpu = m_pLeavesUpdatedByCpu;
 		
 		// new stuff
-		memcpy(pInstance->m_afPos, m_afPos, 3 * sizeof(float));
+		memcpy(spInstance->m_afPos, m_afPos, 3 * sizeof(float));
-		memcpy(pInstance->m_afBoundingBox, m_afBoundingBox, 6 * sizeof(float));
+		memcpy(spInstance->m_afBoundingBox, m_afBoundingBox, 6 * sizeof(float));
-		pInstance->m_pInstanceOf = this;
+		spInstance->m_pInstanceOf = shared_from_this();
-		m_vInstances.push_back(pInstance);
+		m_vInstances.push_back(spInstance);
     }
     else
 	{
 		fprintf(stderr, "SpeedTreeRT Error: %s\n", m_pSpeedTree->GetCurrentError());
-        delete pInstance;
+		spInstance.reset();
-        pInstance = NULL;
 	}
 	
-	return pInstance;
+	return spInstance;
 }
 
 
 ///////////////////////////////////////////////////////////////////////  
 //	CSpeedTreeWrapper::GetInstances
-
+std::vector <CSpeedTreeWrapper::SpeedTreeWrapperPtr> CSpeedTreeWrapper::GetInstances(UINT& nCount)
-CSpeedTreeWrapper ** CSpeedTreeWrapper::GetInstances(UINT& nCount)
 {
+	std::vector <SpeedTreeWrapperPtr> kResult;
+
 	nCount = m_vInstances.size();
 	if (nCount)
-		return &(m_vInstances[0]);
+	{
-	else
+		for (auto it : m_vInstances)
-		return NULL;
+		{
+			kResult.push_back(it);
+		}
+	}
+
+	return kResult;
 }
 
-void CSpeedTreeWrapper::DeleteInstance(CSpeedTreeWrapper * pInstance)
+void CSpeedTreeWrapper::DeleteInstance(SpeedTreeWrapperPtr pInstance)
 {
-	std::vector<CSpeedTreeWrapper *>::iterator itor = m_vInstances.begin();
+	auto itor = m_vInstances.begin();
 	
 	while (itor != m_vInstances.end())
 	{
@@ -827,7 +832,6 @@ void CSpeedTreeWrapper::DeleteInstance(CSpeedTreeWrapper * pInstance)
 		else
 			++itor;
 	}
-	delete pInstance;
 }
 
 ///////////////////////////////////////////////////////////////////////  

src/SpeedTreeLib/SpeedTreeWrapper.h

@@ -42,6 +42,7 @@
 #include <d3d9types.h>
 #include <d3dx9.h>
 #include <vector>
+#include <memory>
 
 #include "EterLib/GrpObjectInstance.h"
 #include "EterLib/GrpImageInstance.h"
@@ -63,8 +64,10 @@
 #pragma warning(push)
 #pragma warning(disable:4100)
 
-class CSpeedTreeWrapper : public CGraphicObjectInstance
+class CSpeedTreeWrapper : public CGraphicObjectInstance, public std::enable_shared_from_this<CSpeedTreeWrapper>
 {
+	using SpeedTreeWrapperPtr = std::shared_ptr <CSpeedTreeWrapper>;
+
 	enum
 	{
 		ID = TREE_OBJECT
@@ -125,10 +128,10 @@ public:
 	void						RenderBillboards(void) const;
 	
 	// instancing
-	CSpeedTreeWrapper **		GetInstances(unsigned int& nCount);
+	std::vector <SpeedTreeWrapperPtr>		GetInstances(UINT& nCount);
-	CSpeedTreeWrapper *			InstanceOf(void) const							{ return m_pInstanceOf; }
+	SpeedTreeWrapperPtr			InstanceOf(void) const { return m_pInstanceOf; }
-	CSpeedTreeWrapper * 		MakeInstance();								
+	SpeedTreeWrapperPtr 		MakeInstance();
-	void						DeleteInstance(CSpeedTreeWrapper * pInstance);
+	void						DeleteInstance(SpeedTreeWrapperPtr pInstance);
 	CSpeedTreeRT *				GetSpeedTree(void) const						{ return m_pSpeedTree; }
 	
 	// lighting																	
@@ -154,15 +157,14 @@ private:
 	static bool					LoadTexture(const char* pFilename, CGraphicImageInstance & rImage);
 	void						SetShaderConstants(const float* pMaterial) const;
 	
-	
 private:
 	// SpeedTreeRT data
 	CSpeedTreeRT*					m_pSpeedTree;					// the SpeedTree object
 	CSpeedTreeRT::STextures*		m_pTextureInfo;					// texture info cache
 	bool							m_bIsInstance;					// is this an instance?
-	std::vector<CSpeedTreeWrapper*>	m_vInstances;					// what is an instance of us
+	std::vector<SpeedTreeWrapperPtr>	m_vInstances;					// what is an instance of us
-	CSpeedTreeWrapper*				m_pInstanceOf;					// which tree is this an instance of
+	SpeedTreeWrapperPtr				m_pInstanceOf;					// which tree is this an instance of
-	
+
 	// geometry cache
 	CSpeedTreeRT::SGeometry*		m_pGeometryCache;				// cache for pulling geometry from SpeedTree avoids lots of reallocation