XeNTaX

Game Research Forum
https://forum.xentax.com/

.elu GunZ 1.5 Online - New Mesh.

https://forum.xentax.com/viewtopic.php?t=17596

Page 1 of 1

.elu GunZ 1.5 Online - New Mesh.

Posted: Mon Jan 22, 2018 3:39 pm
by TaigaOwX
I'm trying to import the new models of GunZ The Duel, with the existing script in this thread, but when I checked I realized that this new format has another reading system, I want to know if someone from the community can help me by generating the new script.
http://forum.ragezone.com/f245/elu-ani- ... er-488857/

checking the C ++ code of the game you can find the new format, I do not know if this can help you in speed up the creation of the script.

Code: Select all

bool RMesh::ReadNewElu(MZFile* mzf, char* fname) {
#define MZF_READ(x,y) { if(!mzf->Read((x),(y))) return false; }
#define MZF_READ_XOR(x,y) { if(!mzf->Read((x),(y))) return false; }
#define MZF_READ_XOR_SPECIAL(x,y) { if(!mzf->Read((x),(y))) return false; for (int i = 0; i < y; ++i) *(BYTE*)(x + i) ^= 0; }
  int i;
    unsigned short count_mesh = 0;
    MZF_READ_XOR(&count_mesh, 2);

  for(i=0; i < count_mesh; i++)
  {

    char Name[256];
    memset(Name, 0, sizeof(Name));

    unsigned short count_name = 0;
    unsigned short count_name_Parent = 0;
    MZF_READ_XOR(&count_name, 2);
    MZF_READ_XOR(Name  ,count_name );
    MZF_READ_XOR(&count_name_Parent, 2);
    RMeshNode* pMeshNode = new RMeshNode;
    D3DXMatrixIdentity(&pMeshNode->m_mat_base);
    pMeshNode->m_id = m_data_num;
    memset(pMeshNode->m_Parent, 0, sizeof(pMeshNode->m_Parent));
    pMeshNode->m_pParentMesh = this;
    pMeshNode->m_pBaseMesh = this;
    pMeshNode->SetName(Name);
    MZF_READ_XOR(pMeshNode->m_Parent, count_name_Parent );
    MZF_READ_XOR(pMeshNode->m_axis_scale,sizeof(D3DXVECTOR3) );
    MZF_READ_XOR(pMeshNode->m_mat_etc,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(pMeshNode->m_mat_ref,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(pMeshNode->m_mat_inv,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(&pMeshNode->m_axis_rot_angle,sizeof(float) );
    MZF_READ_XOR(pMeshNode->m_mat_base,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(pMeshNode->m_mat_ref_inv,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(pMeshNode->m_axis_rot,sizeof(D3DXVECTOR3) );
    MZF_READ_XOR(&pMeshNode->m_axis_scale_angle,sizeof(float) );
    MZF_READ_XOR(pMeshNode->m_mat_local,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(pMeshNode->m_mat_result,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(pMeshNode->m_mat_scale,sizeof(D3DXMATRIX) );
    MZF_READ_XOR(pMeshNode->m_ap_scale,sizeof(D3DXVECTOR3) );
    MZF_READ_XOR(pMeshNode->m_mat_flip,sizeof(D3DXMATRIX) );
    
    CheckNameToType(pMeshNode);
    MZF_READ_XOR(&pMeshNode->m_point_num,4 );

    if(pMeshNode->m_point_num != 0) {
    
      pMeshNode->m_point_list = new D3DXVECTOR3[pMeshNode->m_point_num];
      memset(pMeshNode->m_point_list,0,pMeshNode->m_point_num * sizeof(D3DXVECTOR3));
      int p = 0;
      for (p = 0; p < pMeshNode->m_point_num; p++)
      {
      MZF_READ_XOR(pMeshNode->m_point_list[p],sizeof(D3DXVECTOR3));
      }
      pMeshNode->CalcLocalBBox();
    }

    //tex uv 까지 포함

    MZF_READ_XOR(&pMeshNode->m_face_num,4 );


    if(pMeshNode->m_face_num) {

      pMeshNode->m_face_list = new RFaceInfo[pMeshNode->m_face_num];
      pMeshNode->m_face_normal_list = new RFaceNormalInfo[pMeshNode->m_face_num];

      memset(pMeshNode->m_face_list, 0, pMeshNode->m_face_num * sizeof(RFaceInfo));

        MZF_READ(pMeshNode->m_face_list,sizeof(RFaceInfo)*pMeshNode->m_face_num);
        MZF_READ(pMeshNode->m_face_normal_list,sizeof(RFaceNormalInfo)*pMeshNode->m_face_num);

    }
    /*
    if(pMeshNode->m_face_num) {

      pMeshNode->m_face_list = new RFaceInfo[pMeshNode->m_face_num];
      pMeshNode->m_face_normal_list = new RFaceNormalInfo[pMeshNode->m_face_num];

      memset(pMeshNode->m_face_list, 0, pMeshNode->m_face_num * sizeof(RFaceInfo));

      int p = 0;
      for (p = 0; p < pMeshNode->m_face_num; p++)
      {
      MZF_READ_XOR(&pMeshNode->m_face_list[p],sizeof(RFaceInfo));
      }
      int e = 0;
      for (e = 0; e < pMeshNode->m_face_num; e++)
      {
      MZF_READ_XOR(&pMeshNode->m_face_normal_list[e],sizeof(RFaceNormalInfo));
      }
      //MZF_READ_XOR(pMeshNode->m_face_list,sizeof(RFaceInfo)*pMeshNode->m_face_num);
      //MZF_READ_XOR(pMeshNode->m_face_normal_list,sizeof(RFaceNormalInfo)*pMeshNode->m_face_num);
    }*/
    
    MZF_READ_XOR(&pMeshNode->m_point_color_num,4 );

    if(pMeshNode->m_point_color_num) {
        pMeshNode->m_point_color_list = new D3DXVECTOR3 [pMeshNode->m_point_color_num];
        MZF_READ_XOR(pMeshNode->m_point_color_list,sizeof(D3DXVECTOR3)*pMeshNode->m_point_color_num);
    }

    if( (pMeshNode->m_point_num==0) || (pMeshNode->m_face_num==0) ) {
      pMeshNode->m_isDummyMesh = true;
    }

    MZF_READ_XOR(&pMeshNode->m_mtrl_id,4 );

    MZF_READ_XOR(&pMeshNode->m_physique_num,4 );

    if(pMeshNode->m_physique_num) {
      
      m_isPhysiqueMesh = true;
      pMeshNode->m_physique = new RPhysiqueInfo[pMeshNode->m_physique_num];
      ZeroMemory(pMeshNode->m_physique,pMeshNode->m_physique_num * sizeof(RPhysiqueInfo));
      
      for(int j=0;j<pMeshNode->m_physique_num;j++) {
        int infcount = 0;
        MZF_READ_XOR(&infcount,1 );
        pMeshNode->m_physique[j].m_num = infcount;
        for (int k=0; k<infcount;k++)
        {
          int countiname = 0;
          MZF_READ_XOR(&pMeshNode->m_physique[j].m_parent_id[k], 4);
          MZF_READ_XOR(&pMeshNode->m_physique[j].m_weight[k], 4);
          MZF_READ_XOR(&pMeshNode->m_physique[j].m_offset[k], 12);
          MZF_READ_XOR(&countiname,2 );  
          MZF_READ_XOR(&pMeshNode->m_physique[j].m_parent_name[k], countiname);
          
        }
      }
    }
    if(pMeshNode->m_point_color_num>0 && pMeshNode->m_PartsType == eq_parts_chest )
      pMeshNode->m_isClothMeshNode = true;

    m_list.PushBack(pMeshNode);
    
    m_data.push_back( pMeshNode );
    m_data_num++;

    if( MAX_MESH_NODE_TABLE != (int)m_data.capacity() )
    {
      mlog( "m_data number is not quite right..! (%d)\n", (int)m_data.capacity());
      return false;
    }
  }
  unsigned short count_mtrl;
  MZF_READ_XOR(&count_mtrl, 2);
  i = 0;

  if(count_mtrl)
  {
  for(i=0;i<count_mtrl;i++) {

    RMtrl* node = new RMtrl;

      MZF_READ_XOR(&node->m_mtrl_id    ,4 );
    MZF_READ_XOR(&node->m_sub_mtrl_id,4 );

    MZF_READ_XOR(&node->m_ambient ,sizeof(D3DXCOLOR) );
    MZF_READ_XOR(&node->m_diffuse ,sizeof(D3DXCOLOR) );
    MZF_READ_XOR(&node->m_specular,sizeof(D3DXCOLOR) );

    MZF_READ_XOR(&node->m_power,4 );
    MZF_READ_XOR(&node->m_sub_mtrl_num,4 );
    unsigned short count_name;
    unsigned short count_opa_name;

    MZF_READ_XOR(&count_name, 2 );
    memset(node->m_name, 0, sizeof(node->m_name));
    MZF_READ_XOR(node->m_name    , count_name  );
    memset(node->m_opa_name, 0, sizeof(node->m_opa_name));
    MZF_READ_XOR(&count_opa_name, 2 );
    MZF_READ_XOR(node->m_opa_name, count_opa_name );
    char twoside=0;
      MZF_READ_XOR(&twoside,sizeof(char) );
      node->m_bTwoSided = twoside ? false : true;
    char additive = 0;
      MZF_READ_XOR(&additive,sizeof(char) );
	  node->m_bAdditive = additive ? false : true;
   int alpha_test = 0;
      MZF_READ_XOR(&alpha_test,sizeof(int) );
      node->m_nAlphaTestValue = alpha_test;
      node->m_bAlphaTestMap = alpha_test != 0;  
  char diffuse = 0;
      MZF_READ_XOR(&diffuse,sizeof(char) );
	  node->m_bDiffuseMap = diffuse ? false : true;
  char alpha_map = 0;
      MZF_READ_XOR(&alpha_map,sizeof(char) );
      node->m_bAlphaMap = alpha_map ? false : true;



    node->CheckAniTexture();

    m_mtrl_list_ex.Add(node);
  }
  }

  return true;
#undef MZF_READ

}

bool RMesh::ReadOldElu(MZFile* mzf, ex_hd_t* m_phd_t) {

#define MZF_READ(x,y) { if(!mzf->Read((x),(y))) return false; }


		int i,j,k;
	// sub mtrl 까지 포함한 갯수
	for(i=0;i<m_phd_t->mtrl_num;i++) {

		RMtrl* node = new RMtrl;

		MZF_READ(&node->m_mtrl_id    ,4 );
		MZF_READ(&node->m_sub_mtrl_id,4 );

		MZF_READ(&node->m_ambient ,sizeof(D3DXCOLOR) );
		MZF_READ(&node->m_diffuse ,sizeof(D3DXCOLOR) );
		MZF_READ(&node->m_specular,sizeof(D3DXCOLOR) );

		MZF_READ(&node->m_power,4 );

		node->m_power *= 100.f;

		if(m_phd_t->ver <= EXPORTER_MESH_VER3)
			if(node->m_power == 2000.f)
				node->m_power = 0.f;

//		node->m_power = 80.f;

		MZF_READ(&node->m_sub_mtrl_num,4 );

		if(m_phd_t->ver < EXPORTER_MESH_VER7) {
			MZF_READ(&node->m_name    ,MAX_NAME_LEN );
			MZF_READ(&node->m_opa_name,MAX_NAME_LEN );
		}
		else {
			MZF_READ(&node->m_name    ,MAX_PATH_NAME_LEN );
			MZF_READ(&node->m_opa_name,MAX_PATH_NAME_LEN );
		}

		if(m_phd_t->ver > EXPORTER_MESH_VER2) {//ver3 부터
			int twoside=0;
			MZF_READ(&twoside,sizeof(int) );
			node->m_bTwoSided = twoside ? true : false;
		}

		if(m_phd_t->ver > EXPORTER_MESH_VER4) {
			int additive = 0;
			MZF_READ(&additive,sizeof(int) );
			node->m_bAdditive = additive ? true : false;
		}

		if(m_phd_t->ver > EXPORTER_MESH_VER7 )//ver8 부터
		{
			int alpha_test = 0;
			MZF_READ(&alpha_test,sizeof(int) );
			node->m_bAlphaTestMap = alpha_test ? true : false;
			node->m_nAlphaTestValue = alpha_test;
		}
		
		if( node->m_name[0] ) {

			int	 len = strlen(node->m_name);
			char _temp[5];

			strncpy(_temp,&node->m_name[len-4],4);

			_temp[4] = 0;

			if( stricmp(_temp,".tga")==0 ) {
				node->m_bDiffuseMap = true;
			}

			if( node->m_opa_name[0] ) {
				node->m_bAlphaMap	= true;
				node->m_bDiffuseMap = false;
			}
		}

		if( node->m_bAlphaTestMap ) {
			node->m_bAlphaMap	= false;
			node->m_bDiffuseMap = false;
		}

		node->CheckAniTexture();

		m_mtrl_list_ex.Add(node);
	}

	bool bNeedScaleMat = false;
	D3DXMATRIX smat;

	for(i=0;i<m_phd_t->mesh_num;i++) {

		bNeedScaleMat = false;

		RMeshNode* pMeshNode = new RMeshNode;

//		memset( pMeshNode, 0, sizeof(RMeshNode));
//		pMeshNode->m_mtrl_id = -1;
		D3DXMatrixIdentity(&pMeshNode->m_mat_base);

		pMeshNode->m_id = m_data_num;//last id
		pMeshNode->m_pParentMesh = this;
		pMeshNode->m_pBaseMesh = this;

		char Name[256];
		Name[0] = NULL;

		MZF_READ(Name  ,MAX_NAME_LEN );
//		MZF_READ(pMeshNode->m_Name  ,MAX_NAME_LEN );
		MZF_READ(pMeshNode->m_Parent,MAX_NAME_LEN );
		MZF_READ(&pMeshNode->m_mat_base,sizeof(D3DXMATRIX) );//mat

#ifdef _DEBUG
		char name[256];
		sprintf(name, Name);
		TrimStr(name, name);
#endif
		pMeshNode->SetName( Name );

		pMeshNode->m_mat_ref = pMeshNode->m_mat_base;
		D3DXMatrixInverse( &pMeshNode->m_mat_ref_inv , 0, &pMeshNode->m_mat_ref );
		
		if(m_phd_t->ver >= EXPORTER_MESH_VER2) {
			MZF_READ(&pMeshNode->m_ap_scale,sizeof(D3DXVECTOR3) );//mat
		}
		else  {
			pMeshNode->m_ap_scale.x = 1.f;
			pMeshNode->m_ap_scale.y = 1.f;
			pMeshNode->m_ap_scale.z = 1.f;
		}

		///////////////////////////////////////////////

		if(m_phd_t->ver >= EXPORTER_MESH_VER4) {

			MZF_READ(&pMeshNode->m_axis_rot,sizeof(D3DXVECTOR3) );
			MZF_READ(&pMeshNode->m_axis_rot_angle,sizeof(float) );

			MZF_READ(&pMeshNode->m_axis_scale,sizeof(D3DXVECTOR3) );
			MZF_READ(&pMeshNode->m_axis_scale_angle,sizeof(float) );

			MZF_READ(&pMeshNode->m_mat_etc,sizeof(D3DXMATRIX) );//mat

			D3DXMATRIX scalemat;
			D3DXMATRIX scalepivot;
			D3DXMATRIX scalepivotinv;
			D3DXMATRIX flipmat;

			D3DXMatrixScaling( &scalemat, pMeshNode->m_ap_scale.x, pMeshNode->m_ap_scale.y, pMeshNode->m_ap_scale.z );
			D3DXMatrixRotationAxis( &scalepivot, &pMeshNode->m_axis_scale, pMeshNode->m_axis_scale_angle );
			D3DXMatrixInverse( &scalepivotinv, NULL, &scalepivot );

			D3DXMatrixIdentity(&flipmat);

			pMeshNode->m_mat_flip = flipmat;

//			result_mat2 = scalepivotinv * scalemat * scalepivot;
			pMeshNode->m_mat_etc = scalepivotinv * scalemat * scalepivot;

		}
		else {

			D3DXMatrixIdentity(&pMeshNode->m_mat_etc);
			D3DXMatrixIdentity(&pMeshNode->m_mat_flip);
		}

		memcpy(&pMeshNode->m_mat_local,&pMeshNode->m_mat_base,sizeof(D3DXMATRIX));

		pMeshNode->m_mat_result = pMeshNode->m_mat_base;

		D3DXMatrixScaling(&pMeshNode->m_mat_scale, pMeshNode->m_ap_scale.x, pMeshNode->m_ap_scale.y, pMeshNode->m_ap_scale.z);

		RMatInv(pMeshNode->m_mat_inv,pMeshNode->m_mat_local);

		CheckNameToType(pMeshNode);

		MZF_READ(&pMeshNode->m_point_num,4 );

		if(pMeshNode->m_point_num) {
		
			pMeshNode->m_point_list = new D3DXVECTOR3[pMeshNode->m_point_num];
			memset(pMeshNode->m_point_list,0,pMeshNode->m_point_num * sizeof(D3DXVECTOR3));

			MZF_READ(pMeshNode->m_point_list,sizeof(D3DXVECTOR3)*pMeshNode->m_point_num);

			pMeshNode->CalcLocalBBox();
		}

		//tex uv 까지 포함

		MZF_READ(&pMeshNode->m_face_num,4 );

		if(pMeshNode->m_face_num) {

			pMeshNode->m_face_list = new RFaceInfo[pMeshNode->m_face_num];
			pMeshNode->m_face_normal_list = new RFaceNormalInfo[pMeshNode->m_face_num];

			memset(pMeshNode->m_face_list, 0, pMeshNode->m_face_num * sizeof(RFaceInfo));

			if(m_phd_t->ver >= EXPORTER_MESH_VER6 ) {//ver 6

				MZF_READ(pMeshNode->m_face_list,sizeof(RFaceInfo)*pMeshNode->m_face_num);
				MZF_READ(pMeshNode->m_face_normal_list,sizeof(RFaceNormalInfo)*pMeshNode->m_face_num);

			}
			else if(m_phd_t->ver > EXPORTER_MESH_VER2) {//ver3 부터

				MZF_READ(pMeshNode->m_face_list,sizeof(RFaceInfo)*pMeshNode->m_face_num);
			}
			else {									//ver3 이하

				RFaceInfoOld* pInfo = new RFaceInfoOld[pMeshNode->m_face_num];
				MZF_READ(pInfo,sizeof(RFaceInfoOld)*pMeshNode->m_face_num);

				ConvertOldFaceInfo(pMeshNode->m_face_list,pInfo,pMeshNode->m_face_num);

				delete[] pInfo;
			}
		}

		if( m_phd_t->ver >= EXPORTER_MESH_VER6 ) {
		
			MZF_READ(&pMeshNode->m_point_color_num,4 );

			if(pMeshNode->m_point_color_num) {
				pMeshNode->m_point_color_list = new D3DXVECTOR3 [pMeshNode->m_point_color_num];
				MZF_READ(pMeshNode->m_point_color_list,sizeof(D3DXVECTOR3)*pMeshNode->m_point_color_num);
			}
		}

		if( (pMeshNode->m_point_num==0) || (pMeshNode->m_face_num==0) ) {
			pMeshNode->m_isDummyMesh = true;
		}

		//////////////////////////////////////////////
		
		MZF_READ(&pMeshNode->m_mtrl_id,4 );

		MZF_READ(&pMeshNode->m_physique_num,4 );

		if(pMeshNode->m_physique_num) {
			
			m_isPhysiqueMesh = true;

			pMeshNode->m_physique = new RPhysiqueInfo[pMeshNode->m_physique_num];
			ZeroMemory(pMeshNode->m_physique,pMeshNode->m_physique_num * sizeof(RPhysiqueInfo));

			for(int j=0;j<pMeshNode->m_physique_num;j++) {

				MZF_READ( &pMeshNode->m_physique[j],sizeof(RPhysiqueInfo) );
			}
		}

		D3DXPLANE	plane;
		D3DXVECTOR3	vv[3];

		if( m_phd_t->ver < EXPORTER_MESH_VER6 ) {

			if(pMeshNode->m_face_num) {
			
				for(int a=0;a<pMeshNode->m_face_num;a++) {

					vv[0] = pMeshNode->m_point_list[pMeshNode->m_face_list[a].m_point_index[0]];
					vv[1] = pMeshNode->m_point_list[pMeshNode->m_face_list[a].m_point_index[1]];
					vv[2] = pMeshNode->m_point_list[pMeshNode->m_face_list[a].m_point_index[2]];

					D3DXPlaneFromPoints(&plane,&vv[0],&vv[1],&vv[2]);
					D3DXPlaneNormalize(&plane,&plane);

					pMeshNode->m_face_normal_list[a].m_normal.x = plane.a;
					pMeshNode->m_face_normal_list[a].m_normal.y = plane.b;
					pMeshNode->m_face_normal_list[a].m_normal.z = plane.c;
				}
			}

			if(pMeshNode->m_point_num&&pMeshNode->m_point_num) 
			{
				D3DXVECTOR3* pPointNormal = new D3DXVECTOR3 [pMeshNode->m_point_num];
				memset(pPointNormal,0,sizeof(D3DXVECTOR3)*pMeshNode->m_point_num);
			

				for(k=0;k<pMeshNode->m_face_num;k++) {
					for(j=0;j<3;j++) {
						pPointNormal[ pMeshNode->m_face_list[k].m_point_index[j] ] =
							pPointNormal[pMeshNode->m_face_list[k].m_point_index[j]] + pMeshNode->m_face_normal_list[k].m_normal;
					}
				}

				for(k=0;k<pMeshNode->m_point_num;k++) {
					pPointNormal[k] = pPointNormal[k]/3.f;
					D3DXVec3Normalize(&pPointNormal[k],&pPointNormal[k]);
				}

				for(k=0;k<pMeshNode->m_face_num;k++) {
					for(j=0;j<3;j++) {
						pMeshNode->m_face_normal_list[k].m_pointnormal[j] = pPointNormal[ pMeshNode->m_face_list[k].m_point_index[j] ];
					}
				}

				delete [] pPointNormal;

			}
		}

		if(pMeshNode->m_point_color_num>0 && pMeshNode->m_PartsType == eq_parts_chest )
			pMeshNode->m_isClothMeshNode = true;

		m_list.PushBack(pMeshNode);
		
		m_data.push_back( pMeshNode );
		m_data_num++;

		if( MAX_MESH_NODE_TABLE != (int)m_data.capacity() )
		{
			mlog( "m_data number is not quite right..! (%d)\n", (int)m_data.capacity());
		}
	}

return true;

#undef MZF_READ
}
I hope you can help me
All times are UTC+01:00
Page 1 of 1

Powered by phpBB® Forum Software © phpBB Limited