WMOGroup Class Reference

#include <wmo.h>

Public Member Functions
	WMOGroup (std::string const &filename)
	~WMOGroup ()
bool	open ()
int	ConvertToVMAPGroupWmo (FILE *output, WMORoot *rootWMO, bool preciseVectorData)

Public Attributes
char *	MOPY
uint16 *	MOVI
uint16 *	MoviEx
float *	MOVT
uint16 *	MOBA
int *	MobaEx
WMOLiquidHeader *	hlq
WMOLiquidVert *	LiquEx
char *	LiquBytes
int	groupName
int	descGroupName
int	mogpFlags
float	bbcorn1 [3]
float	bbcorn2 [3]
uint16	moprIdx
uint16	moprNItems
uint16	nBatchA
uint16	nBatchB
uint32	nBatchC
uint32	fogIdx
uint32	liquidType
uint32	groupWMOID
int	mopy_size
int	moba_size
int	LiquEx_size
unsigned int	nVertices
int	nTriangles
uint32	liquflags

Private Attributes
std::string	filename

Constructor & Destructor Documentation

WMOGroup::WMOGroup

(

std::string const &

filename

)

 :
 filename(filename), MOPY(0), MOVI(0), MoviEx(0), MOVT(0), MOBA(0), MobaEx(0),
 hlq(0), LiquEx(0), LiquBytes(0), groupName(0), descGroupName(0), mogpFlags(0),
 moprIdx(0), moprNItems(0), nBatchA(0), nBatchB(0), nBatchC(0), fogIdx(0),
 liquidType(0), groupWMOID(0), mopy_size(0), moba_size(0), LiquEx_size(0),
 nVertices(0), nTriangles(0), liquflags(0)
{
 memset(bbcorn1, 0, sizeof(bbcorn1));
 memset(bbcorn2, 0, sizeof(bbcorn2));
}

WMOGroup::~WMOGroup

(

)

{
 delete [] MOPY;
 delete [] MOVI;
 delete [] MOVT;
 delete [] MOBA;
 delete hlq;
 delete [] LiquEx;
 delete [] LiquBytes;
}

Member Function Documentation

int WMOGroup::ConvertToVMAPGroupWmo	(	FILE *	output,
		WMORoot *	rootWMO,
		bool	preciseVectorData
	)

