jann/m2dev-client-src
1
0
Fork 0
forked from metin-server/m2dev-client-src
Code Pull Requests Activity

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

Browse Source 
fix some memory leaks
This commit is contained in:
d1str4ught
2025-08-28 18:41:51 +02:00
committed by GitHub
parent cb0c5d8fc9 e5bd21ff75
commit b9783bec79
10 changed files with 149 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/EterLib/DibBar.cpp
View File

@@ -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;
}
}

3
src/EterLib/GrpObjectInstance.cpp
View File

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

3
src/GameLib/ActorInstance.h
View File

@@ -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:

5
src/GameLib/Area.h
View File

@@ -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;

2
src/GameLib/MapOutdoor.h
View File

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

71
src/SpeedTreeLib/SpeedTreeForest.cpp
View File

@@ -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();
UINT uiCount;
while (itor != m_pMainTreeMap.end())
for (auto tr : m_pMainTreeMap)
{
CSpeedTreeWrapper * pMainTree = (itor++)->second;
CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
SpeedTreeWrapperPtr pMainTree = tr.second;
for (UINT i = 0; i < uiCount; ++i)
delete ppInstances[i];
UINT uiCount;
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;
if (!GetMainTree(dwTreeCRC, &pMainTree, c_szTreeName))
SpeedTreeWrapperPtr pMainTree;
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;
CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
auto pMainTree = (itor++)->second;
auto ppInstances = pMainTree->GetInstances(uiCount);
for (UINT i = 0; i < uiCount; ++i)
ppInstances[i]->GetSpeedTree()->SetWindStrength(m_fWindStrength);
for (auto it : ppInstances)
it->GetSpeedTree()->SetWindStrength(m_fWindStrength);
}
}

13
src/SpeedTreeLib/SpeedTreeForest.h
View File

@@ -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);
CSpeedTreeWrapper * GetMainTree(DWORD dwCRC);
BOOL GetMainTree(DWORD dwCRC, SpeedTreeWrapperPtr& ppMainTree, const char* c_pszFileName);
SpeedTreeWrapperPtr GetMainTree(DWORD dwCRC);
void DeleteMainTree(DWORD dwCRC);
CSpeedTreeWrapper * CreateInstance(float x, float y, float z, DWORD dwTreeCRC, const char * c_pszTreeName);
void DeleteInstance(CSpeedTreeWrapper * pTree);
SpeedTreeWrapperPtr CreateInstance(float x, float y, float z, DWORD dwTreeCRC, const char* c_pszTreeName);
void DeleteInstance(SpeedTreeWrapperPtr pTree);
//void SetLodLimits(void);

54
src/SpeedTreeLib/SpeedTreeForestDirectX8.cpp
View File

