khanat-opennel-code/code/nel/tools/pacs/build_rbank/surface_splitter.h

582 lines
15 KiB
C
Raw Normal View History

2010-07-14 14:52:15 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// 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_SURFACE_SPLITTER_H
#define NL_SURFACE_SPLITTER_H
#include "nel/misc/types_nl.h"
#include "nel/../../src/pacs/local_retriever.h"
#include "nel/../../src/pacs/quad_grid.h"
#include <map>
/**
* TODO Class description
* \author Benjamin Legros
* \author Nevrax France
* \date 2002
*/
class CSurfaceSplitter
{
public:
///
class CVector2s64;
class CSurfaceId;
class CChain;
class CLoop;
class CSurface;
///
class CFixed64
{
protected:
sint64 _Value;
public:
CFixed64() : _Value(0) {}
CFixed64(const sint64 &v) : _Value(v) {}
CFixed64(const double &v) : _Value((sint64)(v*4294967296.0)) {}
CFixed64(const CFixed64 &v) : _Value(v._Value) {}
operator double(void) const { return ((double)_Value) / 4294967296.0; }
operator float(void) const { return ((float)_Value) / 4294967296.0f; }
operator sint64(void) const { return _Value; }
CFixed64 operator + (const CFixed64 &f) const { return CFixed64(_Value + f._Value); }
CFixed64 operator - (const CFixed64 &f) const { return CFixed64(_Value - f._Value); }
CFixed64 operator - () const { return CFixed64(-_Value); }
CFixed64 operator * (const CFixed64 &f) const
{
sint64 vh = _Value>>32;
sint64 vl = _Value&0xffffffff;
sint64 uh = f._Value>>32;
sint64 ul = f._Value&0xffffffff;
sint64 res = ((vh*uh)<<32)+(vh*ul+uh*vl)+((uint64)(vl*ul)>>32);
double fres = ((double)res) / 4294967296.0;
double cfres = (double)(*this) * (double)f;
return CFixed64(res);
}
CFixed64 operator / (const CFixed64 &f) const
{
if (f._Value == 0)
return CFixed64();
sint sign = 0;
uint64 a = _Value;
uint64 b = f._Value;
if ((sint64)a < 0)
a = -(sint64)a, sign ^= 1;
if ((sint64)b < 0)
b = -(sint64)b, sign ^= 1;
uint64 lb = INT64_CONSTANT (0x8000000000000000);
uint64 q = 0;
uint64 nh = a>>32;
uint64 nl = a<<32;
while (lb != 0)
{
if (nh >= b)
{
q |= (lb+lb);
nh -= b;
}
nh = (nh+nh) + (nl&lb ? 1 : 0);
lb >>= 1;
}
// round final bit
if (nh >= b)
++q;
CFixed64 result(sign ? -(sint64)q : +(sint64)q );
return result;
}
CFixed64 &operator += (const CFixed64 &f) { _Value+=f._Value; return *this; }
CFixed64 &operator -= (const CFixed64 &f) { _Value-=f._Value; return *this; }
CFixed64 &operator *= (const CFixed64 &f) { *this = *this*f; return *this; }
CFixed64 &operator /= (const CFixed64 &f) { *this = *this/f; return *this; }
bool operator == (const CFixed64 &f) const { return _Value == f._Value; }
bool operator != (const CFixed64 &f) const { return _Value != f._Value; }
bool operator < (const CFixed64 &f) const { return _Value < f._Value; }
bool operator <= (const CFixed64 &f) const { return _Value <= f._Value; }
bool operator >= (const CFixed64 &f) const { return _Value >= f._Value; }
bool operator > (const CFixed64 &f) const { return _Value > f._Value; }
double sqnorm() const { return (double)(*this * *this); }
double norm() const { return sqrt(sqnorm()); }
};
///
class CVector2s64
{
public:
CFixed64 x;
CFixed64 y;
CVector2s64() : x(), y() {}
CVector2s64(const sint64 &X, const sint64 &Y) : x(X), y(Y) {}
CVector2s64(const CFixed64 &X, const CFixed64 &Y) : x(X), y(Y) {}
CVector2s64(const NLMISC::CVector &v) : x(v.x), y(v.y) {}
CVector2s64(const NLMISC::CVectorD &v) : x(v.x), y(v.y) {}
CVector2s64(const NLPACS::CVector2s &v) : x(((sint64)v.x) << 25), y(((sint64)v.y) << 25) {}
CVector2s64 operator + (const CVector2s64 &v) const { return CVector2s64(x+v.x, y+v.y); }
CVector2s64 operator - (const CVector2s64 &v) const { return CVector2s64(x-v.x, y-v.y); }
CVector2s64 operator * (sint64 s) const { return CVector2s64(x*CFixed64(s), y*CFixed64(s)); }
CVector2s64 operator * (CFixed64 s) const { return CVector2s64(x*s, y*s); }
CVector2s64 operator * (double s) const { return CVector2s64(x*CFixed64(s), y*CFixed64(s)); }
CVector2s64 operator / (sint64 s) const { return CVector2s64(x*CFixed64(s), y*CFixed64(s)); }
CVector2s64 operator / (CFixed64 s) const { return CVector2s64(x*s, y*s); }
CVector2s64 operator / (double s) const { return CVector2s64(x*CFixed64(s), y*CFixed64(s)); }
CFixed64 operator * (const CVector2s64 &v) const { return x*v.x + y*v.y; }
CFixed64 operator ^ (const CVector2s64 &v) const { return x*v.y - y*v.x; }
bool operator == (const CVector2s64 &v) const { return x == v.x && y == v.y; }
bool operator != (const CVector2s64 &v) const { return x != v.x || y != v.y; }
CVector2s64 &operator += (const CVector2s64 &v)
{
x += v.x;
y += v.y;
return *this;
}
CVector2s64 &operator -= (const CVector2s64 &v)
{
x -= v.x;
y -= v.y;
return *this;
}
CVector2s64 &operator *= (sint64 s)
{
CFixed64 ss(s);
x *= ss;
y *= ss;
return *this;
}
CVector2s64 &operator *= (double s)
{
CFixed64 ss(s);
x *= ss;
y *= ss;
return *this;
}
NLMISC::CVector asVector() const
{
return NLMISC::CVector((float)x, (float)y, 0.0f);
}
NLMISC::CVectorD asVectorD() const
{
return NLMISC::CVectorD((double)x, (double)y, 0.0);
}
};
///
class CSurfaceId
{
public:
uint16 Instance;
uint16 Surface;
uint16 SubSurface;
CSurfaceId(uint16 instance=65535, uint16 surface=65535, uint16 subsurface=0) :
Instance(instance),
Surface(surface),
SubSurface(subsurface) {}
bool operator == (const CSurfaceId &id) const { return Instance == id.Instance && Surface == id.Surface && SubSurface == id.SubSurface; }
bool operator != (const CSurfaceId &id) const { return !(*this == id); }
bool operator < (const CSurfaceId &id) const
{
if (Instance < id.Instance)
return true;
else if (Instance > id.Instance)
return false;
else if (Surface < id.Surface)
return true;
else if (Surface > id.Surface)
return false;
else
return SubSurface < id.SubSurface;
}
bool operator > (const CSurfaceId &id) const { return id < *this; }
bool operator <= (const CSurfaceId &id) const { return *this == id || *this < id; }
bool operator >= (const CSurfaceId &id) const { return *this == id || id < *this; }
};
///
class CChainId
{
public:
CChainId(uint32 id=0) : Id(id) {}
uint32 Id;
bool operator == (const CChainId &id) const { return Id == id.Id; }
bool operator != (const CChainId &id) const { return !(*this == id); }
bool operator < (const CChainId &id) const { return Id < id.Id; }
bool operator > (const CChainId &id) const { return id < *this; }
bool operator <= (const CChainId &id) const { return *this == id || *this < id; }
bool operator >= (const CChainId &id) const { return *this == id || id < *this; }
};
///
class CEdgeId
{
public:
CEdgeId(const CChainId &chain=CChainId(), uint edge=0) : Chain(chain), Edge(edge) {}
CChainId Chain;
uint Edge;
};
typedef NLPACS::CQuadGrid<CEdgeId> TEdgeGrid;
///
class CTipId
{
public:
CTipId(uint32 id=0) : Id(id) {}
uint32 Id;
bool operator == (const CTipId &id) const { return Id == id.Id; }
bool operator != (const CTipId &id) const { return !(*this == id); }
bool operator < (const CTipId &id) const { return Id < id.Id; }
bool operator > (const CTipId &id) const { return id < *this; }
bool operator <= (const CTipId &id) const { return *this == id || *this < id; }
bool operator >= (const CTipId &id) const { return *this == id || id < *this; }
};
///
class CChain
{
public:
CChainId Id;
CSurfaceId Left;
CSurfaceId Right;
CTipId Start;
CTipId Stop;
std::vector<CVector2s64> Vertices;
std::vector<TEdgeGrid::CIterator> Iterators;
bool DontSplit;
///
CChain() : DontSplit(false) {}
///
void dump(bool forward) const
{
NLMISC::InfoLog->displayRawNL("Chain:%d[Left=%d:%d:%d,Right=%d:%d:%d]", Id.Id, Left.Instance, Left.Surface, Left.SubSurface, Right.Instance, Right.Surface, Right.SubSurface);
sint i, j=0;
if (forward)
{
for (i=0; i<(sint)Vertices.size(); ++i, ++j)
NLMISC::InfoLog->displayRawNL("%d;%.3f;%.3f", j, (double)Vertices[i].x, (double)Vertices[i].y);
}
else
{
for (i=(sint)Vertices.size()-1; i>=0; --i, ++j)
NLMISC::InfoLog->displayRawNL("%d;%.3f;%.3f", j, (double)Vertices[i].x, (double)Vertices[i].y);
}
}
};
///
class CTip
{
public:
CTipId Id;
CVector2s64 Tip;
std::vector<CChainId> Chains;
};
///
class CLoop
{
public:
CSurfaceId Surface;
std::vector<CChainId> Chains;
///
void dump(const CSurfaceSplitter &splitter) const
{
uint i;
for (i=0; i<Chains.size(); ++i)
{
const CChain *chain = splitter.getChain(Chains[i]);
if (chain != NULL)
chain->dump(Surface == chain->Left);
}
}
///
void removeChain(CChainId chain)
{
std::vector<CChainId>::iterator it;
for (it=Chains.begin(); it!=Chains.end(); )
{
if (*it == chain)
it = Chains.erase(it);
else
++it;
}
}
///
class iterator
{
public:
CSurfaceSplitter *pSplitter;
CLoop *pLoop;
sint Chain;
CChain *pChain;
sint ChainVertex;
sint8 Direction;
sint8 ChainDirection;
iterator(CSurfaceSplitter *splitter=NULL, CLoop *loop=NULL, bool forward=true) : pSplitter(splitter), pLoop(loop), Chain(0), pChain(NULL), ChainVertex(0), Direction(0), ChainDirection(0)
{
Direction = forward ? +1 : -1;
if (splitter == NULL || pLoop == NULL)
return;
Chain = (Direction>0 ? 0 : (sint)pLoop->Chains.size()-1);
resetChain();
}
iterator(const iterator &it)
{
*this = it;
}
iterator &operator = (const iterator &it)
{
pSplitter = it.pSplitter;
pLoop = it.pLoop;
Chain = it.Chain;
pChain = it.pChain;
ChainVertex = it.ChainVertex;
Direction = it.Direction;
return *this;
}
bool operator == (const iterator &it)
{
return pSplitter == it.pSplitter &&
pLoop == it.pLoop &&
Chain == it.Chain &&
ChainVertex == it.ChainVertex;
}
bool operator != (const iterator &it) { return !(*this == it); }
iterator &operator ++ ()
{
ChainVertex += ChainDirection;
if (ChainVertex == 0 || ChainVertex == (sint)pChain->Vertices.size()-1)
{
Chain += Direction;
resetChain();
}
// FIXME add return value here!
}
void resetChain()
{
if (Chain < 0 || Chain == (sint)pLoop->Chains.size())
{
pSplitter = NULL;
pLoop = NULL;
Chain = 0;
pChain = NULL;
ChainVertex = 0;
Direction = 0;
ChainDirection = 0;
return;
}
pChain = pSplitter->getChain(pLoop->Chains[Chain]);
ChainDirection = (pChain->Left == pLoop->Surface ? Direction : -Direction);
ChainVertex = (ChainDirection>0 ? 0 : (sint)pChain->Vertices.size()-1);
}
CVector2s64 operator * () const
{
return pChain->Vertices[ChainVertex];
}
};
};
///
class CSurface
{
public:
CSurfaceId Id;
std::vector<CLoop> Loops;
///
void dump(const CSurfaceSplitter &splitter) const
{
NLMISC::InfoLog->displayRawNL("---Surface:%d:%d:%d", Id.Instance, Id.Surface, Id.SubSurface);
uint i;
for (i=0; i<Loops.size(); ++i)
{
NLMISC::InfoLog->displayRawNL("Loop:%d", i);
Loops[i].dump(splitter);
}
}
///
void removeChain(CChainId chain)
{
uint i;
for (i=0; i<Loops.size(); ++i)
Loops[i].removeChain(chain);
}
};
protected:
typedef std::map<CSurfaceId, CSurface> TSurfaceMap;
typedef std::map<CChainId, CChain> TChainMap;
typedef std::map<CTipId, CTip> TTipMap;
TSurfaceMap _Surfaces;
uint _NumSurfaces;
TChainMap _Chains;
uint _NumChains;
TTipMap _Tips;
uint _NumTips;
TEdgeGrid _Edges;
public:
/// Constructor
CSurfaceSplitter();
///
void build(NLPACS::CLocalRetriever &lr);
///
CSurface *getSurface(const CSurfaceId &id)
{
TSurfaceMap::iterator it = _Surfaces.find(id);
return (it == _Surfaces.end() ? NULL : &((*it).second));
}
///
CChain *getChain(const CChainId &id)
{
TChainMap::iterator it = _Chains.find(id);
return (it == _Chains.end() ? NULL : &((*it).second));
}
///
const CSurface *getSurface(const CSurfaceId &id) const
{
TSurfaceMap::const_iterator it = _Surfaces.find(id);
return (it == _Surfaces.end() ? NULL : &((*it).second));
}
///
const CChain *getChain(const CChainId &id) const
{
TChainMap::const_iterator it = _Chains.find(id);
return (it == _Chains.end() ? NULL : &((*it).second));
}
protected:
///
void buildChain(NLPACS::CLocalRetriever &lr, uint chain);
///
void buildSurface(NLPACS::CLocalRetriever &lr, uint surface);
///
void initEdgeGrid();
///
void splitChains();
///
void splitChain(TChainMap::iterator it, uint &numInters);
///
void dump() const
{
TSurfaceMap::const_iterator it;
for (it=_Surfaces.begin(); it!=_Surfaces.end(); ++it)
(*it).second.dump(*this);
}
///
void dumpChain(CChainId chain) const
{
TChainMap::const_iterator it = _Chains.find(chain);
if (it == _Chains.end())
return;
(*it).second.dump(true);
}
///
bool intersect(const CVector2s64 &v0, const CVector2s64 &v1,
const CVector2s64 &c0, const CVector2s64 &c1,
CVector2s64 &intersect, CFixed64 &ndist);
///
CChainId addChain(const CSurfaceId &left, const CSurfaceId &right, const std::vector<CVector2s64> &points, bool dontSplit=false);
///
void removeChain(CChainId chain);
///
void replaceChain(CChainId chain, const std::vector<CChainId> &chains);
};
#endif // NL_SURFACE_SPLITTER_H
/* End of surface_splitter.h */