contrib/vmap_extractor_v2/vmapextract/wmo.cpp

   1 #define __STORMLIB_SELF__
   2
   3 #include "wmo.h"
   4 #include "Stormlib.h"
   5 #include "mpq.h"
   6
   7 using namespace std;
   8
   9 WMORoot::WMORoot(std::string &filename) : filename(filename)
  10 {
  11 }
  12
  13 bool WMORoot::open()
  14 {
  15     MPQFile f(filename.c_str());
  16     if(f.isEof ())
  17     {
  18         printf("No such file.\n");
  19         return false;
  20     }
  21
  22     size_t size;
  23     char fourcc[5];
  24     bbcorn1[3] = 0;
  25     bbcorn2[3]= 0;
  26
  27     while (!f.isEof())
  28     {
  29         f.read(fourcc,4);
  30         f.read(&size, 4);
  31
  32         flipcc(fourcc);
  33         fourcc[4] = 0;
  34
  35         size_t nextpos = f.getPos() + size;
  36
  37         if (!strcmp(fourcc,"MOHD"))//header
  38         {
  39             f.read(&nTextures, 4);
  40             f.read(&nGroups, 4);
  41             f.read(&nP, 4);
  42             f.read(&nLights, 4);
  43             f.read(&nModels, 4);
  44             f.read(&nDoodads, 4);
  45             f.read(&nDoodadSets, 4);
  46             f.read(&col, 4);
  47             f.read(&RootID, 4);
  48             f.read(bbcorn1,12);
  49             f.read(bbcorn2,12);
  50             break;
  51         }
  52         /*
  53         else if (!strcmp(fourcc,"MOTX"))
  54         {
  55         }
  56         else if (!strcmp(fourcc,"MOMT"))
  57         {
  58         }
  59         else if (!strcmp(fourcc,"MOGN"))
  60         {
  61         }
  62         else if (!strcmp(fourcc,"MOGI"))
  63         {
  64         }
  65         else if (!strcmp(fourcc,"MOLT"))
  66         {
  67         }
  68         else if (!strcmp(fourcc,"MODN"))
  69         {
  70         }
  71         else if (!strcmp(fourcc,"MODS"))
  72         {
  73         }
  74         else if (!strcmp(fourcc,"MODD"))
  75         {
  76         }
  77         else if (!strcmp(fourcc,"MOSB"))
  78         {
  79         }
  80         else if (!strcmp(fourcc,"MOPV"))
  81         {
  82         }
  83         else if (!strcmp(fourcc,"MOPT"))
  84         {
  85         }
  86         else if (!strcmp(fourcc,"MOPR"))
  87         {
  88         }
  89         else if (!strcmp(fourcc,"MFOG"))
  90         {
  91         }
  92         */
  93         f.seek((int)nextpos);
  94     }
  95     f.close ();
  96     return true;
  97 }
  98
  99 bool WMORoot::ConvertToVMAPRootWmo(FILE *pOutfile)
 100 {
 101     //printf("Convert RootWmo...\n");
 102
 103     fwrite("VMAP002",1,8,pOutfile);
 104     unsigned int nVectors = 0;
 105     fwrite(&nVectors,sizeof(nVectors),1,pOutfile); // will be filled later
 106     fwrite(&nGroups,4,1,pOutfile);
 107     return true;
 108 }
 109
 110 WMORoot::~WMORoot()
 111 {
 112 }
 113
 114 WMOGroup::WMOGroup(std::string &filename) : filename(filename)
 115 {
 116 }
 117
 118 bool WMOGroup::open()
 119 {
 120     MPQFile f(filename.c_str());
 121     if(f.isEof ())
 122     {
 123         printf("No such file.\n");
 124         return false;
 125     }
 126     size_t size;
 127     char fourcc[5];
 128     bbcorn1[3] = 0;
 129     bbcorn2[3] = 0;
 130     while (!f.isEof())
 131     {
 132         f.read(fourcc,4);
 133         f.read(&size, 4);
 134         flipcc(fourcc);
 135         if (!strcmp(fourcc,"MOGP"))//Fix sizeoff = Data size.
 136         {
 137             size = 68;
 138         }
 139         fourcc[4] = 0;
 140         size_t nextpos = f.getPos() + size;
 141         LiquEx_size = 0;
 142         liquflags = 0;
 143
 144         if (!strcmp(fourcc,"MOGP"))//header
 145         {
 146             f.seekRelative(-4);
 147             f.read(&offsize, 4);
 148             f.read(&flag, 4);
 149             f.read(&flag1, 4);
 150             f.read(&Xid, 4);
 151             f.read(bbcorn1, 12);
 152             f.read(bbcorn2, 12);
 153             f.read(&Xid2, 4);
 154             f.read(&Xid3, 4);
 155             f.read(&zero1, 4);
 156             f.read(&Xflag, 4);
 157             f.read(&nTexture,4);
 158             f.read(&GroupID,4);
 159         }
 160         else if (!strcmp(fourcc,"MOPY"))
 161         {
 162             MOPY = new char[size];
 163             mopy_size = size;
 164             nTriangles = (int)size / 2;
 165             f.read(MOPY, size);
 166         }
 167         else if (!strcmp(fourcc,"MOVI"))
 168         {
 169             MOVI = new uint16[size/2];
 170             f.read(MOVI, size);
 171         }
 172         else if (!strcmp(fourcc,"MOVT"))
 173         {
 174             MOVT = new float[size/4];
 175             f.read(MOVT, size);
 176             nVertices = (int)size / 12;
 177         }
 178         else if (!strcmp(fourcc,"MONR"))
 179         {
 180         }
 181         else if (!strcmp(fourcc,"MOTV"))
 182         {
 183         }
 184         else if (!strcmp(fourcc,"MOBA"))
 185         {
 186             MOBA = new uint16[size/2];
 187             moba_size = size/2;
 188             f.read(MOBA, size);
 189         }
 190         else if (!strcmp(fourcc,"MLIQ"))
 191         {
 192             liquflags |= 1;
 193             WMOLiquidHeader hlq;
 194             f.read(&hlq, 0x1E);
 195             float ydir = -1.0f;
 196             hlq_xverts = hlq.xverts;
 197             hlq_yverts = hlq.yverts;
 198             int noVer = hlq.xverts * hlq.yverts;
 199             float tilesize  = CHUNKSIZE / 8.0f;
 200             LiquEx_size = sizeof(float) * 3 * noVer;
 201             LiquEx = new float[sizeof(float) * 3 * noVer];
 202             int p = 0;
 203
 204             for (int j=0; j<hlq.yverts; ++j)
 205             {
 206                 for (int i=0; i<hlq.xverts; ++i)
 207                 {
 208                     LiquEx[p++] = hlq.pos_x + tilesize * i;
 209                     LiquEx[p++] = hlq.pos_z;
 210                     LiquEx[p++] = ydir * (hlq.pos_y + tilesize * j);
 211                 }
 212             }
 213         }
 214         f.seek((int)nextpos);
 215     }
 216     f.close();
 217     return true;
 218 }
 219
 220 int WMOGroup::ConvertToVMAPGroupWmo(FILE *output, bool pPreciseVectorData)
 221 {
 222     if(pPreciseVectorData)
 223     {
 224         fwrite(&liquflags,sizeof(uint32),1,output);
 225         char GRP[] = "GRP ";
 226         fwrite(GRP,1,4,output);
 227
 228         int k = 0;
 229         int moba_batch = moba_size/12;
 230         MobaEx = new int[moba_batch*4];
 231         for(int i=8; i<moba_size; i+=12)
 232         {
 233             MobaEx[k++] = MOBA[i];
 234         }
 235         delete [] MOBA;
 236         int moba_size_grp = moba_batch*4+4;
 237         fwrite(&moba_size_grp,4,1,output);
 238         fwrite(&moba_batch,4,1,output);
 239         fwrite(MobaEx,4,k,output);
 240         delete [] MobaEx;
 241
 242         uint32 nIdexes = nTriangles * 3;
 243
 244         if(fwrite("INDX",4, 1, output) != 1)
 245         {
 246             printf("Error while writing file nbraches ID");
 247             exit(0);
 248         }
 249         int wsize = sizeof(uint32) + sizeof(unsigned short) * nIdexes;
 250         if(fwrite(&wsize, sizeof(int), 1, output) != 1)
 251         {
 252             printf("Error while writing file wsize");
 253             // no need to exit?
 254         }
 255         if(fwrite(&nIdexes, sizeof(uint32), 1, output) != 1)
 256         {
 257             printf("Error while writing file nIndexes");
 258             exit(0);
 259         }
 260         if(nIdexes >0)
 261         {
 262             if(fwrite(MOVI, sizeof(unsigned short), nIdexes, output) != nIdexes)
 263             {
 264                 printf("Error while writing file indexarray");
 265                 exit(0);
 266             }
 267         }
 268
 269         if(fwrite("VERT",4, 1, output) != 1)
 270         {
 271             printf("Error while writing file nbraches ID");
 272             exit(0);
 273         }
 274         wsize = sizeof(int) + sizeof(float) * 3 * nVertices;
 275         if(fwrite(&wsize, sizeof(int), 1, output) != 1)
 276         {
 277             printf("Error while writing file wsize");
 278             // no need to exit?
 279         }
 280         if(fwrite(&nVertices, sizeof(int), 1, output) != 1)
 281         {
 282             printf("Error while writing file nVertices");
 283             exit(0);
 284         }
 285         if(nVertices >0)
 286         {
 287             if(fwrite(MOVT, sizeof(float)*3, nVertices, output) != nVertices)
 288             {
 289                 printf("Error while writing file vectors");
 290                 exit(0);
 291             }
 292         }
 293
 294         if(LiquEx_size != 0)
 295         {
 296             int LIQU_h[] = {0x5551494C,LiquEx_size+8,hlq_xverts,hlq_yverts};// "LIQU"
 297             fwrite(LIQU_h,4,4,output);
 298             fwrite(LiquEx,4,LiquEx_size/4,output);
 299             delete [] LiquEx;
 300         }
 301
 302         return nTriangles;
 303     }
 304     else
 305     {
 306         //printf("Convert GroupWmo...\n");
 307         //-------GRP -------------------------------------
 308         fwrite(&liquflags,sizeof(uint32),1,output);
 309         char GRP[] = "GRP ";
 310         fwrite(GRP,1,4,output);
 311         int k = 0;
 312         int moba_batch = moba_size/12;
 313         MobaEx = new int[moba_batch*4];
 314         for(int i=8; i<moba_size; i+=12)
 315         {
 316             MobaEx[k++] = MOBA[i];
 317         }
 318         delete [] MOBA;
 319         int moba_size_grp = moba_batch*4+4;
 320         fwrite(&moba_size_grp,4,1,output);
 321         fwrite(&moba_batch,4,1,output);
 322         fwrite(MobaEx,4,k,output);
 323         delete [] MobaEx;
 324
 325         //-------INDX------------------------------------
 326         //-------MOPY--------
 327         int n = 0;
 328         int j = 0;
 329         MopyEx = new char[mopy_size];
 330         IndexExTr = new int[mopy_size];
 331         for (int i=0; i<mopy_size; i+=2)
 332         {
 333             // Skip no collision triangles
 334             if ((int)MOPY[i]&WMO_MATERIAL_NO_COLLISION)
 335                 continue;
 336             // Use only this triangles
 337             if ((int)MOPY[i]&(WMO_MATERIAL_HINT|WMO_MATERIAL_COLLIDE_HIT))
 338             {
 339                 MopyEx[n] = MOPY[i];
 340                 MopyEx[(n+1)] = MOPY[(i+1)];
 341                 IndexExTr[j] = i/2;
 342                 j+=1;
 343                 n+=2;
 344             }
 345         }
 346         MopyEx_size = n;
 347         IndexExTr_size = j;
 348         delete [] MOPY;
 349         delete [] MopyEx;
 350
 351         //---------MOVI-----------
 352         MoviEx = new uint16[IndexExTr_size*3];
 353         int m = 0;
 354         for (int i=0; i<IndexExTr_size; ++i)
 355         {
 356             int n = 0;
 357             n = IndexExTr[i]*3;
 358             for (int x=0; x<3; ++x)
 359             {
 360                 MoviEx[m] = MOVI[n];
 361                 n++;
 362                 m++;
 363             }
 364         }
 365         delete [] MOVI;
 366
 367         MoviExSort = new uint16[IndexExTr_size*3];
 368         for(int y=0; y<IndexExTr_size*3; ++y)
 369         {
 370             MoviExSort[y]=MoviEx[y];
 371         }
 372
 373         uint16 hold;
 374         for (int pass = 1; pass < IndexExTr_size*3; ++pass)
 375         {
 376             for (int i=0; i < IndexExTr_size*3-1; ++i)
 377             {
 378                 if (MoviExSort[i] > MoviExSort[i+1])
 379                 {
 380                     hold = MoviExSort[i];
 381                     MoviExSort[i] = MoviExSort[i+1];
 382                     MoviExSort[i+1] = hold;
 383                 }
 384                 //double = 65535
 385                 else
 386                     if (MoviExSort[i] == MoviExSort[i+1])
 387                         MoviExSort[i+1] = 65535;
 388             }
 389         }
 390         // double delet
 391         uint16 s = 0;
 392         for (int i=0; i < IndexExTr_size*3; ++i)
 393         {
 394             if (MoviExSort[i]!=65535)
 395             {
 396                 MoviExSort[s] = MoviExSort[i];
 397                 s++;
 398             }
 399         }
 400         MovtExSort = new uint16[s];
 401         for (int i=0; i < s; ++i)
 402         {
 403             MovtExSort[i] = MoviExSort[i];
 404         }
 405
 406         for (int i=0; i < IndexExTr_size*3; ++i)
 407         {
 408             uint16 b = MoviEx[i];
 409             for (uint16 x = 0; x < s; ++x)
 410             {
 411                 if(MoviExSort[x] == b)
 412                 {
 413                     MoviEx[i] = x;
 414                     break;
 415                 }
 416             }
 417         }
 418         int INDX[] = {0x58444E49,IndexExTr_size*6+4,IndexExTr_size*3};
 419         fwrite(INDX,4,3,output);
 420         fwrite(MoviEx,2,IndexExTr_size*3,output);
 421
 422         delete [] MoviEx;
 423         delete [] MoviExSort;
 424         delete [] IndexExTr;
 425
 426         //----------VERT---------
 427         //-----MOVT----------
 428         int d = 0;
 429         MovtEx = new float[s*3];
 430         for (uint16 i=0; i<s; ++i)
 431         {
 432             int c=0;//!!!!data in MovtExSort[i] more uint16 in great group wmo files!!!!
 433             c = MovtExSort[i]*3;
 434             for (int y=0; y<3; ++y)
 435             {
 436                 MovtEx[d] = MOVT[c];
 437                 c++;
 438                 d++;
 439             }
 440         }
 441         int VERT[] = {0x54524556,d*4+4,d*4/12};// "VERT"
 442         fwrite(VERT,4,3,output);
 443         fwrite(MovtEx,4,d,output);
 444         //------LIQU------------------------
 445         if(LiquEx_size != 0)
 446         {
 447             int LIQU_h[] = {0x5551494C,LiquEx_size+8,hlq_xverts,hlq_yverts};// "LIQU"
 448             fwrite(LIQU_h,4,4,output);
 449             fwrite(LiquEx,4,LiquEx_size/4,output);
 450             delete [] LiquEx;
 451         }
 452
 453         delete [] MOVT;
 454         delete [] MovtEx;
 455         delete [] MovtExSort;
 456
 457         //---------------------------------------------
 458         return IndexExTr_size;
 459     }
 460 }
 461
 462 WMOGroup::~WMOGroup()
 463 {
 464 }
 465
 466 WMOInstance::WMOInstance(MPQFile &f,const char* WmoInstName,const char*MapName, FILE *pDirfile)
 467 {
 468     pos = Vec3D(0,0,0);
 469
 470     float ff[3];
 471     f.read(&id, 4);
 472     f.read(ff,12);
 473     pos = Vec3D(ff[0],ff[1],ff[2]);
 474     f.read(ff,12);
 475     rot = Vec3D(ff[0],ff[1],ff[2]);
 476     f.read(ff,12);
 477     pos2 = Vec3D(ff[0],ff[1],ff[2]);
 478     f.read(ff,12);
 479     pos3 = Vec3D(ff[0],ff[1],ff[2]);
 480     f.read(&d2,4);
 481     f.read(&d3,4);
 482
 483     doodadset = (d2 & 0xFFFF0000) >> 16;
 484
 485     int realx1 = (int) ((float) pos2.x / 533.333333f);
 486     int realy1 = (int) ((float) pos2.z / 533.333333f);
 487     int realx2 = (int) ((float) pos3.x / 533.333333f);
 488     int realy2 = (int) ((float) pos3.z / 533.333333f);
 489
 490     if(realx1 < 0)
 491     {
 492         realx1 +=20; realx2+=20;
 493     }
 494     if(realy1 < 0)
 495     {
 496         realy1 +=20; realy2+=20;
 497     } // hack to prevent neg. values
 498
 499     //-----------add_in _dir_file----------------
 500
 501     char tempname[512];
 502     //    const char dirname[] = "buildings\\dir";
 503
 504     sprintf(tempname, "buildings\\%s", WmoInstName);
 505     FILE *input;
 506     input = fopen(tempname, "r+b");
 507
 508     if(!input)
 509         return;
 510
 511     fseek(input, 8, SEEK_SET); // get the correct no of vertices
 512     int nVertices;
 513     fread(&nVertices, sizeof (int), 1, input);
 514     fclose(input);
 515
 516     if(nVertices == 0)
 517         return;
 518
 519     /*    FILE *dirfile;
 520     dirfile = fopen(dirname, "ab");
 521     if(!dirfile)
 522     {
 523     printf("Can't open dirfile!'%s'\n");
 524     return;
 525     }
 526     */
 527     float x,z;
 528     x = pos.x;
 529     z = pos.z;
 530     if(x==0 && z == 0)
 531     {
 532         x = 533.33333f*32;
 533         z = 533.33333f*32;
 534     }
 535
 536     fprintf(pDirfile,"%s/%s %f,%f,%f_%f,%f,%f 1.0 %d %d %d,%d %d\n",
 537         MapName,
 538         WmoInstName,
 539         (float) x, (float) pos.y, (float) z,
 540         (float) rot.x, (float) rot.y, (float) rot.z,
 541         nVertices,
 542         realx1, realy1,
 543         realx2, realy2
 544         );
 545
 546     // fclose(dirfile);
 547 }