@@ -165,13 +165,11 @@ void CSpeedTreeForestDirectX8::Render(unsigned long ulRenderBitVector)
while (itor != m_pMainTreeMap.end())
{
CSpeedTreeWrapper * pMainTree = (itor++)->second;
CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
auto pMainTree = (itor++)->second;
auto ppInstances = pMainTree->GetInstances(uiCount);
for (UINT i = 0; i < uiCount; ++i)
{
ppInstances[i]->Advance();
}
for (auto it : ppInstances)
it->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;
CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
auto pMainTree = (itor++)->second;
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;
CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
auto pMainTree = (itor++)->second;
auto ppInstances = pMainTree->GetInstances(uiCount);
pMainTree->SetupFrondForTreeType();
for (UINT i = 0; i < uiCount; ++i)
if (ppInstances[i]->isShow())
ppInstances[i]->RenderFronds();
for (auto it : ppInstances)
{
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;
CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
auto pMainTree = (itor++)->second;
auto ppInstances = pMainTree->GetInstances(uiCount);
pMainTree->SetupLeafForTreeType();
for (UINT i = 0; i < uiCount; ++i)
if (ppInstances[i]->isShow())
ppInstances[i]->RenderLeaves();
for (auto it : ppInstances)
{
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;
CSpeedTreeWrapper ** ppInstances = pMainTree->GetInstances(uiCount);
auto pMainTree = (itor++)->second;
auto ppInstances = pMainTree->GetInstances(uiCount);
pMainTree->SetupBranchForTreeType();
pMainTree->SetupLeafForTreeType();
for (UINT i = 0; i < uiCount; ++i)
if (ppInstances[i]->isShow())
ppInstances[i]->RenderBillboards();
for (auto it : ppInstances)
{
if (it->isShow())
it->RenderBillboards();
}
}
}
#endif

84
src/SpeedTreeLib/SpeedTreeWrapper.cpp
View File

@@ -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);
pInstance->m_pSpeedTree = m_pSpeedTree->MakeInstance();
SAFE_DELETE(spInstance->m_pSpeedTree);
spInstance->m_pSpeedTree = m_pSpeedTree->MakeInstance();
if (pInstance->m_pSpeedTree)
if (spInstance->m_pSpeedTree)
{
// use the same materials
pInstance->m_cBranchMaterial = m_cBranchMaterial;
pInstance->m_cLeafMaterial = m_cLeafMaterial;
pInstance->m_cFrondMaterial = m_cFrondMaterial;
pInstance->m_CompositeImageInstance.SetImagePointer(m_CompositeImageInstance.GetGraphicImagePointer());
pInstance->m_BranchImageInstance.SetImagePointer(m_BranchImageInstance.GetGraphicImagePointer());
spInstance->m_cBranchMaterial = m_cBranchMaterial;
spInstance->m_cLeafMaterial = m_cLeafMaterial;
spInstance->m_cFrondMaterial = m_cFrondMaterial;
spInstance->m_CompositeImageInstance.SetImagePointer(m_CompositeImageInstance.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;
pInstance->m_pBranchIndexCounts = m_pBranchIndexCounts;
pInstance->m_pBranchVertexBuffer = m_pBranchVertexBuffer;
pInstance->m_unBranchVertexCount = m_unBranchVertexCount;
spInstance->m_pBranchIndexBuffer = m_pBranchIndexBuffer;
spInstance->m_pBranchIndexCounts = m_pBranchIndexCounts;
spInstance->m_pBranchVertexBuffer = m_pBranchVertexBuffer;
spInstance->m_unBranchVertexCount = m_unBranchVertexCount;
pInstance->m_pFrondIndexBuffer = m_pFrondIndexBuffer;
pInstance->m_pFrondIndexCounts = m_pFrondIndexCounts;
pInstance->m_pFrondVertexBuffer = m_pFrondVertexBuffer;
pInstance->m_unFrondVertexCount = m_unFrondVertexCount;
spInstance->m_pFrondIndexBuffer = m_pFrondIndexBuffer;
spInstance->m_pFrondIndexCounts = m_pFrondIndexCounts;
spInstance->m_pFrondVertexBuffer = m_pFrondVertexBuffer;
spInstance->m_unFrondVertexCount = m_unFrondVertexCount;
pInstance->m_pLeafVertexBuffer = m_pLeafVertexBuffer;
pInstance->m_usNumLeafLods = m_usNumLeafLods;
pInstance->m_pLeavesUpdatedByCpu = m_pLeavesUpdatedByCpu;
spInstance->m_pLeafVertexBuffer = m_pLeafVertexBuffer;
spInstance->m_usNumLeafLods = m_usNumLeafLods;
spInstance->m_pLeavesUpdatedByCpu = m_pLeavesUpdatedByCpu;
// new stuff
memcpy(pInstance->m_afPos, m_afPos, 3 * sizeof(float));
memcpy(pInstance->m_afBoundingBox, m_afBoundingBox, 6 * sizeof(float));
pInstance->m_pInstanceOf = this;
m_vInstances.push_back(pInstance);
memcpy(spInstance->m_afPos, m_afPos, 3 * sizeof(float));
memcpy(spInstance->m_afBoundingBox, m_afBoundingBox, 6 * sizeof(float));
spInstance->m_pInstanceOf = shared_from_this();
m_vInstances.push_back(spInstance);
}
else
{
fprintf(stderr, "SpeedTreeRT Error: %s\n", m_pSpeedTree->GetCurrentError());
delete pInstance;
pInstance = NULL;
spInstance.reset();
}
return pInstance;
return spInstance;
}
///////////////////////////////////////////////////////////////////////
// CSpeedTreeWrapper::GetInstances
CSpeedTreeWrapper ** CSpeedTreeWrapper::GetInstances(UINT& nCount)
std::vector <CSpeedTreeWrapper::SpeedTreeWrapperPtr> CSpeedTreeWrapper::GetInstances(UINT& nCount)
{
std::vector <SpeedTreeWrapperPtr> kResult;
nCount = m_vInstances.size();
if (nCount)
return &(m_vInstances[0]);
else
return NULL;
{
for (auto it : m_vInstances)
{
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;
}
///////////////////////////////////////////////////////////////////////

20
src/SpeedTreeLib/SpeedTreeWrapper.h
View File

@@ -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);
CSpeedTreeWrapper * InstanceOf(void) const { return m_pInstanceOf; }
CSpeedTreeWrapper * MakeInstance();
void DeleteInstance(CSpeedTreeWrapper * pInstance);
std::vector <SpeedTreeWrapperPtr> GetInstances(UINT& nCount);
SpeedTreeWrapperPtr InstanceOf(void) const { return m_pInstanceOf; }
SpeedTreeWrapperPtr MakeInstance();
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
CSpeedTreeWrapper* m_pInstanceOf; // which tree is this an instance of
std::vector<SpeedTreeWrapperPtr> m_vInstances; // what is an instance of us
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