metin-server/m2dev-client-src
3
0
Fork 1
Code Issues Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity

Networking Overhaul: Modern packets, buffers, handshake, dispatch & security hardening

Browse Source 
See Readme
This commit is contained in:
rtw1x1
2026-02-08 07:36:07 +00:00
parent 058589ca1b
commit cda1c73bd3
72 changed files with 3612 additions and 6155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/EterGrnLib/Material.cpp
View File

@@ -508,53 +508,3 @@ DWORD CGrannyMaterialPalette::GetMaterialCount() const
return m_mtrlVector.size();
}
/*
void CActorInstance::BeginSpecularRender()
{
// NOTE - Blending해서 찍는 부분은 Specular를 적용시키지 않는다 - [levites]
STATEMANAGER.SaveRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, D3DXCOLOR(1.0f, 1.0f, 1.0f, m_AddColor.r));
STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR);
STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TEXTURE);
STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATEALPHA_ADDCOLOR);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
// STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
// STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
// STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
//
// STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
// STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TEXTURE);
// STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATEALPHA_ADDCOLOR);
// STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
// STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
// D3DXMATRIX texMatrix;
// GetSphereMatrix(&texMatrix);
// STATEMANAGER.SetTransform(D3DTS_TEXTURE1, &texMatrix);
// STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
// Type 1
// STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
// // Type 2
// STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACENORMAL);
}
void CActorInstance::EndSpecularRender()
{
// STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
// STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
}
*/

28
src/EterGrnLib/Mesh.cpp
View File

@@ -215,33 +215,7 @@ bool CGrannyMesh::LoadTriGroupNodeList(CGrannyMaterialPalette& rkMtrlPal)
void CGrannyMesh::RebuildTriGroupNodeList()
{
assert(!"CGrannyMesh::RebuildTriGroupNodeList() - 왜 리빌드를 하는가- -?");
/*
int mtrlCount = m_pgrnMesh->MaterialBindingCount;
int GroupNodeCount = GrannyGetMeshTriangleGroupCount(m_pgrnMesh);
if (GroupNodeCount <= 0)
return;
const granny_tri_material_group * c_pgrnTriGroups = GrannyGetMeshTriangleGroups(m_pgrnMesh);
for (int g = 0; g < GroupNodeCount; ++g)
{
const granny_tri_material_group& c_rgrnTriGroup = c_pgrnTriGroups[g];
TTriGroupNode * pTriGroupNode = m_triGroupNodes + g;
int iMtrl = c_rgrnTriGroup.MaterialIndex;
if (iMtrl >= 0 && iMtrl < mtrlCount)
{
CGrannyMaterial & rMtrl = m_mtrls[iMtrl];
pTriGroupNode->lpd3dTextures[0] = rMtrl.GetD3DTexture(0);
pTriGroupNode->lpd3dTextures[1] = rMtrl.GetD3DTexture(1);
}
}
*/
assert(!"CGrannyMesh::RebuildTriGroupNodeList() - should not be called");
}
bool CGrannyMesh::LoadMaterials(CGrannyMaterialPalette& rkMtrlPal)

123
src/EterGrnLib/ModelInstanceCollisionDetection.cpp
View File

