mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2025-01-07 16:35:21 +00:00
286 lines
6.4 KiB
C++
286 lines
6.4 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 NL_PATAT_GRID_H
|
|
#define NL_PATAT_GRID_H
|
|
|
|
// Nel Misc
|
|
#include "nel/misc/types_nl.h"
|
|
#include "nel/misc/stream.h"
|
|
|
|
// Nel Ligo
|
|
#include "nel/ligo/primitive.h"
|
|
|
|
//
|
|
#include "move_grid.h"
|
|
|
|
// stl
|
|
#include <deque>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <set>
|
|
#include <string>
|
|
|
|
// resolution in meters
|
|
#define PatatGridResolution 1.0f
|
|
#define mmPatatGridResolution 1000
|
|
|
|
/**
|
|
* <Class description>
|
|
* \author Benjamin Legros
|
|
* \author Nevrax France
|
|
* \date 2002
|
|
*/
|
|
class CPatatGrid
|
|
{
|
|
public:
|
|
/// \name public Typedefs
|
|
//@{
|
|
|
|
/// The grid entry index
|
|
typedef uint16 TEntryIndex;
|
|
|
|
//@}
|
|
|
|
protected:
|
|
/// \name typedefs
|
|
//@{
|
|
|
|
/// The container of prim zone
|
|
typedef std::vector<NLLIGO::CPrimZone> TZoneVector;
|
|
|
|
/// The entry type
|
|
class CEntry
|
|
{
|
|
public:
|
|
CEntry() : EntryIndex(0), HashCode(0), NumSamples(0) {}
|
|
/// The entry index for this entry
|
|
TEntryIndex EntryIndex;
|
|
/// The entry hash code
|
|
uint32 HashCode;
|
|
/// The number of point in grid that point to this entry
|
|
uint32 NumSamples;
|
|
/// The zones for this
|
|
std::vector<uint32> Zones;
|
|
|
|
/// serial
|
|
void serial(NLMISC::IStream &f)
|
|
{
|
|
sint version = f.serialVersion(0);
|
|
f.serial(EntryIndex, HashCode, NumSamples);
|
|
f.serialCont(Zones);
|
|
}
|
|
};
|
|
|
|
/// The entry table type
|
|
typedef std::vector<CEntry> TEntryTable;
|
|
|
|
/// The entry map type to find entry quickly
|
|
typedef std::multimap<uint32, TEntryIndex> TEntryMap;
|
|
|
|
/// The map of zone name (to zone id)
|
|
typedef std::map<std::string, sint32> TZoneMap;
|
|
|
|
/// The move grid, used as grid
|
|
typedef CMoveGrid<TEntryIndex, 1024, mmPatatGridResolution> TGrid;
|
|
|
|
//@}
|
|
|
|
/// \name Attributes
|
|
//@{
|
|
|
|
/// Patats
|
|
TZoneVector _PrimZones;
|
|
|
|
/// Patat map
|
|
TZoneMap _ZoneMap;
|
|
|
|
/// The move grid
|
|
TGrid _SelectGrid;
|
|
|
|
/// The entry table
|
|
TEntryTable _EntryTable;
|
|
|
|
/// The flag table
|
|
std::vector<bool> _FlagTable;
|
|
|
|
/// The fast entry map
|
|
TEntryMap _EntryMap;
|
|
|
|
/// The free table entries
|
|
std::deque<TEntryIndex> _FreeEntries;
|
|
|
|
//@}
|
|
|
|
/// \name Class filtering
|
|
//@{
|
|
|
|
std::set<std::string> _PrimZoneFilters;
|
|
|
|
//@}
|
|
|
|
public:
|
|
|
|
/// Constructor
|
|
CPatatGrid();
|
|
|
|
/// Destructor
|
|
~CPatatGrid();
|
|
|
|
/// Init grid;
|
|
void init();
|
|
|
|
/// Use a prim file
|
|
void usePrim(const std::string &primFile, std::vector<uint32> &inFile);
|
|
|
|
/// Check if patat exists
|
|
bool exist(const std::string &name) const { return (_ZoneMap.find(name) != _ZoneMap.end()); }
|
|
|
|
/// Get entry index
|
|
sint32 getEntryIndex(const NLMISC::CVector &v)
|
|
{
|
|
_SelectGrid.select(v);
|
|
TGrid::CIterator it = _SelectGrid.begin();
|
|
sint32 index = (it != _SelectGrid.end()) ? (*it) : 0;
|
|
_SelectGrid.clearSelection();
|
|
return index;
|
|
}
|
|
|
|
/// Set entry index
|
|
void setEntryIndex(const NLMISC::CVector &v, sint32 entry)
|
|
{
|
|
_SelectGrid.select(v);
|
|
TGrid::CIterator it = _SelectGrid.begin();
|
|
if (it != _SelectGrid.end())
|
|
{
|
|
(*it) = (TEntryIndex)entry;
|
|
}
|
|
else
|
|
{
|
|
TEntryIndex idx = (TEntryIndex)entry;
|
|
_SelectGrid.insert(idx, v);
|
|
}
|
|
_SelectGrid.clearSelection();
|
|
}
|
|
|
|
/// Get zone id from its name
|
|
sint32 getZoneId(const std::string &name) const
|
|
{
|
|
TZoneMap::const_iterator it = _ZoneMap.find(name);
|
|
if (it == _ZoneMap.end())
|
|
{
|
|
nlwarning("Can't find Prim zone %s", name.c_str());
|
|
return 0;
|
|
}
|
|
return (*it).second;
|
|
}
|
|
|
|
/// Get zone name from its id
|
|
const std::string &getZoneName(uint32 id) const
|
|
{
|
|
std::string *ret;
|
|
if (_PrimZones[id].getPropertyByName("name", ret))
|
|
return *ret;
|
|
else
|
|
{
|
|
static std::string noName;
|
|
return noName;
|
|
}
|
|
}
|
|
|
|
/// Get zone differences between 2 entry
|
|
bool diff(TEntryIndex previous, TEntryIndex next, std::vector<uint32> &in, std::vector<uint32> &out);
|
|
|
|
/// Serial
|
|
void serial(NLMISC::IStream &f)
|
|
{
|
|
sint version = f.serialVersion(1);
|
|
|
|
f.serialCont(_PrimZones);
|
|
f.serialCont(_ZoneMap);
|
|
f.serial(_SelectGrid);
|
|
f.serialCont(_EntryTable);
|
|
f.serialCont(_FlagTable);
|
|
f.serialCont(_EntryMap);
|
|
f.serialCont(_FreeEntries);
|
|
|
|
if (version >= 1)
|
|
f.serialCont(_PrimZoneFilters);
|
|
}
|
|
|
|
/// Display
|
|
void displayInfo(NLMISC::CLog *log = NLMISC::InfoLog)
|
|
{
|
|
log->displayNL("Display PatatGrid PrimZones: %d zones", _PrimZones.size());
|
|
uint i, j;
|
|
for (i=0; i<_PrimZones.size(); ++i)
|
|
{
|
|
std::string name;
|
|
_PrimZones[i].getPropertyByName("name", name);
|
|
log->displayNL(" + %d: Name:%s Points:%d", i, name.c_str(), _PrimZones[i].VPoints.size());
|
|
}
|
|
|
|
log->displayNL("Display PatatGrid entries: %d entries", _EntryTable.size());
|
|
for (i=0; i<_EntryTable.size(); ++i)
|
|
{
|
|
log->displayNL(" + %d: EntryIndex:%d HashCode:%d NumSamples:%d", i, _EntryTable[i].EntryIndex, _EntryTable[i].HashCode, _EntryTable[i].NumSamples);
|
|
for (j=0; j<_EntryTable[i].Zones.size(); ++j)
|
|
log->displayNL(" + Zone %d", _EntryTable[i].Zones[j]);
|
|
}
|
|
|
|
log->displayNL("Display quick EntryMap: %d in map", _EntryMap.size());
|
|
TEntryMap::iterator ite;
|
|
for (ite=_EntryMap.begin(); ite!=_EntryMap.end(); ++ite)
|
|
log->displayNL(" + %d->%d", (*ite).first, (*ite).second);
|
|
|
|
log->displayNL("Display free Entries: %d free entries", _FreeEntries.size());
|
|
for (i=0; i<_FreeEntries.size(); ++i)
|
|
log->displayNL(" + %d", _FreeEntries[i]);
|
|
|
|
log->displayNL("End of PatatGrid info");
|
|
}
|
|
|
|
/// Add CPrimZone class filter
|
|
void addPrimZoneFilter(const std::string &filter)
|
|
{
|
|
_PrimZoneFilters.insert(filter);
|
|
}
|
|
|
|
/// Remove CPrimZone class filter
|
|
void removePrimZoneFilter(const std::string &filter)
|
|
{
|
|
_PrimZoneFilters.erase(filter);
|
|
}
|
|
|
|
/// Reset CPrimZone class filter
|
|
void resetPrimZoneFilter()
|
|
{
|
|
_PrimZoneFilters.clear();
|
|
}
|
|
|
|
protected:
|
|
|
|
/// read recursive primitive
|
|
void readPrimitive(NLLIGO::IPrimitive *primitive, std::vector<uint32> &inFile);
|
|
|
|
};
|
|
|
|
|
|
#endif // NL_PATAT_GRID_H
|
|
|
|
/* End of patat_grid.h */
|