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

Merge pull request #45 from savisxss/opti2

Browse Source
This commit is contained in:
rtw1x1
2025-12-26 07:05:06 +00:00
committed by GitHub
parent b56f55ce7c 9ac8e3e4d7
commit d37607baa1
6 changed files with 102 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/EterLib/ResourceManager.cpp
View File

@@ -8,7 +8,7 @@
#include "ResourceManager.h"
#include "GrpImage.h"
int g_iLoadingDelayTime = 20;
int g_iLoadingDelayTime = 1; // Reduced from 20ms to 1ms for faster async loading
const long c_Deleting_Wait_Time = 30000; // 삭제 대기 시간 (30초)
const long c_DeletingCountPerFrame = 30; // 프레임당 체크 리소스 갯수
@@ -16,6 +16,21 @@ const long c_Reference_Decrease_Wait_Time = 30000; // 선로딩 리소스의 해
CFileLoaderThread CResourceManager::ms_loadingThread;
void CResourceManager::BeginThreadLoading()
{
// Already started in constructor, nothing to do
}
void CResourceManager::EndThreadLoading()
{
// Wait for all pending requests to complete
while (!m_RequestMap.empty() || !m_WaitingMap.empty())
{
ProcessBackgroundLoading();
Sleep(10);
}
}
void CResourceManager::LoadStaticCache(const char* c_szFileName)
{
CResource* pkRes=GetResourcePointer(c_szFileName);
@@ -514,11 +529,11 @@ void CResourceManager::ReserveDeletingResource(CResource * pResource)
CResourceManager::CResourceManager()
{
//ms_loadingThread.Create(0);
ms_loadingThread.Create(0);
}
CResourceManager::~CResourceManager()
{
Destroy();
//ms_loadingThread.Shutdown();
ms_loadingThread.Shutdown();
}

91
src/GameLib/ActorInstanceCollisionDetection.cpp
View File

@@ -25,8 +25,10 @@ bool CActorInstance::CanSkipCollision()
void CActorInstance::UpdatePointInstance()
{
// Optimized: Cache end iterator
TCollisionPointInstanceListIterator itor;
for (itor = m_DefendingPointInstanceList.begin(); itor != m_DefendingPointInstanceList.end(); ++itor)
TCollisionPointInstanceListIterator end = m_DefendingPointInstanceList.end();
for (itor = m_DefendingPointInstanceList.begin(); itor != end; ++itor)
UpdatePointInstance(&(*itor));
}
@@ -76,9 +78,11 @@ void CActorInstance::UpdatePointInstance(TCollisionPointInstance * pPointInstanc
}
// Update Collsion Sphere
// Optimized: Cache end iterator
CSphereCollisionInstanceVector::const_iterator sit = pPointInstance->c_pCollisionData->SphereDataVector.begin();
CSphereCollisionInstanceVector::const_iterator sit_end = pPointInstance->c_pCollisionData->SphereDataVector.end();
CDynamicSphereInstanceVector::iterator dit=pPointInstance->SphereInstanceVector.begin();
for (;sit!=pPointInstance->c_pCollisionData->SphereDataVector.end();++sit,++dit)
for (;sit!=sit_end;++sit,++dit)
{
const TSphereData & c = sit->GetAttribute();//c_pCollisionData->SphereDataVector[j].GetAttribute();
@@ -107,8 +111,10 @@ void CActorInstance::UpdateAdvancingPointInstance()
D3DXMATRIX matPoint;
D3DXMATRIX matCenter;
// Optimized: Cache end iterator
TCollisionPointInstanceListIterator itor = m_BodyPointInstanceList.begin();
for (; itor != m_BodyPointInstanceList.end(); ++itor)
TCollisionPointInstanceListIterator itor_end = m_BodyPointInstanceList.end();
for (; itor != itor_end; ++itor)
{
TCollisionPointInstance & rInstance = *itor;
@@ -173,13 +179,17 @@ bool CActorInstance::CheckCollisionDetection(const CDynamicSphereInstanceVector
return false;
}
// Optimized: Cache end iterator and vector sizes
TCollisionPointInstanceListIterator itor;
for (itor = m_DefendingPointInstanceList.begin(); itor != m_DefendingPointInstanceList.end(); ++itor)
TCollisionPointInstanceListIterator itor_end = m_DefendingPointInstanceList.end();
DWORD attackSize = c_pAttackingSphereVector->size();
for (itor = m_DefendingPointInstanceList.begin(); itor != itor_end; ++itor)
{
const CDynamicSphereInstanceVector * c_pDefendingSphereVector = &(*itor).SphereInstanceVector;
DWORD defendSize = c_pDefendingSphereVector->size();
for (DWORD i = 0; i < c_pAttackingSphereVector->size(); ++i)
for (DWORD j = 0; j < c_pDefendingSphereVector->size(); ++j)
for (DWORD i = 0; i < attackSize; ++i)
for (DWORD j = 0; j < defendSize; ++j)
{
const CDynamicSphereInstance & c_rAttackingSphere = c_pAttackingSphereVector->at(i);
const CDynamicSphereInstance & c_rDefendingSphere = c_pDefendingSphereVector->at(j);
@@ -247,12 +257,14 @@ bool CActorInstance::CreateCollisionInstancePiece(DWORD dwAttachingModelIndex, c
pPointInstance->SphereInstanceVector.clear();
pPointInstance->SphereInstanceVector.reserve(c_rSphereDataVector.size());
// Optimized: Cache end iterator
CSphereCollisionInstanceVector::const_iterator it;
CSphereCollisionInstanceVector::const_iterator it_end = c_rSphereDataVector.end();
CDynamicSphereInstance dsi;
dsi.v3LastPosition = D3DXVECTOR3(0.0f,0.0f,0.0f);
dsi.v3Position = D3DXVECTOR3(0.0f,0.0f,0.0f);
for (it = c_rSphereDataVector.begin(); it!=c_rSphereDataVector.end(); ++it)
for (it = c_rSphereDataVector.begin(); it!=it_end; ++it)
{
const TSphereData & c_rSphereData = it->GetAttribute();
dsi.fRadius = c_rSphereData.fRadius;
@@ -266,9 +278,10 @@ bool CActorInstance::CreateCollisionInstancePiece(DWORD dwAttachingModelIndex, c
BOOL CActorInstance::__SplashAttackProcess(CActorInstance & rVictim)
{
// Optimized: Use squared distance to avoid sqrt
D3DXVECTOR3 v3Distance(rVictim.m_x - m_x, rVictim.m_z - m_z, rVictim.m_z - m_z);
float fDistance = D3DXVec3LengthSq(&v3Distance);
if (fDistance >= 1000.0f*1000.0f)
float fDistanceSq = D3DXVec3LengthSq(&v3Distance);
if (fDistanceSq >= 1000.0f*1000.0f)
return FALSE;
// Check Distance
@@ -334,18 +347,19 @@ BOOL CActorInstance::__NormalAttackProcess(CActorInstance & rVictim)
{
// Check Distance
// NOTE - 일단 근접 체크만 하고 있음
// Optimized: Already using squared distance comparison
D3DXVECTOR3 v3Distance(rVictim.m_x - m_x, rVictim.m_z - m_z, rVictim.m_z - m_z);
float fDistance = D3DXVec3LengthSq(&v3Distance);
float fDistanceSq = D3DXVec3LengthSq(&v3Distance);
extern bool IS_HUGE_RACE(unsigned int vnum);
if (IS_HUGE_RACE(rVictim.GetRace()))
{
if (fDistance >= 500.0f*500.0f)
if (fDistanceSq >= 500.0f*500.0f)
return FALSE;
}
else
{
if (fDistance >= 300.0f*300.0f)
if (fDistanceSq >= 300.0f*300.0f)
return FALSE;
}
@@ -498,9 +512,10 @@ BOOL CActorInstance::TestPhysicsBlendingCollision(CActorInstance & rVictim)
TPixelPosition kPPosLast;
GetBlendingPosition( &kPPosLast );
// Optimized: Already using squared distance comparison
D3DXVECTOR3 v3Distance = D3DXVECTOR3(rVictim.m_x - kPPosLast.x, rVictim.m_y - kPPosLast.y, rVictim.m_z - kPPosLast.z);
float fDistance = D3DXVec3LengthSq(&v3Distance);
if (fDistance > 800.0f*800.0f)
float fDistanceSq = D3DXVec3LengthSq(&v3Distance);
if (fDistanceSq > 800.0f*800.0f)
return FALSE;
// NOTE : 공격 중일때는 Defending Sphere로 Collision Check를 합니다.
@@ -524,16 +539,20 @@ BOOL CActorInstance::TestPhysicsBlendingCollision(CActorInstance & rVictim)
D3DXVECTOR3 prevLastPosition, prevPosition;
const int nSubCheckCount = 50;
// Optimized: Cache end iterators and vector sizes
TCollisionPointInstanceListIterator itorMain = pMainList->begin();
TCollisionPointInstanceListIterator itorMain_end = pMainList->end();
TCollisionPointInstanceListIterator itorVictim = pVictimList->begin();
for (; itorMain != pMainList->end(); ++itorMain)
TCollisionPointInstanceListIterator itorVictim_end = pVictimList->end();
for (; itorMain != itorMain_end; ++itorMain)
{
for (; itorVictim != pVictimList->end(); ++itorVictim)
for (; itorVictim != itorVictim_end; ++itorVictim)
{
CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
CDynamicSphereInstanceVector & c_rVictimSphereVector = (*itorVictim).SphereInstanceVector;
DWORD mainSize = c_rMainSphereVector.size();
for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
for (DWORD i = 0; i < mainSize; ++i)
{
CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector[i];
//adjust main sphere center
@@ -542,11 +561,13 @@ BOOL CActorInstance::TestPhysicsBlendingCollision(CActorInstance & rVictim)
c_rMainSphere.v3LastPosition = prevPosition;
// Optimized: Cache victim vector size
DWORD victimSize = c_rVictimSphereVector.size();
for( int i = 1; i <= nSubCheckCount; ++ i )
{
c_rMainSphere.v3Position = prevPosition + (float)(i/(float)nSubCheckCount) * kPDelta;
for (DWORD j = 0; j < c_rVictimSphereVector.size(); ++j)
for (DWORD j = 0; j < victimSize; ++j)
{
CDynamicSphereInstance & c_rVictimSphere = c_rVictimSphereVector[j];
@@ -593,9 +614,10 @@ BOOL CActorInstance::TestActorCollision(CActorInstance & rVictim)
// 프레임 스킵시나 대상 오브젝트의 크기가 클경우 문제가 생길 여지가 있음
// 캐릭터가 자신의 Body Sphere Radius 보다 더 크게 이동했는지를 체크하고,
// 만약 그렇지 않다면 거리로 체크해서 걸러준다.
// Optimized: Already using squared distance comparison
D3DXVECTOR3 v3Distance = D3DXVECTOR3(rVictim.m_x - m_x, rVictim.m_y - m_y, rVictim.m_z - m_z);
float fDistance = D3DXVec3LengthSq(&v3Distance);
if (fDistance > 800.0f*800.0f)
float fDistanceSq = D3DXVec3LengthSq(&v3Distance);
if (fDistanceSq > 800.0f*800.0f)
return FALSE;
// NOTE : 공격 중일때는 Defending Sphere로 Collision Check를 합니다.
@@ -613,16 +635,21 @@ BOOL CActorInstance::TestActorCollision(CActorInstance & rVictim)
pVictimList = &rVictim.m_BodyPointInstanceList;
}
// Optimized: Cache end iterators and vector sizes
TCollisionPointInstanceListIterator itorMain = pMainList->begin();
TCollisionPointInstanceListIterator itorMain_end = pMainList->end();
TCollisionPointInstanceListIterator itorVictim = pVictimList->begin();
for (; itorMain != pMainList->end(); ++itorMain)
for (; itorVictim != pVictimList->end(); ++itorVictim)
TCollisionPointInstanceListIterator itorVictim_end = pVictimList->end();
for (; itorMain != itorMain_end; ++itorMain)
for (; itorVictim != itorVictim_end; ++itorVictim)
{
const CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
const CDynamicSphereInstanceVector & c_rVictimSphereVector = (*itorVictim).SphereInstanceVector;
DWORD mainSize = c_rMainSphereVector.size();
DWORD victimSize = c_rVictimSphereVector.size();
for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
for (DWORD j = 0; j < c_rVictimSphereVector.size(); ++j)
for (DWORD i = 0; i < mainSize; ++i)
for (DWORD j = 0; j < victimSize; ++j)
{
const CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector[i];
const CDynamicSphereInstance & c_rVictimSphere = c_rVictimSphereVector[j];
@@ -694,14 +721,17 @@ BOOL CActorInstance::__TestObjectCollision(const CGraphicObjectInstance * c_pObj
if (m_canSkipCollision)
return FALSE;
if (m_v3Movement.x == 0.0f && m_v3Movement.y == 0.0f && m_v3Movement.z == 0.0f)
if (m_v3Movement.x == 0.0f && m_v3Movement.y == 0.0f && m_v3Movement.z == 0.0f)
return FALSE;
// Optimized: Cache end iterator and vector size
TCollisionPointInstanceListIterator itorMain = m_BodyPointInstanceList.begin();
for (; itorMain != m_BodyPointInstanceList.end(); ++itorMain)
TCollisionPointInstanceListIterator itorMain_end = m_BodyPointInstanceList.end();
for (; itorMain != itorMain_end; ++itorMain)
{
const CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
DWORD mainSize = c_rMainSphereVector.size();
for (DWORD i = 0; i < mainSize; ++i)
{
const CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector[i];
@@ -725,11 +755,14 @@ BOOL CActorInstance::__TestObjectCollision(const CGraphicObjectInstance * c_pObj
bool CActorInstance::TestCollisionWithDynamicSphere(const CDynamicSphereInstance & dsi)
{
// Optimized: Cache end iterator and vector size
TCollisionPointInstanceListIterator itorMain = m_BodyPointInstanceList.begin();
for (; itorMain != m_BodyPointInstanceList.end(); ++itorMain)
TCollisionPointInstanceListIterator itorMain_end = m_BodyPointInstanceList.end();
for (; itorMain != itorMain_end; ++itorMain)
{
const CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
DWORD mainSize = c_rMainSphereVector.size();
for (DWORD i = 0; i < mainSize; ++i)
{
const CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector[i];

5
src/GameLib/MapOutdoorRender.cpp
View File

@@ -40,7 +40,8 @@ void CMapOutdoor::RenderTerrain()
//////////////////////////////////////////////////////////////////////////
// Push
m_PatchVector.clear();
m_PatchVector.reserve(256); // Pre-allocate to avoid reallocations
__RenderTerrain_RecurseRenderQuadTree(m_pRootNode);
// 거리순 정렬
@@ -491,6 +492,7 @@ void CMapOutdoor::RenderArea(bool bRenderAmbience)
{
static std::vector<CGraphicThingInstance*> s_kVct_pkOpaqueThingInstSort;
s_kVct_pkOpaqueThingInstSort.clear();
s_kVct_pkOpaqueThingInstSort.reserve(512); // Pre-allocate to avoid reallocations
for (int i = 0; i < AROUND_AREA_NUM; ++i)
{
@@ -522,6 +524,7 @@ void CMapOutdoor::RenderBlendArea()
static std::vector<CGraphicThingInstance*> s_kVct_pkBlendThingInstSort;
s_kVct_pkBlendThingInstSort.clear();
s_kVct_pkBlendThingInstSort.reserve(256); // Pre-allocate to avoid reallocations
for (int i = 0; i < AROUND_AREA_NUM; ++i)
{

1
src/UserInterface/InstanceBase.h
View File

@@ -640,6 +640,7 @@ class CInstanceBase
float NEW_GetDistanceFromDirPixelPosition(const TPixelPosition& c_rkPPosDir);
float NEW_GetDistanceFromDestPixelPosition(const TPixelPosition& c_rkPPosDst);
float NEW_GetDistanceFromDestInstance(CInstanceBase& rkInstDst);
float NEW_GetDistanceFromDestInstanceSquared(CInstanceBase& rkInstDst); // Optimized: no sqrt
float NEW_GetRotation();
float NEW_GetRotationFromDestPixelPosition(const TPixelPosition& c_rkPPosDst);

13
src/UserInterface/InstanceBaseBattle.cpp
View File

@@ -91,6 +91,19 @@ float CInstanceBase::NEW_GetDistanceFromDirPixelPosition(const TPixelPosition& c
return sqrtf(c_rkPPosDir.x*c_rkPPosDir.x+c_rkPPosDir.y*c_rkPPosDir.y);
}
// Optimized: Get squared distance (avoid sqrt for comparisons)
float CInstanceBase::NEW_GetDistanceFromDestInstanceSquared(CInstanceBase& rkInstDst)
{
TPixelPosition kPPosDst;
rkInstDst.NEW_GetPixelPosition(&kPPosDst);
TPixelPosition kPPosCur;
NEW_GetPixelPosition(&kPPosCur);
TPixelPosition kPPosDir = kPPosDst - kPPosCur;
return kPPosDir.x * kPPosDir.x + kPPosDir.y * kPPosDir.y;
}
float CInstanceBase::NEW_GetRotation()
{
float fCurRot=GetRotation();

6
src/UserInterface/PythonCharacterManager.cpp
View File

@@ -178,8 +178,10 @@ void CPythonCharacterManager::Update()
continue;
}
int nDistance = int(pkInstEach->NEW_GetDistanceFromDestInstance(*pkInstMain));
if (nDistance > CHAR_STAGE_VIEW_BOUND + 10)
// Optimized: Use squared distance to avoid sqrt
float fDistanceSquared = pkInstEach->NEW_GetDistanceFromDestInstanceSquared(*pkInstMain);
const float fViewBoundSquared = (CHAR_STAGE_VIEW_BOUND + 10) * (CHAR_STAGE_VIEW_BOUND + 10);
if (fDistanceSquared > fViewBoundSquared)
{
__DeleteBlendOutInstance(pkInstEach);
m_kAliveInstMap.erase(c);