@@ -90,90 +90,6 @@ bool CGrannyModelInstance::Intersect(const D3DXMATRIX * c_pMatrix,
return true;
/*
TBoundBox* boundBoxs = s_boundBoxPool.base();
for (int i = 0; i < s_boundBoxPool.size(); ++i)
{
TBoundBox& rcurBoundBox=boundBoxs[i];
if (!IntersectBoundBox(c_pMatrix, rcurBoundBox, &u, &v, &t))
continue;
granny_matrix_4x4* pgrnMatCompositeBuffer = GrannyGetWorldPoseComposite4x4Array(m_pgrnWorldPose);
const CGrannyMesh* c_pMesh = m_pModel->GetMeshPointer(rcurBoundBox.meshIndex);
const granny_mesh* c_pgrnMesh = c_pMesh->GetGrannyMeshPointer();
if (!GrannyMeshIsRigid(c_pgrnMesh))
{
//continue;
ret = true;
}
else
{
D3DXMATRIX matMesh;
int* toBoneIndices = c_pMesh->GetBoneIndices();
D3DXMatrixMultiply(&matMesh, (D3DXMATRIX*) pgrnMatCompositeBuffer[toBoneIndices[0]], c_pMatrix);
granny_tri_material_group* pgrnTriGroups = GrannyGetMeshTriangleGroups(c_pgrnMesh);
int mtrlCount = c_pMesh->GetGrannyMeshPointer()->MaterialBindingCount;
int vtxCount = GrannyGetMeshVertexCount(c_pgrnMesh);
int groupCount = GrannyGetMeshTriangleGroupCount(c_pgrnMesh);
TIndex* modelIndices;
TPNTVertex* modelVertices;
if (m_pModel->LockVertices((void**)&modelIndices, (void**)&modelVertices))
{
TIndex* meshIndices = modelIndices + c_pMesh->GetIndexBasePosition();
TPNTVertex* meshVertices = modelVertices + c_pMesh->GetVertexBasePosition();
for (int i = 0; i < groupCount; ++i)
{
granny_tri_material_group& rgrnTriGroup = pgrnTriGroups[i];
if (rgrnTriGroup.MaterialIndex < 0 || rgrnTriGroup.MaterialIndex >= mtrlCount)
continue;
if (IntersectMesh(&matMesh,
meshVertices,
sizeof(TPNTVertex),
vtxCount,
meshIndices,
GrannyGetMeshIndexCount(c_pgrnMesh),
ms_vtPickRayOrig,
ms_vtPickRayDir,
&u, &v, &t))
{
ret = true;
break;
}
}
m_pModel->UnlockVertices();
}
}
if (ret)
{
*pu = u;
*pv = v;
*pt = -t;
if (c_szModelName)
{
if (!strncmp(c_pgrnMesh->Name, c_szModelName, strlen(c_szModelName)))
return ret;
ret = false;
continue;
}
return ret;
}
}
return (ret);
*/
}
#include "EterBase/Timer.h"
@@ -226,42 +142,3 @@ bool CGrannyModelInstance::GetMeshMatrixPointer(int iMesh, const D3DXMATRIX ** c
return true;
}
/*
void CGraphicThingInstance::DrawBoundBox()
{
if (!mc_pMeshVector)
return;
if (!m_pgrnWorldPose)
return;
D3DXVECTOR3 vtMin;
D3DXVECTOR3 vtMax;
SetDiffuseColor(0.0f, 1.0f, 0.0f);
// 캐릭터 꽉차는 바운딩 박스
//GetBoundBox(&vtMin, &vtMax);
//DrawLineCube(vtMin.x, vtMin.y, vtMin.z, vtMax.x, vtMax.y, vtMax.z);
//const CThing::TMeshVector& rmeshVector=mc_pModel->meshVector;
ms_lpd3dMatStack->LoadMatrix(&m_Matrix);
for (size_t m=0; m<mc_pMeshVector->size(); ++m)
{
const CThing::TMesh& rmesh=mc_pMeshVector->at(m);
for (int b=0; b<rmesh.pgrnMesh->BoneBindingCount; ++b)
{
granny_bone_binding& rgrnBoneBinding=rmesh.pgrnMesh->BoneBindings[b];
int* toBoneIndices=GrannyGetMeshBindingToBoneIndices(rmesh.pgrnMeshBinding);
D3DXMATRIX* pmat=(D3DXMATRIX*)GrannyGetWorldPose4x4(m_pgrnWorldPose, toBoneIndices[b]);
D3DXVec3TransformCoord(&vtMin, &D3DXVECTOR3(rgrnBoneBinding.OBBMin), pmat);
D3DXVec3TransformCoord(&vtMax, &D3DXVECTOR3(rgrnBoneBinding.OBBMax), pmat);
DrawLineCube(vtMin.x, vtMin.y, vtMin.z, vtMax.x, vtMax.y, vtMax.z);
}
}
}
*/

106
src/EterGrnLib/ModelInstanceRender.cpp
View File