{
 fwrite(&mogpFlags,sizeof(uint32),1,output);
 fwrite(&groupWMOID,sizeof(uint32),1,output);
 // group bound
 fwrite(bbcorn1, sizeof(float), 3, output);
 fwrite(bbcorn2, sizeof(float), 3, output);
 fwrite(&liquflags,sizeof(uint32),1,output);
 int nColTriangles = 0;
 if (preciseVectorData)
 {
 char GRP[] = "GRP ";
 fwrite(GRP,1,4,output);

 int k = 0;
 int moba_batch = moba_size/12;
 MobaEx = new int[moba_batch*4];
 for(int i=8; i<moba_size; i+=12)
 {
 MobaEx[k++] = MOBA[i];
 }
 int moba_size_grp = moba_batch*4+4;
 fwrite(&moba_size_grp,4,1,output);
 fwrite(&moba_batch,4,1,output);
 fwrite(MobaEx,4,k,output);
 delete [] MobaEx;

 uint32 nIdexes = nTriangles * 3;

 if(fwrite("INDX",4, 1, output) != 1)
 {
 printf("Error while writing file nbraches ID");
 exit(0);
 }
 int wsize = sizeof(uint32) + sizeof(unsigned short) * nIdexes;
 if(fwrite(&wsize, sizeof(int), 1, output) != 1)
 {
 printf("Error while writing file wsize");
 // no need to exit?
 }
 if(fwrite(&nIdexes, sizeof(uint32), 1, output) != 1)
 {
 printf("Error while writing file nIndexes");
 exit(0);
 }
 if(nIdexes >0)
 {
 if(fwrite(MOVI, sizeof(unsigned short), nIdexes, output) != nIdexes)
 {
 printf("Error while writing file indexarray");
 exit(0);
 }
 }

 if(fwrite("VERT",4, 1, output) != 1)
 {
 printf("Error while writing file nbraches ID");
 exit(0);
 }
 wsize = sizeof(int) + sizeof(float) * 3 * nVertices;
 if(fwrite(&wsize, sizeof(int), 1, output) != 1)
 {
 printf("Error while writing file wsize");
 // no need to exit?
 }
 if(fwrite(&nVertices, sizeof(int), 1, output) != 1)
 {
 printf("Error while writing file nVertices");
 exit(0);
 }
 if(nVertices >0)
 {
 if(fwrite(MOVT, sizeof(float)*3, nVertices, output) != nVertices)
 {
 printf("Error while writing file vectors");
 exit(0);
 }
 }

 nColTriangles = nTriangles;
 }
 else
 {
 char GRP[] = "GRP ";
 fwrite(GRP,1,4,output);
 int k = 0;
 int moba_batch = moba_size/12;
 MobaEx = new int[moba_batch*4];
 for(int i=8; i<moba_size; i+=12)
 {
 MobaEx[k++] = MOBA[i];
 }

 int moba_size_grp = moba_batch*4+4;
 fwrite(&moba_size_grp,4,1,output);
 fwrite(&moba_batch,4,1,output);
 fwrite(MobaEx,4,k,output);
 delete [] MobaEx;

 //-------INDX------------------------------------
 //-------MOPY--------
 MoviEx = new uint16[nTriangles*3]; // "worst case" size...
 int *IndexRenum = new int[nVertices];
 memset(IndexRenum, 0xFF, nVertices*sizeof(int));
 for (int i=0; i<nTriangles; ++i)
 {
 // Skip no collision triangles
 if (MOPY[2*i]&WMO_MATERIAL_NO_COLLISION ||
 !(MOPY[2*i]&(WMO_MATERIAL_HINT|WMO_MATERIAL_COLLIDE_HIT)) )
 continue;
 // Use this triangle
 for (int j=0; j<3; ++j)
 {
 IndexRenum[MOVI[3*i + j]] = 1;
 MoviEx[3*nColTriangles + j] = MOVI[3*i + j];
 }
 ++nColTriangles;
 }

 // assign new vertex index numbers
 int nColVertices = 0;
 for (uint32 i=0; i<nVertices; ++i)
 {
 if (IndexRenum[i] == 1)
 {
 IndexRenum[i] = nColVertices;
 ++nColVertices;
 }
 }

 // translate triangle indices to new numbers
 for (int i=0; i<3*nColTriangles; ++i)
 {
 assert(MoviEx[i] < nVertices);
 MoviEx[i] = IndexRenum[MoviEx[i]];
 }

 // write triangle indices
 int INDX[] = {0x58444E49, nColTriangles*6+4, nColTriangles*3};
 fwrite(INDX,4,3,output);
 fwrite(MoviEx,2,nColTriangles*3,output);

 // write vertices
 int VERT[] = {0x54524556, nColVertices*3*static_cast<int>(sizeof(float))+4, nColVertices};// "VERT"
 int check = 3*nColVertices;
 fwrite(VERT,4,3,output);
 for (uint32 i=0; i<nVertices; ++i)
 if(IndexRenum[i] >= 0)
 check -= fwrite(MOVT+3*i, sizeof(float), 3, output);

 assert(check==0);

 delete [] MoviEx;
 delete [] IndexRenum;
 }

 //------LIQU------------------------
 if (LiquEx_size != 0)
 {
 int LIQU_h[] = {0x5551494C, static_cast<int>(sizeof(WMOLiquidHeader) + LiquEx_size) + hlq->xtiles*hlq->ytiles};// "LIQU"
 fwrite(LIQU_h, 4, 2, output);

 // according to WoW.Dev Wiki:
 uint32 liquidEntry;
 if (rootWMO->liquidType & 4)
 liquidEntry = liquidType;
 else if (liquidType == 15)
 liquidEntry = 0;
 else
 liquidEntry = liquidType + 1;

 if (!liquidEntry)
 {
 int v1; // [email protected]
 int v2; // [email protected]

 v1 = hlq->xtiles * hlq->ytiles;
 v2 = 0;
 if (v1 > 0)
 {
 while ((LiquBytes[v2] & 0xF) == 15)
 {
 ++v2;
 if (v2 >= v1)
 break;
 }

 if (v2 < v1 && (LiquBytes[v2] & 0xF) != 15)
 liquidEntry = (LiquBytes[v2] & 0xF) + 1;
 }
 }

 if (liquidEntry && liquidEntry < 21)
 {
 switch ((liquidEntry - 1) & 3)
 {
 case 0:
 liquidEntry = ((mogpFlags & 0x80000) != 0) + 13;
 break;
 case 1:
 liquidEntry = 14;
 break;
 case 2:
 liquidEntry = 19;
 break;
 case 3:
 liquidEntry = 20;
 break;
 }
 }

 hlq->type = liquidEntry;

 /* std::ofstream llog("Buildings/liquid.log", ios_base::out | ios_base::app);
 llog << filename;
 llog << ":\nliquidEntry: " << liquidEntry << " type: " << hlq->type << " (root:" << rootWMO->liquidType << " group:" << liquidType << ")\n";
 llog.close(); */

 fwrite(hlq, sizeof(WMOLiquidHeader), 1, output);
 // only need height values, the other values are unknown anyway
 for (uint32 i = 0; i<LiquEx_size/sizeof(WMOLiquidVert); ++i)
 fwrite(&LiquEx[i].height, sizeof(float), 1, output);
 // todo: compress to bit field
 fwrite(LiquBytes, 1, hlq->xtiles*hlq->ytiles, output);
 }

 return nColTriangles;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WMOGroup::open

(

)

{
 MPQFile f(CascStorage, filename.c_str());
 if(f.isEof ())
 {
 printf("No such file.\n");
 return false;
 }
 uint32 size;
 char fourcc[5];
 while (!f.isEof())
 {
 f.read(fourcc,4);
 f.read(&size, 4);
 flipcc(fourcc);
 if (!strcmp(fourcc,"MOGP"))//Fix sizeoff = Data size.
 {
 size = 68;
 }
 fourcc[4] = 0;
 size_t nextpos = f.getPos() + size;
 LiquEx_size = 0;
 liquflags = 0;

 if (!strcmp(fourcc,"MOGP"))//header
 {
 f.read(&groupName, 4);
 f.read(&descGroupName, 4);
 f.read(&mogpFlags, 4);
 f.read(bbcorn1, 12);
 f.read(bbcorn2, 12);
 f.read(&moprIdx, 2);
 f.read(&moprNItems, 2);
 f.read(&nBatchA, 2);
 f.read(&nBatchB, 2);
 f.read(&nBatchC, 4);
 f.read(&fogIdx, 4);
 f.read(&liquidType, 4);
 f.read(&groupWMOID,4);

 }
 else if (!strcmp(fourcc,"MOPY"))
 {
 MOPY = new char[size];
 mopy_size = size;
 nTriangles = (int)size / 2;
 f.read(MOPY, size);
 }
 else if (!strcmp(fourcc,"MOVI"))
 {
 MOVI = new uint16[size/2];
 f.read(MOVI, size);
 }
 else if (!strcmp(fourcc,"MOVT"))
 {
 MOVT = new float[size/4];
 f.read(MOVT, size);
 nVertices = (int)size / 12;
 }
 else if (!strcmp(fourcc,"MONR"))
 {
 }
 else if (!strcmp(fourcc,"MOTV"))
 {
 }
 else if (!strcmp(fourcc,"MOBA"))
 {
 MOBA = new uint16[size/2];
 moba_size = size/2;
 f.read(MOBA, size);
 }
 else if (!strcmp(fourcc,"MLIQ"))
 {
 liquflags |= 1;
 hlq = new WMOLiquidHeader();
 f.read(hlq, 0x1E);
 LiquEx_size = sizeof(WMOLiquidVert) * hlq->xverts * hlq->yverts;
 LiquEx = new WMOLiquidVert[hlq->xverts * hlq->yverts];
 f.read(LiquEx, LiquEx_size);
 int nLiquBytes = hlq->xtiles * hlq->ytiles;
 LiquBytes = new char[nLiquBytes];
 f.read(LiquBytes, nLiquBytes);

 /* std::ofstream llog("Buildings/liquid.log", ios_base::out | ios_base::app);
 llog << filename;
 llog << "\nbbox: " << bbcorn1[0] << ", " << bbcorn1[1] << ", " << bbcorn1[2] << " | " << bbcorn2[0] << ", " << bbcorn2[1] << ", " << bbcorn2[2];
 llog << "\nlpos: " << hlq->pos_x << ", " << hlq->pos_y << ", " << hlq->pos_z;
 llog << "\nx-/yvert: " << hlq->xverts << "/" << hlq->yverts << " size: " << size << " expected size: " << 30 + hlq->xverts*hlq->yverts*8 + hlq->xtiles*hlq->ytiles << std::endl;
 llog.close(); */
 }
 f.seek((int)nextpos);
 }
 f.close();
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

float WMOGroup::bbcorn1[3]

float WMOGroup::bbcorn2[3]

int WMOGroup::descGroupName

std::string WMOGroup::filename

private

uint32 WMOGroup::fogIdx

int WMOGroup::groupName

uint32 WMOGroup::groupWMOID

WMOLiquidHeader* WMOGroup::hlq

char* WMOGroup::LiquBytes

WMOLiquidVert* WMOGroup::LiquEx

int WMOGroup::LiquEx_size

uint32 WMOGroup::liquflags

uint32 WMOGroup::liquidType

uint16* WMOGroup::MOBA

int WMOGroup::moba_size

int* WMOGroup::MobaEx

int WMOGroup::mogpFlags

uint16 WMOGroup::moprIdx

uint16 WMOGroup::moprNItems

char* WMOGroup::MOPY

int WMOGroup::mopy_size

uint16* WMOGroup::MOVI

uint16* WMOGroup::MoviEx

float* WMOGroup::MOVT

uint16 WMOGroup::nBatchA

uint16 WMOGroup::nBatchB

uint32 WMOGroup::nBatchC

int WMOGroup::nTriangles

unsigned int WMOGroup::nVertices

---

The documentation for this class was generated from the following files:

• src/tools/vmap4_extractor/wmo.h
• src/tools/vmap4_extractor/wmo.cpp