ryzom/client/src/ig_callback.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20
  21
  22 #include "stdpch.h"
  23
  24
  25
  26 #include "nel/misc/path.h"
  27 #include "nel/misc/matrix.h"
  28 #include "nel/misc/vector.h"
  29 #include "nel/misc/vectord.h"
  30 #include "nel/misc/sheet_id.h"
  31
  32 #include "nel/pacs/u_primitive_block.h"
  33 #include "nel/pacs/u_move_container.h"
  34 #include "nel/pacs/u_move_primitive.h"
  35 #include "nel/pacs/u_global_position.h"
  36
  37 #include "nel/3d/u_scene.h"
  38 #include "nel/3d/u_instance.h"
  39
  40
  41 #include "ig_callback.h"
  42 #include "fix_season_data.h"
  43 #include "sheet_manager.h"
  44 #include "ig_enum.h"
  45 #include "weather.h"
  46 #include "pacs_client.h"
  47 // Client Sheets
  48 #include "client_sheets/plant_sheet.h"
  49 #include <memory>
  50
  51 #ifdef DEBUG_NEW
  52 #define new DEBUG_NEW
  53 #endif
  54
  55 #define RZ_PRIM_ZEXT_BLOCK_AVOIDANCE    2.0f
  56
  57
  58 H_AUTO_DECL(RZ_IGCallback)
  59
  60 ///===================================================================================
  61 CIGCallback::CIGCallback() : _MoveContainer(NULL)
  62 {
  63         H_AUTO_USE(RZ_IGCallback)
  64         //nlinfo("**** YOYO: CREATING IG CALLBACK: %x", this);
  65 }
  66
  67 ///===================================================================================
  68 CIGCallback::~CIGCallback()
  69 {
  70         //nlinfo("**** YOYO: DELETING IG CALLBACK: %x", this);
  71         H_AUTO_USE(RZ_IGCallback)
  72         deleteIGs();
  73 }
  74
  75 ///===================================================================================
  76 void CIGCallback::resetContainer()
  77 {
  78         H_AUTO_USE(RZ_IGCallback)
  79         if (!_MoveContainer) return;
  80         deleteIGs();
  81         _MoveContainer = NULL;
  82 }
  83
  84 ///===================================================================================
  85 void CIGCallback::setMoveContainer(NLPACS::UMoveContainer *mc)
  86 {
  87         H_AUTO_USE(RZ_IGCallback)
  88         nlassert(!_MoveContainer);
  89         _MoveContainer = mc;
  90 }
  91
  92 ///===================================================================================
  93 void CIGCallback::addIG(NL3D::UInstanceGroup *ig)
  94 {
  95         H_AUTO_USE(RZ_IGCallback)
  96         nlassert(_MoveContainer);
  97         CIGInstance *igi;
  98         try
  99         {
 100                 igi = new CIGInstance(ig, this);
 101                 _IGInstances.push_back(igi);
 102                 ig->setAddRemoveInstanceCallback(igi);
 103                 ig->setTransformNameCallback(igi);
 104                 ig->setIGAddBeginCallback(igi);
 105         }
 106         catch(...)
 107         {
 108                 delete igi;
 109                 throw;
 110         }
 111 }
 112
 113 ///===================================================================================
 114 void CIGCallback::addIGWithNumZC(NL3D::UInstanceGroup *ig, sint numZC)
 115 {
 116         H_AUTO_USE(RZ_IGCallback)
 117         // Check the ig is valid.
 118         if(ig == 0)
 119                 return;
 120
 121         nlassert(_MoveContainer);
 122         CIGInstance *igi;
 123         try
 124         {
 125                 igi = new CIGInstance(ig, this);
 126                 igi->numZC(numZC);
 127                 _IGInstances.push_back(igi);
 128                 ig->setAddRemoveInstanceCallback(igi);
 129                 ig->setTransformNameCallback(igi);
 130                 ig->setIGAddBeginCallback(igi);
 131         }
 132         catch(...)
 133         {
 134                 delete igi;
 135                 throw;
 136         }
 137 }
 138
 139
 140 ///===================================================================================
 141 void CIGCallback::addIGs(const std::vector<NL3D::UInstanceGroup *> &igs)
 142 {
 143         H_AUTO_USE(RZ_IGCallback)
 144         _IGInstances.reserve(_IGInstances.size() + igs.size());
 145         for(uint k = 0; k < igs.size(); ++k)
 146         {
 147                 addIG(igs[k]);
 148         }
 149 }
 150
 151 //-----------------------------------------------
 152 // addIGsWithNumZC :
 153 // Add a vector of instance groups with the num ZC associated.
 154 //-----------------------------------------------
 155 void CIGCallback::addIGsWithNumZC(std::vector<std::pair<NL3D::UInstanceGroup *, sint> > &igs)
 156 {
 157         H_AUTO_USE(RZ_IGCallback)
 158         _IGInstances.reserve(_IGInstances.size() + igs.size());
 159         for(uint k = 0; k < igs.size(); ++k)
 160         {
 161                 addIGWithNumZC(igs[k].first, igs[k].second);
 162         }
 163 }
 164
 165
 166 ///===================================================================================
 167 CIGCallback::CIGInstance::CIGInstance(NL3D::UInstanceGroup *ig, CIGCallback     *owner)
 168         : _Owner(owner), _IG(ig), _HasManagedFXs(false)
 169 {
 170         H_AUTO_USE(RZ_IGCallback)
 171         nlassert(owner);
 172         nlassert(ig);
 173 }
 174
 175 ///===================================================================================
 176 CIGCallback::CIGInstance::~CIGInstance()
 177 {
 178         H_AUTO_USE(RZ_IGCallback)
 179         releaseMovePrimitives();
 180         if (_HasManagedFXs)
 181         {
 182                 CTimedFXManager::getInstance().remove(_ManagedFXHandle);
 183         }
 184         if (_IG)
 185         {
 186                 _IG->setAddRemoveInstanceCallback(NULL);
 187                 _IG->setTransformNameCallback(NULL);
 188                 _IG->setIGAddBeginCallback(NULL);
 189         }
 190 }
 191
 192 ///===================================================================================
 193 void CIGCallback::CIGInstance::instanceGroupAdded()
 194 {
 195         H_AUTO_USE(RZ_IGCallback)
 196         // Check the pointer on the IG.
 197         nlassert(_IG);
 198         nlassert(_Owner);
 199
 200         // See what objects need collisions primitives
 201         if (!_MovePrimitives.empty()) return; // already added
 202         std::vector<NLPACS::UMovePrimitive *> addedPrims;
 203         uint numInstances = _IG->getNumInstance();
 204         for(uint k = 0; k < numInstances; ++k)
 205         {
 206                 TPacsPrimMap::iterator pbIt = PacsPrims.find(NLMISC::toLowerAscii(NLMISC::CFile::getFilenameWithoutExtension(_IG->getShapeName(k))));
 207                 if (pbIt != PacsPrims.end())
 208                 {
 209                         // compute orientation and position
 210                         NLMISC::CMatrix instanceMatrix;
 211                         _IG->getInstanceMatrix(k, instanceMatrix);
 212                         NLMISC::CVector pos;
 213                         float                   angle;
 214                         NLMISC::CVector scale = _IG->getInstanceScale(k);
 215                         NLPACS::UMoveContainer::getPACSCoordsFromMatrix(pos, angle, instanceMatrix);
 216                         // insert the matching primitive block
 217                         addedPrims.clear();
 218                         _Owner->_MoveContainer->addCollisionnablePrimitiveBlock(pbIt->second, 0, 1, &addedPrims, angle, pos, true, scale);
 219                         // Yoyo: For each primitive, increment its height, to avoid blocking bugs
 220                         for(uint i=0;i<addedPrims.size();i++)
 221                         {
 222                                 // do it only for obstacle, non trigerrable(?) prims
 223                                 if(addedPrims[i] && addedPrims[i]->getObstacle() && addedPrims[i]->getTriggerType()==NLPACS::UMovePrimitive::NotATrigger)
 224                                 {
 225                                         addedPrims[i]->setHeight(addedPrims[i]->getHeight() + RZ_PRIM_ZEXT_BLOCK_AVOIDANCE);
 226                                 }
 227                         }
 228                         // for future remove
 229                         _MovePrimitives.insert(_MovePrimitives.end(), addedPrims.begin(), addedPrims.end());
 230                 }
 231         }
 232         // update additionnal datas from sheets
 233         updateFromSheets();
 234         updateManagedFXs();
 235         // free mem for sheet pointers
 236         NLMISC::contReset(_EntitySheets);
 237         _Owner->notifyIGAdded(_IG);
 238 }
 239
 240 ///===================================================================================
 241 void CIGCallback::CIGInstance::instanceGroupRemoved()
 242 {
 243         H_AUTO_USE(RZ_IGCallback)
 244         // If this zone is a ZC.
 245         releaseMovePrimitives();
 246         if (_HasManagedFXs)
 247         {
 248                 CTimedFXManager::getInstance().remove(_ManagedFXHandle);
 249                 _HasManagedFXs = false;
 250         }
 251 }
 252
 253
 254 ///===================================================================================
 255 void CIGCallback::CIGInstance::releaseMovePrimitives()
 256 {
 257         H_AUTO_USE(RZ_IGCallback)
 258         nlassert(_Owner);
 259         // remove all primitives from the move container
 260         nlassert(_Owner->_MoveContainer);
 261         for(TMovePrimitiveVect::iterator it = _MovePrimitives.begin(); it != _MovePrimitives.end(); ++it)
 262         {
 263                 _Owner->_MoveContainer->removePrimitive(*it);
 264         }
 265         NLMISC::contReset(_MovePrimitives);
 266 }
 267
 268 ///===================================================================================
 269 void CIGCallback::deleteIGs()
 270 {
 271         H_AUTO_USE(RZ_IGCallback)
 272         for(TIGInstanceList::iterator it = _IGInstances.begin(); it != _IGInstances.end(); ++it)
 273         {
 274                 delete *it;
 275         }
 276         _IGInstances.clear();
 277 }
 278
 279 ///===================================================================================
 280 void CIGCallback::forceAddAll()
 281 {
 282         H_AUTO_USE(RZ_IGCallback)
 283         for(TIGInstanceList::iterator it = _IGInstances.begin(); it != _IGInstances.end(); ++it)
 284         {
 285                 (*it)->forceAdd();
 286         }
 287 }
 288
 289 ///===================================================================================
 290 void CIGCallback::CIGInstance::startAddingIG(uint numInstances)
 291 {
 292         H_AUTO_USE(RZ_IGCallback)
 293         // make room for sheets ptr
 294         _EntitySheets.resize(numInstances);
 295         std::fill(_EntitySheets.begin(), _EntitySheets.end(), (CEntitySheet *) NULL);
 296 }
 297
 298 ///===================================================================================
 299 void CIGCallback::CIGInstance::buildSheetVector()
 300 {
 301         H_AUTO_USE(RZ_IGCallback)
 302         uint numInstances = _IG->getNumInstance();
 303         _EntitySheets.resize(numInstances);
 304         for(uint k = 0; k < numInstances; ++k)
 305         {
 306                 _EntitySheets[k] = NULL;
 307                 const std::string &name = _IG->getInstanceName(k);
 308                 if (NLMISC::nlstricmp(NLMISC::CFile::getExtension(name), "plant") == 0)
 309                 {
 310                         NLMISC::CSheetId sheetId;
 311                         if (sheetId.buildSheetId(name))
 312                         {
 313                                 _EntitySheets[k] = SheetMngr.get(sheetId);
 314                         }
 315                 }
 316         }
 317 }
 318
 319 ///===================================================================================
 320 void CIGCallback::CIGInstance::eraseSheetVector()
 321 {
 322         H_AUTO_USE(RZ_IGCallback)
 323         NLMISC::contReset(_EntitySheets);
 324 }
 325
 326 ///===================================================================================
 327 std::string CIGCallback::CIGInstance::transformName(uint instanceIndex, const std::string &instanceName, const std::string &shapeName)
 328 {
 329         H_AUTO_USE(RZ_IGCallback)
 330         /** we look if there'is a matching form for this instance name
 331           * If this is the case we can choose the shape we want to instanciate
 332           */
 333
 334         string ext = NLMISC::CFile::getExtension(instanceName);
 335         if (NLMISC::nlstricmp(ext, "pacs_prim") == 0)
 336         {
 337                 return "";              // Don't instanciate pacs_prim
 338         }
 339         if (NLMISC::nlstricmp(ext, "plant") != 0)
 340         {
 341                 return shapeName; // if there's no attached sheet, use the shape name
 342         }
 343         // We cache the last id
 344         static std::string lastName;
 345         static CEntitySheet *lastSheet = NULL;
 346         CEntitySheet *sh;
 347         if (instanceName == lastName)
 348         {
 349                 sh = lastSheet;
 350         }
 351         else
 352         {
 353                 NLMISC::CSheetId sheetId;
 354                 if (sheetId.buildSheetId(instanceName))
 355                 {
 356                         sh = SheetMngr.get(sheetId);
 357                         lastSheet = sh;
 358                         lastName = instanceName;
 359                 }
 360                 else
 361                 {
 362                         return shapeName;
 363                 }
 364         }
 365         if (!sh) return shapeName;
 366         if (sh->type() == CEntitySheet::PLANT)
 367         {
 368                 // store sheet in the sheet list
 369                 _EntitySheets[instanceIndex] = sh;
 370                 return ((CPlantSheet *) sh)->getShapeName();
 371         }
 372         else
 373         {
 374                 return shapeName;
 375         }
 376 }
 377
 378 ///===================================================================================
 379 void CIGCallback::CIGInstance::updateFromSheets()
 380 {
 381         H_AUTO_USE(RZ_IGCallback)
 382         nlassert(_EntitySheets.size() == _IG->getNumInstance());
 383         // See for which objects distance should be overriden (object which use a .PLANT sheet)
 384         uint numInstances = (uint)_EntitySheets.size();
 385         for(uint k = 0; k < numInstances; ++k)
 386         {
 387                 if (_EntitySheets[k] && _EntitySheets[k]->Type == CEntitySheet::PLANT)
 388                 {
 389                         CPlantSheet *ps = NLMISC::safe_cast<CPlantSheet *>(_EntitySheets[k]);
 390                         if (ps->getMaxDist() != -1) _IG->setDistMax(k, ps->getMaxDist());
 391                         if (ps->getCoarseMeshDist() != -1) _IG->setCoarseMeshDist(k, ps->getCoarseMeshDist());
 392                 }
 393         }
 394 }
 395
 396 ///===================================================================================
 397 void CIGCallback::CIGInstance::shutDownFXs()
 398 {
 399         H_AUTO_USE(RZ_IGCallback)
 400         if (!_HasManagedFXs) return;
 401         CTimedFXManager::getInstance().shutDown(_ManagedFXHandle);
 402         _HasManagedFXs = false;
 403 }
 404
 405 ///===================================================================================
 406 void CIGCallback::CIGInstance::updateManagedFXs()
 407 {
 408         H_AUTO_USE(RZ_IGCallback)
 409         nlassert(_EntitySheets.size() == _IG->getNumInstance());
 410         // See for which objects distance should be overriden (object which use a .PLANT sheet)
 411         uint numInstances = (uint)_EntitySheets.size();
 412         // vector of fx that should be managed by the dedicated manager. static for malloc perf
 413         static std::vector<CTimedFX> timedFXs;
 414         timedFXs.clear();
 415         for(uint k = 0; k < numInstances; ++k)
 416         {
 417                 if (_EntitySheets[k] && _EntitySheets[k]->Type == CEntitySheet::PLANT)
 418                 {
 419                         CPlantSheet *ps = NLMISC::safe_cast<CPlantSheet *>(_EntitySheets[k]);
 420                         // check for managed fxs for the current season
 421                         if (CurrSeason < EGSPD::CSeason::Invalid)
 422                         {
 423                                 if (!ps->getFXSheet(CurrSeason).FXName.empty())
 424                                 {
 425                                         timedFXs.push_back(CTimedFX());
 426                                         timedFXs.back().SpawnPosition = _IG->getInstancePos(k);
 427                                         timedFXs.back().Rot = _IG->getInstanceRot(k);
 428                                         timedFXs.back().Scale = _IG->getInstanceScale(k);
 429                                         timedFXs.back().FXSheet = &ps->getFXSheet(CurrSeason);
 430                                 }
 431                         }
 432                 }
 433         }
 434         if (!timedFXs.empty())
 435         {
 436                 _ManagedFXHandle = CTimedFXManager::getInstance().add(timedFXs, CurrSeason);
 437                 _HasManagedFXs = true;
 438         }
 439 }
 440
 441
 442
 443 ///===================================================================================
 444 bool CIGCallback::enumIGs(IIGEnum *callback)
 445 {
 446         H_AUTO_USE(RZ_IGCallback)
 447         nlassert(callback);
 448         for(TIGInstanceList::iterator it = _IGInstances.begin(); it != _IGInstances.end(); ++it)
 449         {
 450                 if ((*it)->getIG() != NULL && (*it)->getIG() != (NL3D::UInstanceGroup *)-1)
 451                 {
 452                         bool res = callback->enumIG((*it)->getIG());
 453                         if (!res) return false;
 454                 }
 455         }
 456         return true;
 457 }
 458
 459 ///===================================================================================
 460 void CIGCallback::changeSeason()
 461 {
 462         H_AUTO_USE(RZ_IGCallback)
 463         // for now, this only update managed fxs so that they are displayed the same way on both clients
 464         for(TIGInstanceList::iterator it = _IGInstances.begin(); it != _IGInstances.end(); ++it)
 465         {
 466                 if ((*it)->getIG() != NULL && (*it)->getIG() != (NL3D::UInstanceGroup *)-1)
 467                 {
 468                         (*it)->buildSheetVector(); // the sheet vector is deleted after use, so need to rebuild it
 469                         (*it)->shutDownFXs();
 470                         (*it)->updateManagedFXs();
 471                         (*it)->eraseSheetVector();
 472                 }
 473         }
 474 }
 475
 476 ///===================================================================================
 477 ///===================================================================================
 478
 479
 480 void createInstancesFromMoveContainer(NL3D::UScene *scene, NLPACS::UMoveContainer *mc, std::vector<NL3D::UInstance> *instances /*=NULL*/)
 481 {
 482         H_AUTO_USE(RZ_IGCallback)
 483         nlassert(scene);
 484         nlassert(mc);
 485         mc->evalCollision(0.1f, 0);
 486         // get the primitives
 487         std::vector<const NLPACS::UMovePrimitive *> prims;
 488         mc->getPrimitives(prims);
 489         if (instances)
 490         {
 491                 instances->reserve(prims.size());
 492         }
 493         for(uint k = 0; k < prims.size(); ++k)
 494         {
 495                 NL3D::UInstance newInstance;
 496                 float angle = 0.f;
 497                 NLMISC::CVector scale;
 498                 switch(prims[k]->getPrimitiveType())
 499                 {
 500                         case NLPACS::UMovePrimitive::_2DOrientedBox:
 501                                 newInstance = scene->createInstance("unit_box.shape");
 502                                 angle = (float) prims[k]->getOrientation(prims[k]->getFirstWorldImageV());
 503                                 prims[k]->getSize(scale.x, scale.y);
 504                         break;
 505                         case NLPACS::UMovePrimitive::_2DOrientedCylinder:
 506                                 newInstance = scene->createInstance("unit_cylinder.shape");
 507                                 scale.x = scale.y = prims[k]->getRadius();
 508                         break;
 509                         default:
 510                                 nlwarning("createInstancesFromMoveContainer : unsupported type encountered");
 511                                 continue;
 512                         break;
 513                 }
 514                 if (!newInstance.empty())
 515                 {
 516                         scale.z = prims[k]->getHeight();
 517                         NLMISC::CVectorD worldPos = prims[k]->getFinalPosition(prims[k]->getFirstWorldImageV());
 518                         newInstance.setPos(NLMISC::CVector((float) worldPos.x, (float) worldPos.y, (float) worldPos.z));
 519                         newInstance.setScale(scale);
 520                         newInstance.setRotQuat(NLMISC::CQuat(NLMISC::CVector::K, angle));
 521                         if (instances)
 522                         {
 523                                 instances->push_back(newInstance);
 524                         }
 525                 }
 526                 else
 527                 {
 528                         nlwarning("createInstancesFromMoveContainer : couldn't create shape");
 529                 }
 530         }
 531 }
 532
 533