@@ -299,109 +299,3 @@ void CGrannyModelInstance::RenderMeshNodeListWithoutTexture(CGrannyMesh::EType e
}
}
/*
void CGrannyModelInstance::RenderMeshNodeList(CGrannyMesh::EType eMeshType, CGrannyMaterial::EType eMtrlType)
{
assert(m_pModel != NULL);
LPDIRECT3DINDEXBUFFER9 lpd3dIdxBuf = m_pModel->GetD3DIndexBuffer();
assert(lpd3dIdxBuf != NULL);
const CGrannyModel::TMeshNode * pMeshNode = m_pModel->GetMeshNodeList(eMeshType, eMtrlType);
while (pMeshNode)
{
const CGrannyMesh * pMesh = pMeshNode->pMesh;
int vtxMeshBasePos = pMesh->GetVertexBasePosition();
STATEMANAGER.SetIndices(lpd3dIdxBuf, vtxMeshBasePos);
STATEMANAGER.SetTransform(D3DTS_WORLD, &m_meshMatrices[pMeshNode->iMesh]);
/////
const CGrannyMesh::TTriGroupNode* pTriGroupNode = pMesh->GetTriGroupNodeList(eMtrlType);
int vtxCount = pMesh->GetVertexCount();
while (pTriGroupNode)
{
ms_faceCount += pTriGroupNode->triCount;
STATEMANAGER.SetTexture(0, pTriGroupNode->lpd3dTextures[0]);
if (pTriGroupNode->lpd3dTextures[1])
STATEMANAGER.SetTexture(1, pTriGroupNode->lpd3dTextures[1]);
else
{
STATEMANAGER.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
STATEMANAGER.SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
STATEMANAGER.SetTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
STATEMANAGER.SetTexture(1, m_FogInstance.GetTexturePointer()->GetD3DTexture());
D3DXMATRIX mat;
memset(&mat, 0, sizeof(D3DXMATRIX));
mat._31 = -0.001f;
mat._41 = -7.0f;
mat._42 = 0.5f;
STATEMANAGER.SetTransform(D3DTS_TEXTURE1, &mat);
}
STATEMANAGER.DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, vtxCount, pTriGroupNode->idxPos, pTriGroupNode->triCount);
if (!pTriGroupNode->lpd3dTextures[1])
{
STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
STATEMANAGER.SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
STATEMANAGER.SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
}
pTriGroupNode = pTriGroupNode->pNextTriGroupNode;
}
/////
pMeshNode = pMeshNode->pNextMeshNode;
}
}
void CGrannyModelInstance::RenderToShadowMap()
{
if (IsEmpty())
return;
STATEMANAGER.SetFVF(ms_pntVS);
// LPDIRECT3DVERTEXBUFFER9 lpd3dDynamicPNTVtxBuf = m_dynamicPNTVtxBuf.GetD3DVertexBuffer();
LPDIRECT3DVERTEXBUFFER9 lpd3dDeformPNTVtxBuf = m_dynamicPNTVtxBuf.GetD3DVertexBuffer();
LPDIRECT3DVERTEXBUFFER9 lpd3dRigidPNTVtxBuf = m_pModel->GetPNTD3DVertexBuffer();
// STATEMANAGER.SaveRenderState(D3DRS_ALPHATESTENABLE, TRUE);
// STATEMANAGER.SaveRenderState(D3DRS_ALPHAREF, 0);
// STATEMANAGER.SaveRenderState(D3DRS_ALPHAFUNC, D3DCMP_NOTEQUAL);
//
// if (lpd3dDynamicPNTVtxBuf)
// {
// STATEMANAGER.SetStreamSource(0, lpd3dDynamicPNTVtxBuf, sizeof(TPNTVertex));
// RenderMeshNodeListWithoutTexture(CGrannyMesh::TYPE_DEFORM, CGrannyMaterial::TYPE_BLEND_PNT);
// }
//
// STATEMANAGER.RestoreRenderState(D3DRS_ALPHATESTENABLE);
// STATEMANAGER.RestoreRenderState(D3DRS_ALPHAREF);
// STATEMANAGER.RestoreRenderState(D3DRS_ALPHAFUNC);
if (lpd3dDeformPNTVtxBuf)
{
STATEMANAGER.SetStreamSource(0, lpd3dDeformPNTVtxBuf, sizeof(TPNTVertex));
RenderMeshNodeListWithoutTexture(CGrannyMesh::TYPE_DEFORM, CGrannyMaterial::TYPE_DIFFUSE_PNT);
}
if (lpd3dRigidPNTVtxBuf)
{
STATEMANAGER.SetStreamSource(0, lpd3dRigidPNTVtxBuf, sizeof(TPNTVertex));
RenderMeshNodeListWithoutTexture(CGrannyMesh::TYPE_RIGID, CGrannyMaterial::TYPE_DIFFUSE_PNT);
}
}
*/

43
src/EterGrnLib/Util.cpp
View File

@@ -1,50 +1,7 @@
#include "StdAfx.h"
#include "Util.h"
/*
bool GrannyMeshGetTextureAnimation(granny_mesh* pgrnMesh, float* puVelocity, float* pvVelocity)
{
static granny_data_type_definition s_UVType[] =
{
{GrannyInt32Member, "UV Animation Flag"},
{GrannyInt32Member, "X Velocity"},
{GrannyInt32Member, "Y Velocity"},
{GrannyEndMember}
};
typedef struct SUVData
{
granny_int32 UVAnimationFlag;
granny_int32 xVelocity;
granny_int32 yVelocity;
} TUVData;
TUVData UVData;
granny_variant& rExtendedData = pgrnMesh->ExtendedData;
GrannyConvertSingleObject(rExtendedData.Type, rExtendedData.Object, s_UVType, &UVData);
*puVelocity = float(UVData.xVelocity) / 100000.0f;
*pvVelocity = float(UVData.yVelocity) / 100000.0f;
return UVData.UVAnimationFlag ? true : false;
}
*/
/*
bool GrannyMeshIsTextureAnimation(granny_mesh* pgrnMesh)
{
if (GrannyMeshIsRigid(pgrnMesh))
{
float xVelocity, yVelocity;
if (GrannyMeshGetTextureAnimation(pgrnMesh, &xVelocity, &yVelocity))
return true;
}
return false;
}
*/
bool GrannyMeshIsDeform(granny_mesh* pgrnMesh)
{