khanat-opennel-code/code/ryzom/client/src/timed_fx_manager.h

348 lines
12 KiB
C++

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef CL_TIMED_FX_MANAGER_H
#define CL_TIMED_FX_MANAGER_H
#include "nel/misc/vector.h"
#include "nel/misc/noise_value.h"
#include "game_share/season.h"
#include "time_client.h"
#include "fx_manager.h"
class CSeasonFXSheet;
namespace NL3D
{
class UParticleSystemInstance;
class UScene;
}
/** A fx that must be spawn at a given season and hour
* \author Nicolas Vizerie
* \author Nevrax France
* \date 2003
*/
class CTimedFX
{
public:
NLMISC::CVector SpawnPosition;
NLMISC::CQuat Rot;
NLMISC::CVector Scale;
const CSeasonFXSheet *FXSheet;
#if !FINAL_VERSION
bool FromIG; // true if the fx comes from an ig, or false if it was generated dynamically
#endif
public:
CTimedFX() : FXSheet(NULL), SpawnPosition(0.f, 0.f, 0.f)
{
#if !FINAL_VERSION
FromIG = true;
#endif
}
NLMISC::CMatrix getInstanceMatrix() const;
};
typedef std::vector<CTimedFX> TTimedFXGroup;
/** Manager to spawn fxs at a given season and hour.
* \author Nicolas Vizerie
* \author Nevrax France
* \date 2003
*/
class CTimedFXManager
{
private:
class CManagedFX;
struct CTimeStampedFX
{
CClientDate Date; // the date at which the FX must be added / removed
//sint32 DebugDay;
CManagedFX *FX; // managed FX
bool operator < (const CTimeStampedFX &rhs) const
{
if (Date == rhs.Date) return FX < rhs.FX;
else return Date < rhs.Date;
} // we want to deal with early dates sooner
bool operator == (const CTimeStampedFX &rhs) const { return Date == rhs.Date && FX == rhs.FX; }
CTimeStampedFX() : FX(NULL) {}
};
typedef std::set<CTimeStampedFX> TTimeStampedFXPtrSet;
struct CManagedFXGroup;
struct CCandidateFXListHead;
/** A managed FX. Unless it is flagged as 'always intanciated', or is in a group that is shutting down,
* such a fx can only be in one set : _FXToAdd if it is not currently instanciated (or is shutting down), and _FXToRemove if it is instanciated and is not being shut down.
* and will be removed in the future.
*/
class CManagedFX : public CTimedFX
{
public:
enum TState { Unknown = 0, Permanent, InAddList, InRemoveList };
#ifdef NL_DEBUG
CManagedFXGroup *OwnerGroup;
#endif
NL3D::UParticleSystemInstance Instance; // Pointer to the actual FX. NULL if failed to instanciate or if not instanciated
TState State;
TTimeStampedFXPtrSet::iterator SetHandle; // if the fx is in a list (see its state), then it is an iterator into that list (for removal)
//
CManagedFX **_PrevCandidateFX; // if the fx has asked to be instanciated, it is inserted in a list of candidate fxs. points the previous "Next" pointer
// even if the fx is currently instanciated, it remains in that list (those are the potnetially instanciated fxs)
CManagedFX *_NextCandidateFX; // next candidate FX
//
CManagedFX **_PrevInstanciatedFX; // link into instanciated fx list, prev (is also a candidate)
CManagedFX *_NextInstanciatedFX; // link into instanciated fx list, next
// Tmp for debug
#ifdef NL_DEBUG
uint32 Magic;
#endif
public:
// ctor
CManagedFX()
{
Instance = NULL;
State = Unknown;
#ifdef NL_DEBUG
OwnerGroup = NULL;
Magic = 0xbaadcafe;
#endif
_PrevCandidateFX = NULL;
_NextCandidateFX = NULL;
//
_PrevInstanciatedFX = NULL;
_NextInstanciatedFX = NULL;
}
// compute start hour of that fx for the given day
void computeStartHour(sint32 cycle, CClientDate &resultDate, float cycleLength, float dayLength, const NLMISC::CNoiseValue &nv) const;
// compute end hour of that fx for the given day
void computeEndHour(sint32 cycle, CClientDate &resultDate, float cycleLength, float dayLength, const NLMISC::CNoiseValue &nv) const;
// unlink from list of candidate fxs
void unlinkFromCandidateFXList();
// unlink from list of instanciated fx. NB : this doesn't remove the model!
void unlinkFromInstanciatedFXList();
/** Shutdown the fx
*/
void shutDown(NL3D::UScene *scene, CFXManager &fxManager);
private:
void computeHour(sint32 cycle, float bias, CClientDate &resultDate, float cycleLength, float dayLength, const NLMISC::CNoiseValue &nv, float minHour, float maxHour) const;
};
// A group of managed fx. We never resize these vectors after creation so we can keep pointers in them.
typedef std::vector<CManagedFX> TManagedFXGroup;
struct CManagedFXGroup
{
TManagedFXGroup Group;
#ifdef NL_DEBUG
EGSPD::CSeason::TSeason Season;
#endif
};
// a list of group of managed fxs.
typedef std::list<CManagedFXGroup> TManagedFXGroupList;
public:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//\name USER INTERFACE
//@{
// mode of display for debug
enum TDebugDisplayMode { NoText = 0, PSName, SpawnDate, DebugModeCount };
// handle to add/remove a group of managed fxs (see add() / remove())
typedef TManagedFXGroupList::iterator TFXGroupHandle;
// dtor
~CTimedFXManager();
/** Init the manager. Must be called before first use
* \param scene The scene from which instances are created
* \param startDate Date of init
* \param dayLength Length of a day, in hours
* \param noiseFrequency Frequency of noise used to compute pseudo random spwaning dates of fxs (depends on their spawn position and on the date)
* \param maxNumberOfFXInstance Max number of fx instances that are allowed to be instanciated at a given time. Nearest fx are instanciated first
* \param sortDistanceInterval precision with which fx are sorted in distance. For example, with 1meter precision, fx at 0.2 & 0.5 from the user are considered
* to be at the same distance
* \param maxDist Max dist at which fxs are sorted. For efficiency, it is important to keep maxDist / sortDistanceInterval
*/
void init(NL3D::UScene *scene,
const CClientDate &startDate,
float dayLength,
float noiseFrequency,
uint maxNumberOfFXInstances,
float sortDistanceInterval,
float maxDist
);
// Reset all manager content
void reset();
/** Register a set of fxs to be managed.
* A handle is returned to remove it later.
*/
TFXGroupHandle add(const std::vector<CTimedFX> &fxs, EGSPD::CSeason::TSeason season);
/** Remove a FX group that has previously been added
* All FX instances are deleted.
*/
void remove(TFXGroupHandle handle);
/** Delayed removal of a fx group that has previously been added.
* All FXs are shutdown by removing their emitters.
* This is useful to switch from one season to another.
*/
void shutDown(TFXGroupHandle handle);
// Update the manager state to match the new date. This add / removes FX as necessary
void update(const CClientDate &date, EGSPD::CSeason::TSeason currSeason, const NLMISC::CVector &camPos);
// Set a new date, but do not update current fx. The new hour will be taken in account during the next call to 'add'
void setDate(const CClientDate &date);
// get the current date
const CClientDate &getDate() const { return _CurrDate; }
// Access to the unique instance of this class
static CTimedFXManager &getInstance();
// for debug only
void dumpFXToAdd() const;
void dumpFXToRemove() const;
void dumpFXInfo() const;
// debug bbox and dates of FXs to remove and to add.
void displayFXBoxes(TDebugDisplayMode displayMode) const;
// set max number of fx to be instanciated at a time
void setMaxNumFXInstances(uint maxNumInstaces);
//@}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private:
// Set of fx to be instanciated in the future. It is managed as a priority queue (sorted by date of instanciation).
TTimeStampedFXPtrSet _FXToAdd;
// Set of fx to remove in the future, and that are currently instanciated (and are not shutting done). It is managed as a priority queue (sorted by date of removal).
TTimeStampedFXPtrSet _FXToRemove;
// List of the groups of FXs that are currenlty managed.
TManagedFXGroupList _FXGroups;
// The scene from which to add / remove instances
NL3D::UScene *_Scene;
// Current date of the manager
CClientDate _CurrDate;
// List of group that are shutting down (that is, shutDown(TFXGroupHandle handle) was called on that group)
std::list<TFXGroupHandle> _ShuttingDownGroups;
// Length of a day, in hours
float _DayLength;
// Noise function used to compute start/end date of fxs
NLMISC::CNoiseValue _Noise;
// Init
bool _InitDone;
//\name DISTANCE SORTING
//@{
// FX to be displayed can be limited in number -> the nearest fx are instanciated in priority
// To achieve this, we keep a list of candidate fx for each interval of distance (thus achieving linear approximate sorting)
typedef std::vector<CManagedFX *> TCandidateFXListSortedByDist;
TCandidateFXListSortedByDist _CandidateFXListSortedByDist; // roughly sorted list of candidate fx. Should be rebuilt completely when players moves (done in linear time)
TCandidateFXListSortedByDist _CandidateFXListSortedByDistTmp; // already allocated vect for fast resorting of list when player moves
// NB : this vector nevers grows
bool _CandidateFXListTouched; // the list of candidate has been modified, so the manager should see which fxs should be instanciated, and which fxs should be removed
float _SortDistance; // lenght of each distance interval, in meters
uint _MaxNumberOfFXInstances; // max number of instances that can be 'alive' at a time
//@}
// Linked list of currently instanciated FXs (nearest candidates)
CManagedFX *_InstanciatedFXs;
NLMISC::CVector _LastCamPos;
// fx manager to deals with shutting down fxs
CFXManager _FXManager;
private:
// ctor
CTimedFXManager();
// for debug
void checkIntegrity();
// setup user params for a fx
void setupUserParams(CManagedFX &fi, uint cycle);
// insert a fx in list of candidate for instanciation (also unlink from a previous list)
void linkCandidateFX(TCandidateFXListSortedByDist &targetList, float dist, CManagedFX *fx);
// link a fx into a list of instances (also unlink from a previous list)
void linkInstanciatedFX(CManagedFX *&listHead, CManagedFX *fx);
// update list of instanciated fxs (create / removes fxs as necessary)
void updateInstanciatedFXList();
// re-sort list of candidate fx by distance (this is necessary when player moves)
void updateCandidateFXListSorting();
public:
// convert a cycle and an hour to a date
static void cycleToDate(sint32 cycle, float hour, float cycleLength, float dayLength, CClientDate &result);
// give the matching cycle for a date
static sint32 dateToCycle(const CClientDate &date, float cycleLength, float dayLength);
};
#endif