nel/tools/ligo/unbuild_land/unbuild_land.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2019-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 //
  17 // This utility is intended to rescue a lost .land file from existing
  18 // runtime zones. It does not recover the heightmap.
  19 //
  20 // Author: Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
  21
  22 // #include "../../3d/zone_lib/zone_utility.h"
  23
  24 #include <iostream>
  25 #include <nel/misc/types_nl.h>
  26 #include <nel/misc/file.h>
  27 #include <nel/misc/o_xml.h>
  28 #include <nel/misc/common.h>
  29 #include <nel/misc/cmd_args.h>
  30 #include <nel/misc/bitmap.h>
  31 //#include <nel/3d/quad_tree.h>
  32 #include <nel/3d/zone.h>
  33 //#include <nel/3d/landscape.h>
  34 //#include <nel/3d/zone_smoother.h>
  35 //#include <nel/3d/zone_tgt_smoother.h>
  36 //#include <nel/3d/zone_corner_smoother.h>
  37 #include <nel/ligo/zone_region.h>
  38 #include <vector>
  39 #include <set>
  40
  41 using namespace NL3D;
  42 using namespace NLMISC;
  43 using namespace NLLIGO;
  44 using namespace std;
  45
  46 namespace /* anonymous */
  47 {
  48
  49 sint32 s_ZoneMinX, s_ZoneMinY, s_ZoneMaxX, s_ZoneMaxY;
  50 float s_CellSize = 160.0f;
  51
  52 bool s_Height = false;
  53
  54 std::string s_ZoneBricksDirIn; // UTF-8 path
  55 std::string s_ZoneRuntimeDirIn; // UTF-8 path
  56 std::string s_LandFileOut; // UTF-8 path
  57
  58 CZoneRegion s_Land;
  59
  60 bool saveLand()
  61 {
  62         try
  63         {
  64                 COFile fileOut;
  65                 if (fileOut.open(s_LandFileOut, false, true, false))
  66                 {
  67                         COXml xml;
  68                         nlverify(xml.init(&fileOut));
  69                         s_Land.serial(xml);
  70                 }
  71                 else
  72                 {
  73                         nlwarning("Can't open the land file for writing: %s", s_LandFileOut.c_str());
  74                         return false;
  75                 }
  76         }
  77         catch (const Exception &e)
  78         {
  79                 nlwarning("Error in writing land file: %s", e.what());
  80                 return true;
  81         }
  82         return true;
  83 }
  84
  85 bool getXYFromZoneName(sint32 &x, sint32 &y, const string &zoneName)
  86 {
  87         string xStr, yStr;
  88         uint32 i = 0;
  89         while (zoneName[i] != '_')
  90         {
  91                 yStr += zoneName[i];
  92                 ++i;
  93                 if (i == zoneName.size())
  94                         goto Fail;
  95         }
  96         if (!NLMISC::fromString(yStr, y))
  97                 goto Fail;
  98         y = -y;
  99         ++i;
 100         while (i < zoneName.size())
 101         {
 102                 xStr += zoneName[i];
 103                 ++i;
 104         }
 105         if (xStr.size() != 2)
 106                 goto Fail;
 107         xStr = NLMISC::toUpperAscii(xStr);
 108         x = ((xStr[0] - 'A') * 26 + (xStr[1] - 'A'));
 109         return true;
 110 Fail:
 111         x = -1;
 112         y = -1;
 113         return false;
 114 }
 115
 116 void centerVertices(std::vector<CVector> &vertices)
 117 {
 118         CVector avg = CVector(0.0f, 0.0f, 0.0f);
 119         for (ptrdiff_t i = 0; i < vertices.size(); ++i)
 120                 avg += vertices[i];
 121         avg /= (float)vertices.size();
 122         nldebug("Average: %f, %f", avg.x, avg.y);
 123         for (ptrdiff_t i = 0; i < vertices.size(); ++i)
 124                 vertices[i] -= avg;
 125 }
 126
 127 void offsetVertices(std::vector<CVector> &vertices, int x, int y)
 128 {
 129         CVector off = CVector((float)x * s_CellSize, (float)y * s_CellSize, 0.0f);
 130         for (ptrdiff_t i = 0; i < vertices.size(); ++i)
 131                 vertices[i] -= off;
 132 }
 133
 134 float ratePoints(const std::vector<CVector> &zone, const std::vector<CVector> &ref, float xx, float xy, float yx, float yy)
 135 {
 136         // Rudimentary distance rating of vertices (not very reliable, but good enough!)
 137
 138         float md = 0.f;
 139         // std::vector<CVector> refcpy = ref;
 140         std::vector<bool> usedref;
 141         usedref.resize(ref.size(), false);
 142         for (ptrdiff_t i = 0; i < zone.size(); ++i)
 143         {
 144                 if (ref.size())
 145                 {
 146                         int lowj = 0;
 147                         float lowv = (CVector(ref[0].x * xx + ref[0].y * xy, ref[0].x * yx + ref[0].y * yy, ref[0].z) - zone[i]).sqrnorm();
 148                         for (ptrdiff_t j = 1; j < ref.size(); ++j)
 149                         {
 150                                 float v = (CVector(ref[j].x * xx + ref[j].y * xy, ref[j].x * yx + ref[j].y * yy, ref[j].z) - zone[i]).sqrnorm();
 151                                 if (v < lowv)
 152                                 {
 153                                         lowj = j;
 154                                         lowv = v;
 155                                 }
 156                         }
 157                         md += sqrtf(lowv);
 158                         usedref[lowj] = true;
 159                         // keep it! - refcpy.erase(refcpy.begin() + lowj);
 160                 }
 161                 else
 162                 {
 163                         md += zone[i].norm();
 164                 }
 165         }
 166 #if 0
 167         md = 0.f;
 168         std::vector<bool> usedzone;
 169         usedzone.resize(zone.size(), false);
 170         for (ptrdiff_t j = 0; j < ref.size(); ++j)
 171         {
 172                 if (usedref[j])
 173                 {
 174                         if (zone.size())
 175                         {
 176                                 int lowi = 0;
 177                                 float lowv = (CVector2f(ref[j].x * xx + ref[j].y * xy, ref[j].x * yx + ref[j].y * yy) - zone[0]).sqrnorm();
 178                                 for (ptrdiff_t i = 1; i < zone.size(); ++i)
 179                                 {
 180                                         float v = (CVector2f(ref[j].x * xx + ref[j].y * xy, ref[j].x * yx + ref[j].y * yy) - zone[i]).sqrnorm();
 181                                         if (v < lowv)
 182                                         {
 183                                                 lowi = i;
 184                                                 lowv = v;
 185                                         }
 186                                 }
 187                                 md += lowv;
 188                                 usedzone[lowi] = true;
 189                         }
 190                         else
 191                         {
 192                                 md += ref[j].norm();
 193                         }
 194                 }
 195         }
 196         md = 0.f;
 197         int nc = 0;
 198         for (ptrdiff_t i = 0; i < zone.size(); ++i)
 199         {
 200                 if (usedzone[i])
 201                 {
 202                         if (ref.size())
 203                         {
 204                                 int lowj = 0;
 205                                 float lowv = (CVector2f(ref[0].x * xx + ref[0].y * xy, ref[0].x * yx + ref[0].y * yy) - zone[i]).sqrnorm();
 206                                 for (ptrdiff_t j = 1; j < ref.size(); ++j)
 207                                 {
 208                                         float v = (CVector2f(ref[j].x * xx + ref[j].y * xy, ref[j].x * yx + ref[j].y * yy) - zone[i]).sqrnorm();
 209                                         if (v < lowv)
 210                                         {
 211                                                 lowj = j;
 212                                                 lowv = v;
 213                                         }
 214                                 }
 215                                 md += sqrtf(lowv);
 216                                 usedref[lowj] = true;
 217                                 // keep it! - refcpy.erase(refcpy.begin() + lowj);
 218                         }
 219                         else
 220                         {
 221                                 md += zone[i].norm();
 222                         }
 223                 }
 224                 else
 225                 {
 226                         ++nc;
 227                         // md += 1.0f;
 228                         // md += 0.01;
 229                 }
 230         }
 231         for (ptrdiff_t j = 0; j < ref.size(); ++j)
 232         {
 233                 if (!usedref[j])
 234                 {
 235                         // md += 1.0f;
 236                         // md += 0.01;
 237                 }
 238         }
 239         if (nc * 8 > zone.size())
 240                 return md + 10000;
 241 #endif
 242         return md;
 243 }
 244
 245 void findBestBrick(std::string &brick, int &rotate, int &flip, float &es, std::vector<CVector> &zoneVertices, const std::map<std::string, std::vector<CVector>> &brickVertices)
 246 {
 247         float bestPoints = (float)(uint32)~0;
 248         for (std::map<std::string, std::vector<CVector>>::const_iterator it = brickVertices.begin(), end = brickVertices.end(); it != end; ++it)
 249         {
 250                 float rating;
 251                 rating = ratePoints(zoneVertices, it->second, 1.0, 0.0, 0.0, 1.0);
 252                 if (rating < bestPoints)
 253                 {
 254                         brick = it->first;
 255                         rotate = 0;
 256                         flip = 0;
 257                         bestPoints = rating;
 258                 }
 259                 rating = ratePoints(zoneVertices, it->second, 0.0, -1.0, 1.0, 0.0);
 260                 if (rating < bestPoints)
 261                 {
 262                         brick = it->first;
 263                         rotate = 1;
 264                         flip = 0;
 265                         bestPoints = rating;
 266                 }
 267                 rating = ratePoints(zoneVertices, it->second, -1.0, 0.0, 0.0, -1.0);
 268                 if (rating < bestPoints)
 269                 {
 270                         brick = it->first;
 271                         rotate = 2;
 272                         flip = 0;
 273                         bestPoints = rating;
 274                 }
 275                 rating = ratePoints(zoneVertices, it->second, 0.0, 1.0, -1.0, 0.0);
 276                 if (rating < bestPoints)
 277                 {
 278                         brick = it->first;
 279                         rotate = 3;
 280                         flip = 0;
 281                 }
 282                 rating = ratePoints(zoneVertices, it->second, -1.0, 0.0, 0.0, 1.0);
 283                 if (rating < bestPoints)
 284                 {
 285                         brick = it->first;
 286                         rotate = 0;
 287                         flip = 1;
 288                         bestPoints = rating;
 289                 }
 290                 rating = ratePoints(zoneVertices, it->second, 0.0, -1.0, -1.0, 0.0);
 291                 if (rating < bestPoints)
 292                 {
 293                         brick = it->first;
 294                         rotate = 1;
 295                         flip = 1;
 296                         bestPoints = rating;
 297                 }
 298                 rating = ratePoints(zoneVertices, it->second, 1.0, 0.0, 0.0, -1.0);
 299                 if (rating < bestPoints)
 300                 {
 301                         brick = it->first;
 302                         rotate = 2;
 303                         flip = 1;
 304                         bestPoints = rating;
 305                 }
 306                 rating = ratePoints(zoneVertices, it->second, 0.0, 1.0, 1.0, 0.0);
 307                 if (rating < bestPoints)
 308                 {
 309                         brick = it->first;
 310                         rotate = 3;
 311                         flip = 1;
 312                         bestPoints = rating;
 313                 }
 314         }
 315         es = bestPoints;
 316 }
 317
 318 bool unbuildLand()
 319 {
 320         s_Land.resize(s_ZoneMinX, s_ZoneMaxX, s_ZoneMinY, s_ZoneMaxY);
 321
 322         // float th = s_CellSize * 0.5f;
 323         float th = (s_CellSize * 0.5f) - (s_CellSize * 0.2f * 0.5f);
 324
 325         // Read in all the bricks
 326         std::vector<std::string> brickFiles;
 327         CPath::getPathContent(s_ZoneBricksDirIn, false, false, true, brickFiles);
 328         std::map<std::string, std::vector<CVector>> brickVertices;
 329         for (std::vector<std::string>::const_iterator it = brickFiles.begin(), end = brickFiles.end(); it != end; ++it)
 330         {
 331                 if (CFile::getExtension(*it) != "zone")
 332                         continue;
 333
 334                 if (NLMISC::startsWith(CFile::getFilename(*it), "converted-")) // Not a real ligo
 335                         continue;
 336
 337                 // if (NLMISC::startsWith(CFile::getFilename(*it), "foret-moor")) // Not useful for r2_forest
 338                 //      continue;
 339                 // if (NLMISC::startsWith(CFile::getFilename(*it), "goo-")) // Not useful for r2_forest
 340                 //      continue;
 341                 // if (NLMISC::endsWith(CFile::getFilenameWithoutExtension(*it), "_zc")) // Not useful for r2_forest
 342                 //      continue;
 343
 344                 nldebug("Load %s", CFile::getFilenameWithoutExtension(*it).c_str());
 345
 346                 CIFile zoneFile(*it);
 347                 CZone zone;
 348                 zone.serial(zoneFile);
 349                 zoneFile.close();
 350
 351                 // Retrieve patches and vertices
 352                 uint16 zoneId = zone.getZoneId();
 353                 std::vector<CPatchInfo> zonePatches;
 354                 std::vector<CBorderVertex> zoneBorderVertices;
 355                 zone.retrieve(zonePatches, zoneBorderVertices);
 356
 357                 brickVertices[CFile::getFilenameWithoutExtension(*it)] = std::vector<CVector>();
 358                 std::vector<CVector> &vec = brickVertices[CFile::getFilenameWithoutExtension(*it)];
 359                 CVector off = CVector(s_CellSize * 0.5f, s_CellSize * 0.5f, 0.0f);
 360                 for (ptrdiff_t i = 0; i < zonePatches.size(); ++i)
 361                 {
 362                         for (ptrdiff_t j = 0; j < 4; ++j)
 363                         {
 364                                 float rx = zonePatches[i].Patch.Vertices[j].x - off.x;
 365                                 float ry = zonePatches[i].Patch.Vertices[j].y - off.y;
 366                                 if (rx <= -th || rx >= th
 367                                         || ry <= -th || ry >= th)
 368                                         goto SkipA;
 369                         }
 370                         for (ptrdiff_t j = 0; j < 4; ++j)
 371                         {
 372                                 float rx = zonePatches[i].Patch.Vertices[j].x - off.x;
 373                                 float ry = zonePatches[i].Patch.Vertices[j].y - off.y;
 374                                 vec.push_back(CVector(rx, ry, s_Height ? zonePatches[i].Patch.Vertices[j].z : 0.0f));
 375                         }
 376                 SkipA:;
 377                 }
 378
 379                 // centerVertices(vec);
 380         }
 381
 382         std::vector<std::string> runtimeFiles;
 383         CPath::getPathContent(s_ZoneRuntimeDirIn, false, false, true, runtimeFiles);
 384         for (std::vector<std::string>::const_iterator it = runtimeFiles.begin(), end = runtimeFiles.end(); it != end; ++it)
 385         {
 386                 if (CFile::getExtension(*it) != "zonel")
 387                         continue;
 388
 389                 int x, y;
 390                 std::string zoneName = CFile::getFilenameWithoutExtension(*it);
 391                 if (!getXYFromZoneName(x, y, zoneName))
 392                 {
 393                         nlerrornoex("Bad zone name: %s", zoneName.c_str());
 394                         continue;
 395                 }
 396
 397                 CIFile zoneFile(*it);
 398                 CZone zone;
 399                 zone.serial(zoneFile);
 400                 zoneFile.close();
 401
 402                 // Retrieve patches and vertices
 403                 uint16 zoneId = zone.getZoneId();
 404                 std::vector<CPatchInfo> zonePatches;
 405                 std::vector<CBorderVertex> zoneBorderVertices;
 406                 zone.retrieve(zonePatches, zoneBorderVertices);
 407
 408                 std::vector<CVector> vec;
 409                 CVector off = CVector((float)x * s_CellSize, (float)y * s_CellSize, 0.0f) + CVector(s_CellSize * 0.5f, s_CellSize * 0.5f, 0.0f);
 410                 for (ptrdiff_t i = 0; i < zonePatches.size(); ++i)
 411                 {
 412                         for (ptrdiff_t j = 0; j < 4; ++j)
 413                         {
 414                                 float rx = zonePatches[i].Patch.Vertices[j].x - off.x;
 415                                 float ry = zonePatches[i].Patch.Vertices[j].y - off.y;
 416                                 if (rx <= -th || rx >= th
 417                                         || ry <= -th || ry >= th)
 418                                         goto SkipB;
 419                         }
 420                         for (ptrdiff_t j = 0; j < 4; ++j)
 421                         {
 422                                 float rx = zonePatches[i].Patch.Vertices[j].x - off.x;
 423                                 float ry = zonePatches[i].Patch.Vertices[j].y - off.y;
 424                                 vec.push_back(CVector(rx, ry, s_Height ? zonePatches[i].Patch.Vertices[j].z : 0.0f));
 425                         }
 426                 SkipB:;
 427                 }
 428
 429                 // offsetVertices(vec, x, y);
 430                 // centerVertices(vec);
 431
 432                 std::string brick;
 433                 int rotate;
 434                 int flip;
 435                 float es;
 436                 findBestBrick(brick, rotate, flip, es, vec, brickVertices);
 437
 438                 nlinfo("Zone: %s, brick: %s, rotate: %i; flip: %i, error score: %f", zoneName.c_str(), brick.c_str(), rotate, flip, es);
 439
 440                 s_Land.setName(x, y, brick);
 441                 s_Land.setRot(x, y, rotate);
 442                 s_Land.setFlip(x, y, flip);
 443         }
 444
 445         return saveLand();
 446 }
 447
 448 } /* anonymous namespace */
 449
 450 int main(int argc, char **argv)
 451 {
 452         NLMISC::CApplicationContext myApplicationContext;
 453
 454         NLMISC::CCmdArgs args;
 455
 456         args.addAdditionalArg("land", "Output ligo land file");
 457         args.addAdditionalArg("zonebricks", "Input zone bricks directory");
 458         args.addAdditionalArg("zoneruntime", "Input runtime zone directory");
 459         args.addAdditionalArg("zonemin", "Zone boundary");
 460         args.addAdditionalArg("zonemax", "Zone boundary");
 461         args.addArg("", "cellsize", "meters", "Zone cell size");
 462         args.addArg("", "height", "", "Take Z coordinate into account");
 463
 464         if (!args.parse(argc, argv))
 465         {
 466                 return EXIT_FAILURE;
 467         }
 468
 469         s_LandFileOut = args.getAdditionalArg("land")[0];
 470         s_ZoneBricksDirIn = args.getAdditionalArg("zonebricks")[0];
 471         s_ZoneRuntimeDirIn = args.getAdditionalArg("zoneruntime")[0];
 472
 473         sint32 zoneMinX, zoneMinY;
 474         sint32 zoneMaxX, zoneMaxY;
 475         if (!getXYFromZoneName(zoneMinX, zoneMinY, args.getAdditionalArg("zonemin")[0])
 476             || !getXYFromZoneName(zoneMaxX, zoneMaxY, args.getAdditionalArg("zonemax")[0]))
 477         {
 478                 goto Fail;
 479         }
 480         s_ZoneMinX = min(zoneMinX, zoneMaxX);
 481         s_ZoneMaxX = max(zoneMinX, zoneMaxX);
 482         s_ZoneMinY = min(zoneMinY, zoneMaxY);
 483         s_ZoneMaxY = max(zoneMinY, zoneMaxY);
 484
 485         s_Height = args.haveLongArg("height");
 486
 487         if (args.haveLongArg("cellsize"))
 488         {
 489                 if (!NLMISC::fromString(args.getLongArg("cellsize")[0], s_CellSize))
 490                         goto Fail;
 491         }
 492
 493         if (!unbuildLand())
 494                 return EXIT_FAILURE;
 495
 496         return EXIT_SUCCESS;
 497 Fail:
 498         args.displayHelp();
 499         return EXIT_FAILURE;
 500 }