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

fix some memory leaks

Browse Source
This commit is contained in:
mq1n
2025-08-27 23:37:19 +03:00
parent 6459c9fa03
commit e5bd21ff75
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