ryzom/client/src/micro_life_manager.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   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
  18
  19 #include "stdpch.h"
  20 #include "micro_life_manager.h"
  21 #include "sheet_manager.h"
  22 #include "misc.h"
  23 #include "continent_manager.h"
  24 #include "user_entity.h"
  25 #include "weather.h"
  26 #include "water_map.h"
  27 //
  28 #include "client_sheets/flora_sheet.h"
  29 //
  30 #include "nel/misc/polygon.h"
  31 #include "nel/misc/bitmap.h"
  32 #include "nel/misc/file.h"
  33 #include "nel/misc/i_xml.h"
  34 #include "nel/misc/line.h"
  35 //
  36 #include "nel/ligo/primitive.h"
  37 //
  38 #include "nel/3d/u_landscape.h"
  39 #include "nel/3d/u_material.h"
  40 #include "nel/3d/u_driver.h"
  41 #include "nel/3d/u_scene.h"
  42 //
  43 #include "nel/misc/check_fpu.h"
  44
  45 using namespace std::rel_ops;
  46 using namespace NLMISC;
  47
  48 extern NLLIGO::CLigoConfig      LigoConfig;
  49 extern CContinentManager        ContinentMngr;
  50 extern NL3D::ULandscape         *Landscape;
  51 extern NL3D::UDriver            *Driver;
  52 extern NL3D::UScene                     *Scene;
  53 extern CUserEntity                      *Userentity;
  54 extern NL3D::UMaterial          GenericMat;
  55
  56 #if !FINAL_VERSION
  57         bool DisplayMicroLifeZones = false;
  58 #endif
  59
  60 #ifdef NL_DEBUG
  61         bool DisplayMicroLifeActiveTiles = false;
  62 #endif
  63
  64 H_AUTO_DECL(RZ_MicroLifeManager)
  65
  66
  67 // ********************************************************************************************
  68 CMicroLifeManager::CMicroLifeManager()
  69 {
  70         FPU_CHECKER
  71         H_AUTO_USE(RZ_MicroLifeManager)
  72         _CellSize = 0.f;
  73         _GridWidth = 0;
  74         _GridHeight = 0;
  75         _Noise.Abs  = 0.f;
  76         _Noise.Rand = 1.f;
  77 }
  78
  79 // ********************************************************************************************
  80 CMicroLifeManager &CMicroLifeManager::getInstance()
  81 {
  82         FPU_CHECKER
  83         H_AUTO_USE(RZ_MicroLifeManager)
  84         static CMicroLifeManager instance;
  85         return instance;
  86 }
  87
  88 // ********************************************************************************************
  89 void CMicroLifeManager::init(const NLMISC::CVector2f &minCorner, const NLMISC::CVector2f &maxCorner, float cellSize /* = 30.f*/)
  90 {
  91         FPU_CHECKER
  92         H_AUTO_USE(RZ_MicroLifeManager)
  93         release();
  94         if (!Landscape) return;
  95         Landscape->addTileCallback(this);
  96         if (cellSize == 0.f)
  97         {
  98                 nlwarning("Bad cell size");
  99                 return;
 100         }
 101         if (minCorner.x >= maxCorner.x)
 102         {
 103                 nlwarning("Corners not well ordered");
 104                 return;
 105         }
 106         _CellSize = cellSize;
 107         //
 108         NLMISC::CVector2f minCornerFinal = minCorner;
 109         NLMISC::CVector2f maxCornerFinal = maxCorner;
 110         if (minCornerFinal.x > maxCornerFinal.x) std::swap(minCornerFinal.x, maxCornerFinal.x);
 111         if (minCornerFinal.y > maxCornerFinal.y) std::swap(minCornerFinal.y, maxCornerFinal.y);
 112         //
 113         _GridWidth  = (uint) (floorf(maxCornerFinal.x - minCornerFinal.x) / cellSize);
 114         _GridHeight = (uint) (floorf(maxCornerFinal.y - minCornerFinal.y) / cellSize);
 115         _MinCorner = minCornerFinal;
 116         _Grid.resize(_GridWidth * _GridHeight, 0);
 117
 118         _Noise.Frequency = 10.1346541f / cellSize;
 119 }
 120
 121 ///////////////////
 122 // BUILD PROCESS //
 123 ///////////////////
 124
 125 // To quickly know if a tile is inside a zone of micro-life, we subdivide the world into a grid. Each grid cell
 126 // may be overlapped by [0, n] polygons of a micro-life zone. We don't want to store a full list for each cell of
 127 // the grid, because such lists are repeated several times (it would end up wasting too much space). What we just need to keep is
 128 // a set of possible polygon lists that can overlap a grid cell. Afterward, we just need a grid of index into
 129 // the list of possible polygon lists.
 130 // To do that : - we first store complete lists in each grid cells : this is done by several calls to drawPolyInBuildGrid
 131 //              - we search for redundant lists and store the result as index in the final grid. This is done in packBuildGrid
 132
 133
 134 // *********************************************************************************************************************************
 135 bool CMicroLifeManager::CGridOverlapPolyInfo::operator < (const CMicroLifeManager::CGridOverlapPolyInfo &other) const
 136 {
 137         FPU_CHECKER
 138         H_AUTO_USE(RZ_MicroLifeManager)
 139         if (PrimitiveIndex != other.PrimitiveIndex) return PrimitiveIndex < other.PrimitiveIndex;
 140         if (Sheet != other.Sheet) return Sheet < other.Sheet;
 141         if (IsExcludePoly != other.IsExcludePoly) return !other.IsExcludePoly; // want to test exclude polys first
 142         if (IsFullyCovered != other.IsFullyCovered) return other.IsFullyCovered;
 143         return Poly < other.Poly;
 144 }
 145
 146 // *********************************************************************************************************************************
 147 bool CMicroLifeManager::CGridOverlapPolyInfo::operator == (const CMicroLifeManager::CGridOverlapPolyInfo &other) const
 148 {
 149         FPU_CHECKER
 150         H_AUTO_USE(RZ_MicroLifeManager)
 151         return PrimitiveIndex == other.PrimitiveIndex &&
 152                    Sheet == other.Sheet &&
 153                    IsExcludePoly == other.IsExcludePoly &&
 154                    IsFullyCovered == other.IsFullyCovered &&
 155                    Poly == other.Poly;
 156 }
 157
 158 // *********************************************************************************************************************************
 159 bool CMicroLifeManager::CGridOverlapPolyInfoVector::operator < (const CMicroLifeManager::CGridOverlapPolyInfoVector &other) const
 160 {
 161         FPU_CHECKER
 162         H_AUTO_USE(RZ_MicroLifeManager)
 163         if (V.size() != other.V.size()) return V.size() < other.V.size();
 164         for(uint k = 0; k < V.size(); ++k)
 165         {
 166                 if (V[k] != other.V[k]) return V[k] < other.V[k];
 167         }
 168         return false;
 169 }
 170
 171 // *********************************************************************************************************************************
 172 bool CMicroLifeManager::CGridOverlapPolyInfoVector::operator == (const CMicroLifeManager::CGridOverlapPolyInfoVector &other) const
 173 {
 174         FPU_CHECKER
 175         H_AUTO_USE(RZ_MicroLifeManager)
 176         if (V.size() != other.V.size()) return false;
 177         return std::equal(V.begin(), V.end(), other.V.begin());
 178 }
 179
 180
 181 // ***************************************************************************************************************************
 182 void CMicroLifeManager::drawPolyInBuildGrid(const std::vector<NLLIGO::CPrimVector> &primPoly,
 183                                                                                         uint primitiveIndex,
 184                                                                                         CMicroLifeManager::TBuildGrid &buildGrid,
 185                                                                                         const CFloraSheet *sheet,
 186                                                                                         bool isExcludeTri)
 187 {
 188         FPU_CHECKER
 189         H_AUTO_USE(RZ_MicroLifeManager)
 190         NLMISC::CPolygon poly;
 191         poly.Vertices.resize(primPoly.size());
 192         std::copy(primPoly.begin(), primPoly.end(), poly.Vertices.begin());
 193         std::list<NLMISC::CPolygon> convexPolys;
 194         if (!poly.toConvexPolygons(convexPolys, NLMISC::CMatrix::Identity))
 195         {
 196                 nlwarning("Can't convert to convex polys");
 197                 return;
 198         }
 199         NLMISC::CPolygon2D poly2D;
 200         for(std::list<NLMISC::CPolygon>::iterator it = convexPolys.begin(); it != convexPolys.end(); ++it)
 201         {
 202                 poly2D.Vertices.resize(it->Vertices.size());
 203                 // convert poly in cell units
 204                 for(uint k = 0; k < it->Vertices.size(); ++k)
 205                 {
 206                         poly2D.Vertices[k].x = (it->Vertices[k].x - _MinCorner.x) / _CellSize;
 207                         poly2D.Vertices[k].y = (it->Vertices[k].y - _MinCorner.y) / _CellSize;
 208                         //nlinfo("poly2D.Vertices[k].x = %.1f, poly2D.Vertices[k].y = %.1f", poly2D.Vertices[k].x, poly2D.Vertices[k].y);
 209                 }
 210                 // rasterize poly
 211                 NLMISC::CPolygon2D::TRasterVect outerBorders;
 212                 NLMISC::CPolygon2D::TRasterVect innerBorders;
 213                 sint outerMinY;
 214                 sint innerMinY;
 215                 poly2D.computeOuterBorders(outerBorders, outerMinY);
 216                 poly2D.computeInnerBorders(innerBorders, innerMinY);
 217                 if (outerBorders.empty()) continue; // no contribution for that poly
 218                 CGridOverlapPolyInfo gti;
 219                 gti.IsExcludePoly = isExcludeTri;
 220                 gti.Sheet = sheet;
 221                 gti.Poly = *it;
 222                 gti.PrimitiveIndex = primitiveIndex;
 223                 sint maxY = std::min(outerMinY + (sint)outerBorders.size(), (sint)_GridHeight);
 224                 sint startY = std::max(0, outerMinY);
 225                 for (sint y = startY; y < maxY; ++y)
 226                 {
 227                         sint maxX = std::min(outerBorders[y - startY].second, (sint) (_GridWidth - 1));
 228                         for (sint x = std::max((sint) 0, outerBorders[y - startY].first); x <= maxX; ++x)
 229                         {
 230                                 nlassert(x >= 0);
 231                                 nlassert(y >= 0);
 232                                 nlassert(x < (sint) _GridWidth);
 233                                 nlassert(y < (sint) _GridHeight);
 234                                 gti.IsFullyCovered = false;
 235                                 // see if primitive covers entirely this grid cell
 236                                 if (y >= innerMinY && y < innerMinY + (sint) innerBorders.size())
 237                                 {
 238                                         if (x >= innerBorders[y - innerMinY].first && x <= innerBorders[y - innerMinY].second)
 239                                         {
 240                                                 gti.IsFullyCovered = true;
 241                                         }
 242                                 }
 243                                 buildGrid[x + y * _GridWidth].V.push_back(gti);
 244                         }
 245                 }
 246         }
 247 }
 248
 249 // predicate to remove a cell that is fully covered by an exclude poly
 250 class CCleanFullyCoveredGridCellPred
 251 {
 252 public:
 253         uint                      PrimitiveIndex;
 254 public:
 255         bool operator()(const CMicroLifeManager::CGridOverlapPolyInfo &info) const
 256         {
 257                 FPU_CHECKER
 258                 return info.PrimitiveIndex == PrimitiveIndex;
 259         }
 260 };
 261
 262
 263 // ***************************************************************************************************************************
 264 // pack the build grid so that each cell only contains index into a small set of poly list, instead of a full poly list
 265 // (a lot of cells share the same poly list)
 266 void CMicroLifeManager::packBuildGrid(TBuildGrid                                                                          &buildGrid,
 267                                                                           CMicroLifeManager::TPossibleOverlapingPolyLists &finalPossibleLists
 268                                                                      )
 269 {
 270         FPU_CHECKER
 271         H_AUTO_USE(RZ_MicroLifeManager)
 272         // the already possible lists
 273         std::set<CGridOverlapPolyInfoVector> possibleLists;
 274         // for each cell :  - remove all polys of the same zone if there's an exclude tri that covers the whole grid
 275         //                  - compute the set of possible lists
 276         for(uint k = 0; k < buildGrid.size(); ++k)
 277         {
 278                 CGridOverlapPolyInfoVector &gopiv = buildGrid[k];
 279                 bool restart = false;
 280                 do
 281                 {
 282                         restart = false;
 283                         for(std::vector<CGridOverlapPolyInfo>::iterator it = gopiv.V.begin(); it != gopiv.V.end(); ++it)
 284                         {
 285                                 if (it->IsExcludePoly && it->IsFullyCovered)
 286                                 {
 287                                         // remove everything about that primitive
 288                                         CCleanFullyCoveredGridCellPred pred;
 289                                         pred.PrimitiveIndex = it->PrimitiveIndex;
 290                                         gopiv.V.erase(std::remove_if(gopiv.V.begin(), gopiv.V.end(), pred), gopiv.V.end());
 291                                         restart = true; // must restart scan from start of list because iterator is now invalid
 292                                         break;
 293                                 }
 294                         }
 295                 }
 296                 while (restart);
 297                 // insert in possible lists
 298                 possibleLists.insert(gopiv);
 299         }
 300         // second pass : flatten the set of possible lists to build an index for each grid cell
 301         nlassert(possibleLists.size() <= 65536);
 302         TPossibleOverlapingPolyLists flatSet(possibleLists.size());
 303         std::copy(possibleLists.begin(), possibleLists.end(), flatSet.begin());
 304         _Grid.resize(buildGrid.size());
 305         for(uint k = 0; k < buildGrid.size(); ++k)
 306         {
 307                 TPossibleOverlapingPolyLists::const_iterator it = std::lower_bound(flatSet.begin(), flatSet.end(), buildGrid[k]);
 308                 nlassert(it != flatSet.end());
 309                 nlassert(*it == buildGrid[k]);
 310                 _Grid[k] = (uint16) (it - flatSet.begin());
 311         }
 312         finalPossibleLists.swap(flatSet);
 313 }
 314
 315 // ***************************************************************************************************************************
 316 // read a .primitive file and add its content to a build grid
 317 void CMicroLifeManager::addPrimitiveToBuildGrid(const std::string &fileName, uint &primitiveIndex, CMicroLifeManager::TBuildGrid &buildGrid)
 318 {
 319         FPU_CHECKER
 320         H_AUTO_USE(RZ_MicroLifeManager)
 321         // read the file into memory and parse to generate 'prims' data tree
 322         NLLIGO::CPrimitives prims;
 323         NLMISC::CIFile fileIn;
 324         std::string path = NLMISC::CPath::lookup(fileName, false, true);
 325         if (path.empty()) return;
 326         if (!fileIn.open (path))
 327         {
 328                 nlwarning("Can't open %s", path.c_str());
 329                 return;
 330         }
 331         // Xml stream
 332         NLMISC::CIXml xmlIn;
 333         xmlIn.init (fileIn);
 334         // Read it
 335         if (!prims.read(xmlIn.getRootNode(), path.c_str(), LigoConfig))
 336         {
 337                 nlwarning ("Error reading file %s", path.c_str());
 338                 return;
 339         }
 340         // get each son zone
 341         for(uint k = 0; k < prims.RootNode->getNumChildren(); ++k)
 342         {
 343                 NLLIGO::IPrimitive *child;
 344                 if (!(prims.RootNode->getChild(child, k) && child)) continue;
 345                 //
 346                 std::string className;
 347                 // make sure it is a 'micro_life' primitive
 348                 if (!child->getPropertyByName("class", className))
 349                 {
 350                         nlwarning("Can't get class for child %d of primitive %s", (int) k, path.c_str());
 351                         continue;
 352                 }
 353                 if (NLMISC::nlstricmp(className.c_str(), "micro_life") != 0) continue; // only deals with micro life
 354                 // read flora sheet in the primitive
 355                 std::string formName;
 356                 if (!child->getPropertyByName("form", formName))
 357                 {
 358                         nlwarning("Can't get form name for child %d of primitive %s", (int) k, path.c_str());
 359                         continue;
 360                 }
 361                 const CEntitySheet *sheet = SheetMngr.get(NLMISC::CSheetId(formName));
 362                 if (!sheet)
 363                 {
 364                         nlwarning("Can't get sheet %s", formName.c_str());
 365                         continue;
 366                 }
 367                 const CFloraSheet *floraSheet = dynamic_cast<const CFloraSheet *>(sheet);
 368                 if (!floraSheet)
 369                 {
 370                         nlwarning("Sheet %s has bad type. Flora sheet wanted", formName.c_str());
 371                         continue;
 372                 }
 373                 //
 374                 for(uint m = 0; m < child->getNumChildren(); ++m)
 375                 {
 376                         NLLIGO::IPrimitive *mlZone;
 377                         if (!(child->getChild(mlZone, m) && mlZone)) continue;
 378                         // make sure it is a 'micro_life_zone'
 379                         if (!mlZone->getPropertyByName("class", className))
 380                         {
 381                                 nlwarning("Can't get class for child %d of primitive %s", (int) m, path.c_str());
 382                                 continue;
 383                         }
 384                         if (NLMISC::nlstricmp("micro_life_zone", className) != 0) continue;
 385
 386                         NLLIGO::CPrimZone *zone = dynamic_cast<NLLIGO::CPrimZone *>(mlZone);
 387                         if (!zone)
 388                         {
 389                                 nlwarning("Child %d of primitive %s is not a zone", (int) k, path.c_str());
 390                                 continue;
 391                         }
 392                         drawPolyInBuildGrid(zone->VPoints, primitiveIndex, buildGrid, floraSheet, false);
 393                         // remove exlcusion zones
 394                         for(uint l = 0; l < zone->getNumChildren(); ++l)
 395                         {
 396                                 NLLIGO::IPrimitive *exclPrim;
 397                                 if (zone->getChild(exclPrim, l) && exclPrim)
 398                                 {
 399                                         if (!exclPrim->getPropertyByName("class", className))
 400                                         {
 401                                                 nlwarning("Can't get class of sub-zone %d for child %d of primitive %s", (int) l, (int) m, path.c_str());
 402                                                 continue;
 403                                         }
 404                                 }
 405                                 if (NLMISC::nlstricmp("micro_life_exclude_zone", className) == 0)
 406                                 {
 407                                         NLLIGO::CPrimZone *exclZone = dynamic_cast<NLLIGO::CPrimZone *>(exclPrim);
 408                                         if (!zone)
 409                                         {
 410                                                 nlwarning("Child %d of child %d of primitive %s is not a zone", (int) l, (int) m, path.c_str());
 411                                                 continue;
 412                                         }
 413                                         // draw exclude polygon
 414                                         drawPolyInBuildGrid(exclZone->VPoints, primitiveIndex, buildGrid, floraSheet, true);
 415                                 }
 416                         }
 417                         ++ primitiveIndex;
 418                 }
 419         }
 420 }
 421
 422 // ********************************************************************************************
 423 void CMicroLifeManager::build(const std::vector<std::string> &fileNames)
 424 {
 425         FPU_CHECKER
 426         H_AUTO_USE(RZ_MicroLifeManager)
 427         TBuildGrid buildGrid;
 428         buildGrid.resize(_Grid.size());
 429         uint currPrimitiveIndex = 0;
 430         for(uint l = 0; l < fileNames.size(); ++l)
 431         {
 432                 addPrimitiveToBuildGrid(fileNames[l], currPrimitiveIndex, buildGrid);
 433         }
 434         // build the final grid
 435         packBuildGrid(buildGrid, _PossibleOverlapPolyLists);
 436 }
 437
 438
 439 // ********************************************************************************************
 440 void CMicroLifeManager::release()
 441 {
 442         FPU_CHECKER
 443         H_AUTO_USE(RZ_MicroLifeManager)
 444         if (Landscape)
 445         {
 446                 if (Landscape->isTileCallback(this))
 447                 {
 448                         Landscape->removeTileCallback(this);
 449                 }
 450         }
 451         // release all registered fxs
 452         for(TTileIDToFX::iterator it = _ActiveFXs.begin(); it != _ActiveFXs.end(); ++it)
 453         {
 454                 CTimedFXManager::getInstance().remove(it->second);
 455         }
 456         _ActiveFXs.clear();
 457         NLMISC::contReset(_Grid);
 458         NLMISC::contReset(_PossibleOverlapPolyLists);
 459         #ifdef NL_DEBUG
 460                 _ActiveTiles.clear();
 461                 _ActiveTilesWithFX.clear();
 462         #endif
 463 }
 464
 465 // ********************************************************************************************
 466 void CMicroLifeManager::tileAdded(const NL3D::CTileAddedInfo &infos)
 467 {
 468         FPU_CHECKER
 469         H_AUTO_USE(RZ_MicroLifeManager)
 470         if (_CellSize == 0.f) return; // not initialized
 471         #ifdef NL_DEBUG
 472                 _ActiveTiles[infos.TileID] = infos;
 473         #endif
 474         // get coords in grid
 475         sint gridCoordX = (sint) floorf((infos.Center.x - _MinCorner.x) / _CellSize);
 476         if (gridCoordX < 0 || gridCoordX >= (sint) _GridWidth) return;
 477         sint gridCoordY = (sint) floorf((infos.Center.y - _MinCorner.y) / _CellSize);
 478         if (gridCoordY < 0 || gridCoordY >= (sint) _GridHeight) return;
 479         // get list of primitives over which the center of the tile is
 480         if( _PossibleOverlapPolyLists.empty() )
 481                 return; // AJM for when called during zone destructor
 482         const CGridOverlapPolyInfoVector &iv = _PossibleOverlapPolyLists[_Grid[gridCoordX + gridCoordY * _GridWidth]];
 483         if (iv.V.empty()) return;
 484         static std::vector<CTimedFX> fxToSpawn; // static for fast alloc
 485         fxToSpawn.clear();
 486         uint k = 0;
 487         do
 488         {
 489                 const CFloraSheet *fs = iv.V[k].Sheet;
 490                 if (!fs) continue;
 491                 if (fs->getNumPlantInfos() == 0) continue;
 492                 //
 493                 bool inside = false;
 494                 uint currPrimIndex = iv.V[k].PrimitiveIndex;
 495                 do
 496                 {
 497                         if (iv.V[k].IsExcludePoly)
 498                         {
 499                                 // test if center of tile is inside of the primitive
 500                                 if (iv.V[k].Poly.contains(NLMISC::CVector2f(infos.Center.x, infos.Center.y)))
 501                                 {
 502                                         inside = false;
 503                                         // jump to next primitive
 504                                         for(;;)
 505                                         {
 506                                                 if (k == iv.V.size()) break;
 507                                                 if (iv.V[k].PrimitiveIndex != currPrimIndex) break;
 508                                                 ++ k;
 509                                         }
 510                                         break;
 511                                 }
 512                         }
 513                         else
 514                         {
 515                                 if (iv.V[k].IsFullyCovered)
 516                                 {
 517                                         // the primitive covers the whole cell so we are inside
 518                                         inside = true;
 519                                 }
 520                                 else
 521                                 {
 522                                         // test is center of tile is inside
 523                                         if (iv.V[k].Poly.contains(NLMISC::CVector2f(infos.Center.x, infos.Center.y)))
 524                                         {
 525                                                 inside = true;
 526                                         }
 527                                 }
 528                         }
 529                         ++k;
 530                         if (k == iv.V.size()) break;
 531                 }
 532                 while(iv.V[k].PrimitiveIndex == currPrimIndex);
 533                 if (!inside) continue; // no inside this primitive, try the next
 534                 // Compute noise at center of the tile, and if it is over the micro-life threshold, then spawn a fx
 535                 // To avoid that each kind of primitive be created at the same time, add an abitrary bias to the position for each primitive type
 536                 float noise = computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.2564f * NLMISC::CVector::K);
 537                 if (noise > fs->MicroLifeThreshold)
 538                 {
 539                         // choose a category of plant/microlife to instanciate by computing some noise around
 540                         float mlCategory = computeUniformNoise(_Noise, infos.Center + (float) (k + 1) * _CellSize * 1.254f * NLMISC::CVector::J + 1.421f * NLMISC::CVector::I);
 541                         uint64 plantWeightedIndex = (uint64) ((double) mlCategory * fs->getPlantInfoTotalWeight());
 542                         const CPlantInfo *pi = fs->getPlantInfoFromWeightedIndex(plantWeightedIndex);
 543                         if (!pi) continue;
 544                         // get pointer on .plant from sheet
 545                         CEntitySheet *es = SheetMngr.get(NLMISC::CSheetId(pi->SheetName));
 546                         if (!es) continue;
 547                         if (es->Type != CEntitySheet::PLANT) continue;
 548                         CPlantSheet *fs = static_cast<CPlantSheet *>(es);
 549                         const CSeasonFXSheet &sfs = fs->getFXSheet(CurrSeason);
 550                         // if orientation is ok for that kind of plant
 551                         float cosMax = cosf(NLMISC::degToRad(sfs.AngleMin));
 552                         float cosMin = cosf(NLMISC::degToRad(sfs.AngleMax));
 553                         if (cosMax < cosMin) std::swap(cosMin, cosMax);
 554                         if (infos.Normal.z < cosMin) continue; // not valid
 555                         if (infos.Normal.z > cosMax) continue; // not valid
 556
 557                         CTimedFX newFX;
 558 #if !FINAL_VERSION
 559                                 // for debug display, tells that it was generated dynamically
 560                                 newFX.FromIG = false;
 561 #endif
 562                         // spawn a primitive on the quad
 563                         float weight[3];
 564                         // compute weight values by computing some noise values around
 565                         weight[0] = computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.415f * NLMISC::CVector::I);
 566                         weight[1] = computeUniformNoise(_Noise, infos.Center - (float) (currPrimIndex + 1) * _CellSize * 1.568f * NLMISC::CVector::I);
 567                         weight[2] = computeUniformNoise(_Noise, infos.Center - (float) (currPrimIndex + 1) * _CellSize * 1.512f * NLMISC::CVector::J);
 568                         bool tri =  computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.898f * NLMISC::CVector::I) > 0.5f; // choose a tri to use
 569                         // if by extraordinary...
 570                         if (weight[0] == 0.f && weight[1] == 0.f && weight[2] == 0.f)
 571                         {
 572                                 weight[0] = 1.f;
 573                         }
 574                         // normalize weights
 575                         float invTotalWeight = 1.f / (weight[0] + weight[1] + weight[2]);
 576                         // choose one of the tri to spawn fx (the 2 tri of the quad are not planar)
 577                         if (tri)
 578                         {
 579                                 newFX.SpawnPosition = invTotalWeight * (weight[0] * infos.Corners[0] + weight[1] * infos.Corners[1] + weight[2] * infos.Corners[2]);
 580                         }
 581                         else
 582                         {
 583                                 newFX.SpawnPosition = invTotalWeight * (weight[0] * infos.Corners[1] + weight[1] * infos.Corners[2] + weight[2] * infos.Corners[3]);
 584                         }
 585
 586
 587                         // see if the fx must be aligned on water
 588                         if (sfs.AlignOnWater)
 589                         {
 590                                 float height;
 591                                 bool splashEnabled;
 592                                 bool hasWater = ContinentMngr.cur()->WaterMap.getWaterHeight(NLMISC::CVector2f(newFX.SpawnPosition.x, newFX.SpawnPosition.y), height, splashEnabled);
 593                                 if (hasWater)
 594                                 {
 595                                         newFX.SpawnPosition.z = height;
 596                                 }
 597                         }
 598                         newFX.SpawnPosition.z += sfs.ZOffset;
 599
 600                         // fit K axis of model with the normal, by doing a rotation around K ^ Normal by an angle alpha
 601                         // whose cos(alpha) is K * Normal = Normal.Z
 602                         // K ^ Normal resolves to [-y x 0]
 603                         // if z is near from 1.f or -1.f then no rotation is performed (because [-y x 0] tends to 0 and can't be normalized)
 604                         CVector rotAxis; // rotation axis to match Z of model with normal
 605                         float   angle = 0.f; // angle of rotation to match Z of model with normal
 606                         // see if want rotation
 607                         if (!sfs.DontRotate)
 608                         {
 609                                 if (1.f - infos.Normal.z < 10e-4)
 610                                 {
 611                                         rotAxis = NLMISC::CVector::I; // any axis in the (x, y) plane will be ok
 612                                         angle = 0.f;
 613                                 }
 614                                 else if (infos.Normal.z + 1.f < 10e-4)
 615                                 {
 616                                         rotAxis = NLMISC::CVector::I; // any axis in the (x, y) plane will be ok
 617                                         angle = (float) NLMISC::Pi;
 618                                 }
 619                                 else
 620                                 {
 621                                         rotAxis.set(- infos.Normal.y, infos.Normal.x, 0.f);
 622                                         angle = acosf(infos.Normal.z);
 623                                 }
 624                         }
 625
 626                         float angleAroundNormal = 0.f;
 627                         // see if want rotation around normal
 628                         if (!sfs.DontRotateAroundLocalZ)
 629                         {
 630                                 // Once instance is positionned, rotate it around its normal for more variety
 631                                 angleAroundNormal = computeUniformNoise(_Noise, infos.Center + (float) (currPrimIndex + 1) * _CellSize * 1.1213f * NLMISC::CVector::K);
 632                         }
 633                         // build final rot
 634                         if (!sfs.DontRotate && !sfs.DontRotateAroundLocalZ)
 635                         {
 636                                 newFX.Rot = NLMISC::CQuat(infos.Normal, angleAroundNormal) * NLMISC::CQuat(rotAxis, angle);
 637                         }
 638                         else if (!sfs.DontRotate)
 639                         {
 640                                 newFX.Rot = NLMISC::CQuat(rotAxis, angle);
 641                         }
 642                         else if (!sfs.DontRotateAroundLocalZ)
 643                         {
 644                                 newFX.Rot = NLMISC::CQuat(NLMISC::CVector::K, angleAroundNormal);
 645                         }
 646                         else
 647                         {
 648                                 // no rotation at all
 649                                 newFX.Rot = NLMISC::CQuat::Identity;
 650                         }
 651
 652                         // deal with scale
 653                         if (!sfs.WantScaling)
 654                         {
 655                                 newFX.Scale.set(1.f, 1.f, 1.f);
 656                         }
 657                         else
 658                         {
 659                                 if (sfs.UniformScale)
 660                                 {
 661                                         float scaleBlend = computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 3.2371f * NLMISC::CVector::J);
 662                                         newFX.Scale = scaleBlend * sfs.ScaleMax + (1.f - scaleBlend) * sfs.ScaleMin;
 663                                 }
 664                                 else
 665                                 {
 666                                         // compute a different blend factor for each axis
 667                                         CVector scaleBlend(computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 3.2371f * NLMISC::CVector::J),
 668                                                                            computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 2.9784f * NLMISC::CVector::J),
 669                                                                            computeUniformNoise(_Noise, infos.Center + (float) currPrimIndex * _CellSize * 1.1782f * NLMISC::CVector::J));
 670                                         newFX.Scale.set(scaleBlend.x * sfs.ScaleMax.x + (1.f - scaleBlend.x) * sfs.ScaleMin.x,
 671                                                             scaleBlend.y * sfs.ScaleMax.y + (1.f - scaleBlend.y) * sfs.ScaleMin.y,
 672                                                                         scaleBlend.z * sfs.ScaleMax.z + (1.f - scaleBlend.z) * sfs.ScaleMin.z);
 673
 674                                 }
 675                         }
 676                         newFX.FXSheet = &sfs;
 677                         fxToSpawn.push_back(newFX);
 678                 }
 679         }
 680         while (k != iv.V.size());
 681         if (!fxToSpawn.empty())
 682         {
 683                 CTimedFXManager::TFXGroupHandle fxsHandle = CTimedFXManager::getInstance().     add(fxToSpawn, CurrSeason);
 684                 #ifdef NL_DEBUG
 685                                 // make sure that tile is not inserted twice
 686                         TTileIDToFX::iterator testIt = _ActiveFXs.find(infos.TileID);
 687                         nlassert(testIt == _ActiveFXs.end());
 688                 #endif
 689                 _ActiveFXs[infos.TileID] = fxsHandle;
 690                 #ifdef NL_DEBUG
 691                         _ActiveTilesWithFX[infos.TileID] = infos;
 692                 #endif
 693         }
 694 }
 695
 696 // ********************************************************************************************
 697 void CMicroLifeManager::tileRemoved(uint64 id)
 698 {
 699         FPU_CHECKER
 700         H_AUTO_USE(RZ_MicroLifeManager)
 701 #ifdef NL_DEBUG
 702                 CHashMap<uint64, NL3D::CTileAddedInfo>::iterator tileIt = _ActiveTiles.find(id);
 703                 if (tileIt != _ActiveTiles.end())
 704                 {
 705                         _ActiveTiles.erase(tileIt);
 706                 }
 707                 tileIt = _ActiveTilesWithFX.find(id);
 708                 if (tileIt != _ActiveTilesWithFX.end())
 709                 {
 710                         _ActiveTilesWithFX.erase(tileIt);
 711                 }
 712 #endif
 713         TTileIDToFX::iterator it = _ActiveFXs.find(id);
 714         if (it == _ActiveFXs.end()) return;
 715         // remove FX from the manager
 716         CTimedFXManager::getInstance().shutDown(it->second);
 717         _ActiveFXs.erase(it);
 718 }
 719
 720 static const NLMISC::CRGBA DebugCols[] =
 721 {
 722                 NLMISC::CRGBA(255, 32, 32),
 723                 NLMISC::CRGBA(32, 255, 32),
 724                 NLMISC::CRGBA(255, 255, 32),
 725                 NLMISC::CRGBA(32, 255, 255),
 726                 NLMISC::CRGBA(255, 32, 255),
 727                 NLMISC::CRGBA(255, 127, 32),
 728                 NLMISC::CRGBA(255, 255, 255)
 729 };
 730 static const uint NumDebugCols = sizeof(DebugCols) / sizeof(DebugCols[0]);
 731
 732 // ********************************************************************************************
 733 void CMicroLifeManager::dumpMLGrid(const std::string &filename)
 734 {
 735         FPU_CHECKER
 736         H_AUTO_USE(RZ_MicroLifeManager)
 737         if (_Grid.empty())
 738         {
 739                 nlwarning("Grid not built");
 740                 return;
 741         }
 742         NLMISC::CBitmap bm;
 743         bm.resize(_GridWidth, _GridHeight, NLMISC::CBitmap::RGBA);
 744         NLMISC::CRGBA *pix = (NLMISC::CRGBA *) bm.getPixels(0).getPtr();
 745         for(uint x = 0; x < _GridWidth; ++x)
 746         {
 747                 for(uint y = 0; y < _GridHeight; ++y)
 748                 {
 749                         if (_Grid[x + y *_GridWidth] == 0)
 750                         {
 751                                 pix[x + y * _GridWidth] = CRGBA(127, 127, 127);
 752                         }
 753                         else
 754                         {
 755                                 pix[x + y * _GridWidth] = DebugCols[_Grid[x + y *_GridWidth] % NumDebugCols];
 756                         }
 757                 }
 758         }
 759         NLMISC::COFile f;
 760         if (!f.open(filename))
 761         {
 762                 nlwarning("Can't open %s for writing", filename.c_str());
 763                 return;
 764         }
 765         bm.writeTGA(f, 24, true);
 766         f.close();
 767 }
 768
 769 // ********************************************************************************************
 770 void CMicroLifeManager::renderMLZones(const NLMISC::CVector2f &camPos, float maxDist /*=1000.f*/)
 771 {
 772         FPU_CHECKER
 773         H_AUTO_USE(RZ_MicroLifeManager)
 774         if (_Grid.empty()) return;
 775         // no fast at all version
 776         Driver->setViewMatrix(Scene->getCam().getMatrix().inverted());
 777         NL3D::CFrustum fr;
 778         Scene->getCam().getFrustum(fr.Left, fr.Right, fr.Bottom, fr.Top, fr.Near, fr.Far);
 779         fr.Perspective = true;
 780         Driver->setFrustum(fr);
 781         Driver->setModelMatrix(NLMISC::CMatrix::Identity);
 782         float userZ = UserEntity ? (float) UserEntity->pos().z : 0.f;
 783         for(uint k = 0; k < _PossibleOverlapPolyLists.size(); ++k)
 784         {
 785                 const CGridOverlapPolyInfoVector &currPolyList = _PossibleOverlapPolyLists[k];
 786                 for(uint l = 0; l < currPolyList.V.size(); ++l)
 787                 {
 788                         const std::vector<NLMISC::CVector2f> &verts = currPolyList.V[l].Poly.Vertices;
 789                         NLMISC::CLineColor line;
 790                         line.Color0 = DebugCols[currPolyList.V[l].PrimitiveIndex % NumDebugCols];
 791                         line.Color0.add(line.Color0, NLMISC::CRGBA(127, 127, 127));
 792                         line.Color1 = line.Color0;
 793                         for(uint m = 0; m < verts.size(); ++m)
 794                         {
 795                                 line.V0.set(verts[m].x, verts[m].y, userZ);
 796                                 line.V1.set(verts[(m + 1) % verts.size()].x, verts[(m + 1) % verts.size()].y, userZ);
 797                                 Driver->drawLine(line, GenericMat);
 798                                 line.V0.z = userZ + 5.f;
 799                                 line.V1.z = userZ + 5.f;
 800                                 Driver->drawLine(line, GenericMat);
 801                                 line.V0.set(verts[m].x, verts[m].y, userZ);
 802                                 line.V1.set(verts[m].x, verts[m].y, userZ + 5.f);
 803                                 Driver->drawLine(line, GenericMat);
 804                         }
 805                 }
 806         }
 807         for (uint x = 0; x < _GridWidth; ++x)
 808         {
 809                 for (uint y = 0; y < _GridHeight; ++y)
 810                 {
 811                         const CGridOverlapPolyInfoVector &currPolyList = _PossibleOverlapPolyLists[_Grid[x + _GridWidth * y]];
 812                         if (currPolyList.V.empty()) continue;
 813                         // see if cell not too far
 814                         NLMISC::CVector2f pos(x * _CellSize + _MinCorner.x, y * _CellSize + _MinCorner.y);
 815                         if ((camPos - pos).norm() > maxDist) continue; // too far, don't display
 816                         // display box for each primitive type
 817                         NLMISC::CVector cornerMin(pos.x, pos.y, userZ - 5.f);
 818                         NLMISC::CVector cornerMax(pos.x + _CellSize, pos.y + _CellSize, userZ + 5.f);
 819                         for(uint l = 0; l < currPolyList.V.size(); ++l)
 820                         {
 821                                 // add a bias each time to see when several primitives are overlapped
 822                                 NLMISC::CVector bias = (float) currPolyList.V[l].PrimitiveIndex * NLMISC::CVector(0.01f, 0.f, 0.1f);
 823                                 CRGBA col = DebugCols[currPolyList.V[l].PrimitiveIndex % NumDebugCols];
 824                                 if (!currPolyList.V[l].IsFullyCovered)
 825                                 {
 826                                         drawBox(cornerMin + bias,  cornerMax + bias, col);
 827                                 }
 828                                 else
 829                                 {
 830                                         col.R /= 2;
 831                                         col.G /= 2;
 832                                         col.B /= 2;
 833                                         drawBox(cornerMin + bias,  cornerMax + bias, col);
 834                                 }
 835                         }
 836                 }
 837         }
 838 }
 839
 840 #ifdef NL_DEBUG
 841         // ********************************************************************************************
 842         void CMicroLifeManager::renderActiveTiles()
 843         {
 844                 FPU_CHECKER
 845                 /*
 846                 Driver->setViewMatrix(Scene->getCam().getMatrix().inverted());
 847                 NL3D::CFrustum fr;
 848                 Scene->getCam().getFrustum(fr.Left, fr.Right, fr.Bottom, fr.Top, fr.Near, fr.Far);
 849                 fr.Perspective = true;
 850                 Driver->setFrustum(fr);
 851                 Driver->setModelMatrix(NLMISC::CMatrix::Identity);
 852                 NL3D::UDriver::TPolygonMode oldPolyMode = Driver->getPolygonMode();
 853                 Driver->setPolygonMode(NL3D::UDriver::Line);
 854                 NL3D::UMaterial mat = Driver->createMaterial();
 855                 mat->initUnlit();
 856                 mat->setDoubleSided(true);
 857                 mat->setColor(CRGBA::Green);
 858                 for(std::hash_map<uint64, NL3D::CTileAddedInfo>::iterator it = _ActiveTiles.begin(); it != _ActiveTiles.end(); ++it)
 859                 {
 860                         Driver->drawLine(NLMISC::CLine(it->second.Corners[0], it->second.Corners[1]), *mat);
 861                         Driver->drawLine(NLMISC::CLine(it->second.Corners[1], it->second.Corners[2]), *mat);
 862                         Driver->drawLine(NLMISC::CLine(it->second.Corners[2], it->second.Corners[3]), *mat);
 863                         Driver->drawLine(NLMISC::CLine(it->second.Corners[3], it->second.Corners[0]), *mat);
 864                 }
 865                 mat->setColor(CRGBA::Red);
 866                 for(std::hash_map<uint64, NL3D::CTileAddedInfo>::iterator it = _ActiveTilesWithFX.begin(); it != _ActiveTilesWithFX.end(); ++it)
 867                 {
 868                         Driver->drawLine(NLMISC::CLine(it->second.Corners[0], it->second.Corners[1]), *mat);
 869                         Driver->drawLine(NLMISC::CLine(it->second.Corners[1], it->second.Corners[2]), *mat);
 870                         Driver->drawLine(NLMISC::CLine(it->second.Corners[2], it->second.Corners[3]), *mat);
 871                         Driver->drawLine(NLMISC::CLine(it->second.Corners[3], it->second.Corners[0]), *mat);
 872                 }
 873                 Driver->deleteMaterial(mat);
 874                 Driver->setPolygonMode(oldPolyMode);
 875                 */
 876         }
 877 #endif
 878
 879 ////////////////////
 880 // DEBUG COMMANDS //
 881 ////////////////////
 882
 883 #ifdef NL_DEBUG
 884         // display micro-life active tiles
 885         NLMISC_COMMAND(showMLActiveTiles,"display micro-life active tiles", "<0 = off, 1 = on>")
 886         {
 887                 if (args.size() != 1) return false;
 888                 fromString(args[0], DisplayMicroLifeActiveTiles);
 889                 return true;
 890         }
 891 #endif
 892
 893 #if !FINAL_VERSION
 894         #include "continent_manager.h"
 895
 896         // ******************************************************************************************************************
 897         // display micro-life zone on screen
 898         NLMISC_COMMAND(showMLZones,"display micro-life zones", "<0 = off, 1 = on>")
 899         {
 900                 if (args.size() != 1) return false;
 901                 fromString(args[0], DisplayMicroLifeZones);
 902                 return true;
 903         }
 904
 905
 906         // ******************************************************************************************************************
 907         // dump micro-life zone in a tga file
 908         NLMISC_COMMAND(dumpMLZones,"display micro-life zones", "<filename>")
 909         {
 910                 if (args.size() != 1) return false;
 911                 CMicroLifeManager::getInstance().dumpMLGrid(args[0]);
 912                 return true;
 913         }
 914
 915
 916         // ******************************************************************************************************************
 917         // reload micro-life zones
 918         NLMISC_COMMAND(reloadMLZones, "reload micro-life zones", "")
 919         {
 920                 if (!args.empty()) return false;
 921                 ClientSheetsStrings.memoryUncompress();
 922                 // reload .flora
 923                 std::vector<std::string> exts;
 924                 exts.push_back("flora");
 925                 NLMISC::IProgressCallback progress;
 926                 SheetMngr.loadAllSheet(progress, true, false, true, true, &exts);
 927                 // reload .plant 5but keep at their current adress)
 928                 CSheetManager sheetManager;
 929                 exts[0] = "plant";
 930                 sheetManager.loadAllSheet(progress, true, false, false, true, &exts);
 931                 //
 932                 const CSheetManager::TEntitySheetMap &sm = SheetMngr.getSheets();
 933                 for(CSheetManager::TEntitySheetMap::const_iterator it = sm.begin(); it != sm.end(); ++it)
 934                 {
 935                         if (it->second.EntitySheet && it->second.EntitySheet->Type == CEntitySheet::PLANT)
 936                         {
 937                                 // find matching sheet in new sheetManager
 938                                 const CEntitySheet *other = sheetManager.get(it->first);
 939                                 if (other)
 940                                 {
 941                                         // replace data in place
 942                                         *(CPlantSheet *) it->second.EntitySheet = *(const CPlantSheet *) other;
 943                                 }
 944                         }
 945                 }
 946
 947                 //
 948                 ClientSheetsStrings.memoryCompress();
 949                 // reload prims
 950                 ContinentMngr.cur()->loadMicroLife();
 951                 if (Landscape) Landscape->invalidateAllTiles();
 952                 return true;
 953         }
 954 #endif
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997