mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-11-24 15:56:22 +00:00
596 lines
17 KiB
C++
596 lines
17 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_PRECIPITATION_CLIP_GRID_H
|
|
#define CL_PRECIPITATION_CLIP_GRID_H
|
|
|
|
#include "nel/3d/u_landscape.h"
|
|
#include "nel/3d/u_visual_collision_manager.h"
|
|
#include "nel/misc/traits_nl.h"
|
|
#include "nel/misc/polygon.h"
|
|
|
|
|
|
/*
|
|
|
|
// *********************************************************************************
|
|
template <class T> class CArray2D
|
|
{
|
|
public:
|
|
typedef typename std::vector<T> TArrayContainer;
|
|
typedef typename TArrayContainer::iterator iterator;
|
|
typedef typename TArrayContainer::const_iterator const_iterator;
|
|
CArray2D() : _Width(0), _Height(0) {}
|
|
void init(uint width, uint height);
|
|
void init(uint width, uint height, const T &defaultValue);
|
|
bool empty() const { return _Array.empty(); }
|
|
typename iterator begin() { return _Array.begin(); }
|
|
typename iterator end() { return _Array.end(); }
|
|
typename const_iterator begin() const { return _Array.begin(); }
|
|
typename const_iterator end() const { return _Array.end(); }
|
|
|
|
// access element by column/row
|
|
T &operator()(uint x, uint y)
|
|
{
|
|
#ifdef NL_DEBUG
|
|
nlassert(x < _Width);
|
|
nlassert(y < _Height);
|
|
#endif
|
|
return _Array[x + y * _Width];
|
|
}
|
|
// access element by column/row (const version)
|
|
const T &operator()(uint x, uint y) const
|
|
{
|
|
#ifdef NL_DEBUG
|
|
nlassert(x < _Width);
|
|
nlassert(y < _Height);
|
|
#endif
|
|
return _Array[x + y * _Width];
|
|
}
|
|
// Return width of array
|
|
uint getWidth() const { return _Width; }
|
|
// Return height of array
|
|
uint getHeight() const { return _Height; }
|
|
// Move array content of the given offset. No wrapping is applied
|
|
// Example : move(1, 0) will move the array of one column to the left. The latest column is lost. The first column remains unchanged
|
|
//
|
|
void move(sint offsetX, sint offsetY);
|
|
// Move a part of the array. Values are clamped as necessary
|
|
void moveSubArray(sint dstX, sint dstY, sint srcX, sint srcY, sint width, sint height);
|
|
// get an iterator to the start of a row
|
|
iterator beginRow(uint row)
|
|
{
|
|
nlassert(row < _Height);
|
|
return _Array.begin() + row * _Width;
|
|
}
|
|
const_iterator beginRow(uint row) const
|
|
{
|
|
nlassert(row < _Height);
|
|
return _Array.begin() + row * _Width;
|
|
}
|
|
iterator endRow(uint row)
|
|
{
|
|
nlassert(row < _Height);
|
|
return _Array.begin() + (row + 1) * _Width;
|
|
}
|
|
const_iterator endRow(uint row) const
|
|
{
|
|
nlassert(row < _Height);
|
|
return _Array.begin() + (row + 1) * _Width;
|
|
}
|
|
// get an iterator at the given position
|
|
iterator getIteratorAt(uint x, uint y)
|
|
{
|
|
#ifdef NL_DEBUG
|
|
nlassert(x < _Width);
|
|
nlassert(y < _Height);
|
|
#endif
|
|
return _Array.begin() + x + (y * _Width);
|
|
}
|
|
// Get a const iterator at the given position
|
|
const iterator getIteratorAt(uint x, uint y) const
|
|
{
|
|
#ifdef NL_DEBUG
|
|
nlassert(x < _Width);
|
|
nlassert(y < _Height);
|
|
#endif
|
|
return _Array.begin() + x + (y * _Width);
|
|
}
|
|
// See which part of array should be updated after its content has been displaced by the given offset (by a call to move for example).
|
|
// Example: getUpdateRects(0, 1, result) will result the first row as a result
|
|
//
|
|
void getUpdateRects(sint moveOffsetX, sint moveOffsetY, std::vector<CRect> &rectsToUpdate);
|
|
// See which parts of array will be discarded if the array is displaced by the given offset
|
|
void getDiscardRects(sint moveOffsetX, sint moveOffsetY, std::vector<CRect> &discardedRects);
|
|
private:
|
|
TArrayContainer _Array;
|
|
uint _Width;
|
|
uint _Height;
|
|
private:
|
|
inline void checkRect(const CRect &r) const
|
|
{
|
|
nlassert(r.X >= 0 && r.X < (sint32) _Width);
|
|
nlassert(r.Y >= 0 && r.Y < (sint32) _Height);
|
|
nlassert(r.X + r.Width >= 0 && r.X + (sint32) r.Width <= (sint32) _Width);
|
|
nlassert(r.Y + r.Height >= 0 && r.Y + (sint32) r.Height <= (sint32) _Height);
|
|
}
|
|
};
|
|
|
|
|
|
// *********************************************************************************
|
|
template <class T>
|
|
void CArray2D<T>::getUpdateRects(sint moveOffsetX, sint moveOffsetY, std::vector<CRect> &rectsToUpdate)
|
|
{
|
|
rectsToUpdate.clear();
|
|
if (moveOffsetX < 0) // moved right ?
|
|
{
|
|
// the width to update
|
|
uint width = std::min((uint) moveOffsetX, _Width);
|
|
// the grid moved top or bottom, exclude this part
|
|
sint height = _Height - abs(moveOffsetY);
|
|
if (height > 0)
|
|
{
|
|
nlwarning("*1");
|
|
// complete column on the right
|
|
rectsToUpdate.push_back(CRect((sint32) (_Width - width), (sint32) (std::max(- moveOffsetY, 0)), (uint32) width, (uint32) height));
|
|
#ifdef NL_DEBUG
|
|
checkRect(rectsToUpdate.back());
|
|
#endif
|
|
}
|
|
}
|
|
else if (moveOffsetX > 0) // moved left ?
|
|
{
|
|
// the width to update
|
|
uint width = std::min((uint) (- moveOffsetX), _Width);
|
|
// the grid moved top or bottom.
|
|
sint height = _Height - abs(moveOffsetY);
|
|
if (height > 0)
|
|
{
|
|
//nlwarning("*2");
|
|
// complete column on the right
|
|
rectsToUpdate.push_back(CRect(0, (sint32) std::max(- moveOffsetY, 0), (uint32) width, (uint32) height));
|
|
#ifdef NL_DEBUG
|
|
checkRect(rectsToUpdate.back());
|
|
#endif
|
|
}
|
|
}
|
|
// update top or bottom part
|
|
if (moveOffsetY < 0)
|
|
{
|
|
sint height = std::min((uint) moveOffsetY, _Height);
|
|
//nlwarning("*3");
|
|
rectsToUpdate.push_back(CRect(0, _Height - height, _Width, height));
|
|
#ifdef NL_DEBUG
|
|
checkRect(rectsToUpdate.back());
|
|
#endif
|
|
}
|
|
else
|
|
if (moveOffsetY > 0)
|
|
{
|
|
sint height = std::min((uint) (- moveOffsetY), _Height);
|
|
//nlwarning("*4");
|
|
rectsToUpdate.push_back(CRect(0, 0, _Width, height));
|
|
#ifdef NL_DEBUG
|
|
checkRect(rectsToUpdate.back());
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// *********************************************************************************
|
|
template <class T>
|
|
void CArray2D<T>::getDiscardRects(sint moveOffsetX, sint moveOffsetY,std::vector<CRect> &discardedRects)
|
|
{
|
|
getUpdateRects(- moveOffsetX, - moveOffsetY, discardedRects);
|
|
}
|
|
|
|
// *********************************************************************************
|
|
template <class T>
|
|
void CArray2D<T>::moveSubArray(sint dstX, sint dstY, sint srcX, sint srcY, sint width, sint height)
|
|
{
|
|
if (srcX >= (sint) getWidth()) return;
|
|
if (srcY >= (sint) getHeight()) return;
|
|
if (dstX >= (sint) getWidth()) return;
|
|
if (dstY >= (sint) getHeight()) return;
|
|
if (srcX < 0)
|
|
{
|
|
width += srcX;
|
|
if (width <= 0) return;
|
|
srcX = 0;
|
|
}
|
|
if (srcY < 0)
|
|
{
|
|
height += srcY;
|
|
if (height <= 0) return;
|
|
srcY = 0;
|
|
}
|
|
if (srcX + width > (sint) getWidth())
|
|
{
|
|
width = getWidth() - srcX;
|
|
}
|
|
if (srcY + height > (sint) getHeight())
|
|
{
|
|
height = getHeight() - srcY;
|
|
}
|
|
if (dstX < 0)
|
|
{
|
|
width += dstX;
|
|
if (width < 0) return;
|
|
srcX -= dstX;
|
|
dstX = 0;
|
|
}
|
|
if (dstY < 0)
|
|
{
|
|
height += dstY;
|
|
if (height < 0) return;
|
|
srcY -= dstY;
|
|
dstY = 0;
|
|
}
|
|
if (dstX + width > (sint) getWidth())
|
|
{
|
|
width = getWidth() - dstX;
|
|
}
|
|
if (dstY + height > (sint) getHeight())
|
|
{
|
|
height = getHeight() - dstY;
|
|
}
|
|
#ifdef NL_DEBUG
|
|
nlassert(width > 0);
|
|
nlassert(height > 0);
|
|
nlassert(srcX >= 0 && srcX < (sint) getWidth());
|
|
nlassert(srcY >= 0 && srcY < (sint) getHeight());
|
|
#endif
|
|
if (dstY < srcY)
|
|
{
|
|
const_iterator src = getIteratorAt(srcX, srcY);
|
|
iterator dst = getIteratorAt(dstX, dstY);
|
|
do
|
|
{
|
|
if (CTraits<T>::SupportRawCopy)
|
|
{
|
|
// type support fast copy
|
|
::memcpy(&(*dst), &(*src), sizeof(T) * width);
|
|
}
|
|
else
|
|
{
|
|
std::copy(src, src + width, dst);
|
|
}
|
|
src += _Width;
|
|
dst += _Width;
|
|
}
|
|
while(--height);
|
|
}
|
|
else if (dstY > srcY)
|
|
{
|
|
// copy from top to bottom
|
|
const_iterator src = getIteratorAt(srcX, srcY + height - 1);
|
|
iterator dst = getIteratorAt(dstX, dstY + height - 1);
|
|
do
|
|
{
|
|
if (CTraits<T>::SupportRawCopy)
|
|
{
|
|
// type support fast copy
|
|
::memcpy(&(*dst), &(*src), sizeof(T) * width);
|
|
}
|
|
else
|
|
{
|
|
std::copy(src, src + width, dst);
|
|
}
|
|
src -= _Width;
|
|
dst -= _Width;
|
|
}
|
|
while(--height);
|
|
}
|
|
else
|
|
{
|
|
const_iterator src = getIteratorAt(srcX, srcY);
|
|
iterator dst = getIteratorAt(dstX, dstY);
|
|
if (dstX < srcX)
|
|
{
|
|
do
|
|
{
|
|
if (CTraits<T>::SupportRawCopy)
|
|
{
|
|
// type support fast copy
|
|
::memmove(&(*dst), &(*src), sizeof(T) * width);
|
|
}
|
|
else
|
|
{
|
|
std::reverse_copy(src, src + width, dst);
|
|
}
|
|
src += _Width;
|
|
dst += _Width;
|
|
}
|
|
while(--height);
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
if (CTraits<T>::SupportRawCopy)
|
|
{
|
|
// type support fast copy
|
|
::memcpy(&(*dst), &(*src), sizeof(T) * width);
|
|
}
|
|
else
|
|
{
|
|
std::copy(src, src + width, dst);
|
|
}
|
|
src += _Width;
|
|
dst += _Width;
|
|
}
|
|
while(--height);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// *********************************************************************************
|
|
template <class T>
|
|
void CArray2D<T>::move(sint offsetX, sint offsetY)
|
|
{
|
|
moveSubArray(offsetX, offsetY, 0, 0, _Width, _Height);
|
|
}
|
|
|
|
// *********************************************************************************
|
|
template <class T>
|
|
void CArray2D<T>::init(uint width, uint height)
|
|
{
|
|
_Array.resize(width * height);
|
|
_Width = width;
|
|
_Height = height;
|
|
}
|
|
|
|
// *********************************************************************************
|
|
template <class T>
|
|
void CArray2D<T>::init(uint width,uint height, const T &defaultValue)
|
|
{
|
|
_Array.resize(width * height, defaultValue);
|
|
_Width = width;
|
|
_Height = height;
|
|
}
|
|
|
|
|
|
// *********************************************************************************
|
|
// A height grid with wrapping
|
|
|
|
class CHeightGridWrapped
|
|
{
|
|
public:
|
|
class CGridElem
|
|
{
|
|
public:
|
|
sint X;
|
|
sint Y;
|
|
float Z;
|
|
public:
|
|
bool operator == (const CGridElem &other) const
|
|
{
|
|
return X == other.X &&
|
|
Y == other.Y &&
|
|
Z == other.Z;
|
|
}
|
|
};
|
|
typedef std::list<CGridElem> TGridElemList;
|
|
// ctor
|
|
CHeightGridWrapped();
|
|
// Init with the given size
|
|
// The size is required to be a power of 2
|
|
void init(uint size, float cellSize);
|
|
inline void insert(const CGridElem &ge);
|
|
inline void remove(const CGridElem &ge);
|
|
const TGridElemList &getGridElemList(sint x, sint y) const { return _Grid(x & _SizeMask, y & _SizeMask); }
|
|
uint getSize() const { return _Grid.getWidth(); }
|
|
// tmp for debug
|
|
uint getListMaxLength() const;
|
|
private:
|
|
CArray2D<TGridElemList> _Grid;
|
|
float _CellSize;
|
|
float _InvCellSize;
|
|
uint _SizeMask;
|
|
};
|
|
|
|
|
|
|
|
// *********************************************************************************
|
|
inline void CHeightGridWrapped::insert(const CGridElem &ge)
|
|
{
|
|
_Grid(ge.X & _SizeMask, ge.Y & _SizeMask).push_back(ge);
|
|
}
|
|
|
|
// *********************************************************************************
|
|
inline void CHeightGridWrapped::remove(const CGridElem &ge)
|
|
{
|
|
TGridElemList &gel = _Grid(ge.X & _SizeMask, ge.Y & _SizeMask);
|
|
for(TGridElemList::iterator &it = gel.begin(); it != gel.end(); ++it)
|
|
{
|
|
if (*it == ge)
|
|
{
|
|
gel.erase(it);
|
|
return;
|
|
}
|
|
}
|
|
nlassert(0);
|
|
}
|
|
|
|
const float HEIGHT_GRID_MIN_Z = -10000.f;
|
|
|
|
// A height grid that give approximate z of geometry near the viewer.
|
|
// Useful to avoid precipitations in interiors / tunnels
|
|
//
|
|
class CHeightGrid : public NL3D::ULandscapeTileCallback
|
|
{
|
|
public:
|
|
// ctor
|
|
CHeightGrid();
|
|
// Init the grid before first use
|
|
// \param cellSize size of a cell of the height grid (in world unit)
|
|
// \param cellSize heightGridSize width/height of the height grid. It must be a power of 2
|
|
// \param cellSize wrappedHeightGridSize width/height of the wrapped height grid (for incoming geometry).
|
|
// It must be a power of 2.
|
|
// \param minZ Minimum possible Z
|
|
//
|
|
void init(float cellSize, uint heightGridSize, uint wrappedHeightGridSize, float minZ = HEIGHT_GRID_MIN_Z);
|
|
void update(const CVector &newPos);
|
|
// for debug, display the height grid on screen
|
|
void display(NL3D::UDriver &drv) const;
|
|
inline void gridCoordToWorld(sint x, sint y, CVector &dest) const;
|
|
inline CVector gridCoordToWorld(sint x, sint y) const;
|
|
// Remove a collision mesh (no op if not already added)
|
|
void removeCollisionMesh(uint id);
|
|
///////////////////////////////////////////////////////////////////////
|
|
private:
|
|
typedef std::map<uint, UVisualCollisionManager::CMeshInstanceColInfo> TColMeshMap;
|
|
typedef std::vector<UVisualCollisionManager::CMeshInstanceColInfo> TColMeshVect;
|
|
CHeightGridWrapped _ZGridWrapped;
|
|
CArray2D<float> _ZGrid;
|
|
float _CellSize;
|
|
float _InvCellSize;
|
|
float _MinZ;
|
|
uint _GridSize;
|
|
uint _SizeMask;
|
|
sint _PosX;
|
|
sint _PosY;
|
|
std::vector<CRect> _UpdateRects;
|
|
CHashMap<uint64, CTileAddedInfo> _TileInfos;
|
|
CPolygon2D _Tri;
|
|
CPolygon2D::TRasterVect _Rasters;
|
|
TColMeshMap _Meshs; // meshs currenlty inserted in the wrapped grid
|
|
TColMeshVect _UpdateMeshs; // mesh to be removed / added to the wrapped grid during the update (keep there to avoid vector allocation)
|
|
std::vector<CVector> _CurrMeshVertices; // vertices of the mesh being inserted
|
|
CAABBox _BBox; // bbox containing current grid
|
|
private:
|
|
void updateBBox();
|
|
void updateRect(const CRect &rect);
|
|
void discardRect(const CRect &rect);
|
|
void updateCell(sint x, sint y);
|
|
// from ULandscapeTileCallback
|
|
virtual void tileAdded(const CTileAddedInfo &infos);
|
|
virtual void tileRemoved(uint64 id);
|
|
// add a tri in the height grid, and update height grid if necessary
|
|
void addTri(const CVector2f corners[3], float z);
|
|
void removeTri(const CVector2f corners[3], float z);
|
|
// Add a collision mesh (doesn't test if already inserted)
|
|
void addCollisionMesh(const UVisualCollisionManager::CMeshInstanceColInfo &colMesh);
|
|
};
|
|
|
|
// ***********************************************************************************
|
|
inline void CHeightGrid::gridCoordToWorld(sint x, sint y, CVector &dest) const
|
|
{
|
|
dest.set(x * _CellSize, y * _CellSize, 0.f);
|
|
}
|
|
|
|
// ***********************************************************************************
|
|
inline CVector CHeightGrid::gridCoordToWorld(sint x, sint y) const
|
|
{
|
|
CVector dest;
|
|
gridCoordToWorld(x, y, dest);
|
|
return dest;
|
|
}
|
|
|
|
|
|
|
|
|
|
// TMP TMP TMP TMP
|
|
// TMP TMP TMP TMP
|
|
// TMP TMP TMP TMP
|
|
// TMP TMP TMP TMP
|
|
extern CHeightGrid HeightGrid;
|
|
|
|
|
|
*/
|
|
|
|
/**
|
|
* Class to know where precipitation can't fall
|
|
* This is a grid that is updated with the position of the player
|
|
* It tells when the quad is in an interior mesh, and gives the
|
|
* mean height for a point of the quad (for landscape)
|
|
* \author Nicolas Vizerie
|
|
* \author Nevrax France
|
|
* \date 2002
|
|
*/
|
|
|
|
class CPrecipitationClipGrid
|
|
{
|
|
public:
|
|
/** Point of the grid
|
|
*/
|
|
struct CGridPoint
|
|
{
|
|
float MeanHeight; // The mean height that precipitation must use at this point
|
|
bool Clipped; // True if clipped
|
|
CGridPoint(float meanHeight = 0.f, bool clipped = true) : MeanHeight(meanHeight), Clipped(clipped)
|
|
{}
|
|
};
|
|
public:
|
|
// ctor
|
|
CPrecipitationClipGrid();
|
|
/** init the grid
|
|
* \param size width & height of the grid so the grid has (size + 1) ^2 elements. For example if size is 1, the grid is a simple square and it has four corners.
|
|
* \param gridEltSize width & height of a grid element.
|
|
*/
|
|
void initGrid(uint size, float gridEltSizeX, float gridEltSizeY);
|
|
|
|
// Update the grid so that it match the position of the user. (this grid is centered at the user pos)
|
|
void updateGrid(const NLMISC::CVector &userPos, NLPACS::UGlobalRetriever *globalRetriever);
|
|
|
|
/** Get grid element point its grid coordinate in world
|
|
* \return NULL if the element is outside the grid
|
|
*/
|
|
const CGridPoint *get(sint x, sint y) const;
|
|
|
|
// for debug, display the clip grid on screen
|
|
void display(NL3D::UDriver &drv) const;
|
|
|
|
// Force the whole grid to be recomputed
|
|
void touch() { _Touched = true; }
|
|
|
|
/////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////
|
|
private:
|
|
typedef std::vector<CGridPoint> TGrid;
|
|
private:
|
|
bool _Touched;
|
|
sint _XPos;
|
|
sint _YPos;
|
|
uint _Size;
|
|
float _EltSizeX;
|
|
float _EltSizeY;
|
|
TGrid _Grid;
|
|
private:
|
|
void clear();
|
|
void updateGridPart(sint worldX, sint worldY, uint gridX, uint gridY, uint width, uint height, NLPACS::UGlobalRetriever *globalRetriever);
|
|
void updateGridElt(CGridPoint &dest, uint worldX, uint worldY);
|
|
void moveGrid(sint offsetX, sint offsetY);
|
|
void printGridValues() const;
|
|
static TGrid::iterator getGridIt(TGrid &grid, uint x, uint y, uint size)
|
|
{
|
|
nlassert(size > 0);
|
|
nlassert(x <= size);
|
|
nlassert(y <= size);
|
|
return grid.begin() + (x + (y * (size + 1)));
|
|
}
|
|
static TGrid::const_iterator getGridIt(const TGrid &grid, uint x, uint y, uint size)
|
|
{
|
|
nlassert(size > 0);
|
|
nlassert(x <= size);
|
|
nlassert(y <= size);
|
|
return grid.begin() + (x + (y * (size + 1)));
|
|
}
|
|
};
|
|
|
|
|
|
#endif
|
|
|