mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-15 14:08:42 +00:00
349 lines
8.6 KiB
C++
349 lines
8.6 KiB
C++
|
// 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/>.
|
||
|
|
|
||
|
|
#include "stdpacs.h"
|
||
|
|
|
||
|
|
#include "chain.h"
|
||
|
|
|
||
|
|
using namespace std;
|
||
|
|
using namespace NLMISC;
|
||
|
|
|
||
|
|
|
||
|
|
// Functions for vertices comparison.
|
||
|
|
// total order relation
|
||
|
|
static inline bool isStrictlyLess(const CVector &a, const CVector &b)
|
||
|
|
{
|
||
|
|
if (a.x < b.x) return true;
|
||
|
|
if (a.x > b.x) return false;
|
||
|
|
if (a.y < b.y) return true;
|
||
|
|
if (a.y > b.y) return false;
|
||
|
|
if (a.z < b.y) return true;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
static inline bool isStrictlyGreater(const CVector &a, const CVector &b)
|
||
|
|
{
|
||
|
|
if (a.x > b.x) return true;
|
||
|
|
if (a.x < b.x) return false;
|
||
|
|
if (a.y > b.y) return true;
|
||
|
|
if (a.y < b.y) return false;
|
||
|
|
if (a.z > b.y) return true;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
static inline bool isEqual(const CVector &a, const CVector &b)
|
||
|
|
{
|
||
|
|
return (a == b);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// COrderedChain3f methods implementation
|
||
|
|
|
||
|
|
void NLPACS::COrderedChain3f::serial(NLMISC::IStream &f)
|
||
|
|
{
|
||
|
|
/*
|
||
|
|
Version 0:
|
||
|
|
- base version.
|
||
|
|
*/
|
||
|
|
(void)f.serialVersion(0);
|
||
|
|
|
||
|
|
f.serialCont(_Vertices);
|
||
|
|
f.serial(_Forward);
|
||
|
|
f.serial(_ParentId);
|
||
|
|
f.serial(_IndexInParent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// end of COrderedChain3f methods implementation
|
||
|
|
|
||
|
|
// COrderedChain methods implementation
|
||
|
|
|
||
|
|
// translates the ordered chain by the vector translation
|
||
|
|
void NLPACS::COrderedChain::translate(const CVector &translation)
|
||
|
|
{
|
||
|
|
uint i;
|
||
|
|
CVector2s translat;
|
||
|
|
translat.pack(translation);
|
||
|
|
for (i=0; i<_Vertices.size(); ++i)
|
||
|
|
_Vertices[i] += translat;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
void NLPACS::COrderedChain::traverse(sint from, sint to, bool forward, vector<NLPACS::CVector2s> &path) const
|
||
|
|
{
|
||
|
|
sint i;
|
||
|
|
if (forward)
|
||
|
|
{
|
||
|
|
if (from < 0) from = 0;
|
||
|
|
if (to < 0) to = _Vertices.size()-1;
|
||
|
|
|
||
|
|
for (i=from+1; i<=to; ++i)
|
||
|
|
path.push_back(_Vertices[i]);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (from < 0) from = _Vertices.size()-2;
|
||
|
|
if (to < 0) to = -1;
|
||
|
|
|
||
|
|
for (i=from; i>to; --i)
|
||
|
|
path.push_back(_Vertices[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
float NLPACS::COrderedChain::distance(const CVector &position) const
|
||
|
|
{
|
||
|
|
float minDist = 1.0e10f;
|
||
|
|
uint i;
|
||
|
|
CVector2f pos = CVector2f(position);
|
||
|
|
|
||
|
|
for (i=0; i+1<_Vertices.size(); ++i)
|
||
|
|
{
|
||
|
|
CVector2f a = _Vertices[i].unpack(),
|
||
|
|
b = _Vertices[i+1].unpack();
|
||
|
|
|
||
|
|
CVector2f d = (b-a);
|
||
|
|
float len = d.norm();
|
||
|
|
d /= len;
|
||
|
|
CVector2f n = CVector2f(d.y, -d.x);
|
||
|
|
|
||
|
|
float l = (pos-a)*d;
|
||
|
|
float dist;
|
||
|
|
|
||
|
|
if (l < 0.0f)
|
||
|
|
{
|
||
|
|
dist = (pos-a).norm();
|
||
|
|
}
|
||
|
|
else if (l > len)
|
||
|
|
{
|
||
|
|
dist = (pos-b).norm();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
dist = (float)fabs((pos-a)*n);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (dist < minDist)
|
||
|
|
{
|
||
|
|
minDist = dist;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return minDist;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// serializes the ordered chain
|
||
|
|
void NLPACS::COrderedChain::serial(NLMISC::IStream &f)
|
||
|
|
{
|
||
|
|
/*
|
||
|
|
Version 0:
|
||
|
|
- base version.
|
||
|
|
Version 1:
|
||
|
|
- added _Min and _Max vectors
|
||
|
|
*/
|
||
|
|
sint ver= f.serialVersion(1);
|
||
|
|
|
||
|
|
f.serialCont(_Vertices);
|
||
|
|
f.serial(_Forward);
|
||
|
|
f.serial(_ParentId);
|
||
|
|
f.serial(_IndexInParent);
|
||
|
|
f.serial(_Length);
|
||
|
|
|
||
|
|
if (ver >= 1)
|
||
|
|
{
|
||
|
|
f.serial(_Min, _Max);
|
||
|
|
}
|
||
|
|
else if (f.isReading() && !_Vertices.empty())
|
||
|
|
{
|
||
|
|
uint i;
|
||
|
|
_Max = _Min = _Vertices[0];
|
||
|
|
for (i=1; i<_Vertices.size(); ++i)
|
||
|
|
{
|
||
|
|
_Min.minof(_Min, _Vertices[i]);
|
||
|
|
_Max.maxof(_Max, _Vertices[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// end of COrderedChain methods implementation
|
||
|
|
|
||
|
|
|
||
|
|
// CChain methods implementation
|
||
|
|
|
||
|
|
// builds the CChain from a list of vertices and a left and right surfaces id.
|
||
|
|
// the chains vector is the vector where to store generated ordered chains.
|
||
|
|
// thisId is the current id of the CChain, and edge is the number of the edge the CChain belongs to (-1
|
||
|
|
// if none.)
|
||
|
|
void NLPACS::CChain::make(const vector<CVector> &vertices, sint32 left, sint32 right, vector<COrderedChain> &chains, uint16 thisId,
|
||
|
|
vector<COrderedChain3f> &fullChains, vector<uint> &useOChainId)
|
||
|
|
{
|
||
|
|
sint first = 0, last = 0, i;
|
||
|
|
|
||
|
|
_Left = left;
|
||
|
|
_Right = right;
|
||
|
|
_Length = 0.0f;
|
||
|
|
|
||
|
|
// splits the vertices list in ordered sub chains.
|
||
|
|
while (first < (sint)vertices.size()-1)
|
||
|
|
{
|
||
|
|
last = first+1;
|
||
|
|
bool forward = isStrictlyLess(vertices[first], vertices[last]);
|
||
|
|
|
||
|
|
// first checks if the subchain goes forward or backward.
|
||
|
|
if (forward)
|
||
|
|
for (; last < (sint)vertices.size() && isStrictlyLess(vertices[last-1], vertices[last]); ++last)
|
||
|
|
;
|
||
|
|
else
|
||
|
|
for (; last < (sint)vertices.size() && isStrictlyGreater(vertices[last-1], vertices[last]); ++last)
|
||
|
|
;
|
||
|
|
--last;
|
||
|
|
|
||
|
|
// inserts the new subchain id within the CChain.
|
||
|
|
uint32 subChainId;
|
||
|
|
|
||
|
|
if (useOChainId.empty())
|
||
|
|
{
|
||
|
|
subChainId = chains.size();
|
||
|
|
if (subChainId > 65535)
|
||
|
|
nlerror("in NLPACS::CChain::make(): reached the maximum number of ordered chains");
|
||
|
|
|
||
|
|
chains.resize(chains.size()+1);
|
||
|
|
fullChains.resize(fullChains.size()+1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
subChainId = useOChainId.back();
|
||
|
|
useOChainId.pop_back();
|
||
|
|
}
|
||
|
|
|
||
|
|
_SubChains.push_back((uint16)subChainId);
|
||
|
|
|
||
|
|
// and creates a new COrderedChain
|
||
|
|
COrderedChain3f &subchain3f = fullChains[subChainId];
|
||
|
|
subchain3f._Vertices.reserve(last-first+1);
|
||
|
|
subchain3f._Forward = forward;
|
||
|
|
subchain3f._ParentId = thisId;
|
||
|
|
subchain3f._IndexInParent = uint16(_SubChains.size()-1);
|
||
|
|
|
||
|
|
// and then copies the vertices (sorted, btw!)
|
||
|
|
if (forward)
|
||
|
|
for (i=first; i<=last; ++i)
|
||
|
|
subchain3f._Vertices.push_back(vertices[i]);
|
||
|
|
else
|
||
|
|
for (i=last; i>=first; --i)
|
||
|
|
subchain3f._Vertices.push_back(vertices[i]);
|
||
|
|
|
||
|
|
first = last;
|
||
|
|
|
||
|
|
COrderedChain &subchain = chains[subChainId];
|
||
|
|
subchain.pack(subchain3f);
|
||
|
|
subchain.computeMinMax();
|
||
|
|
|
||
|
|
float length = 0.0f;
|
||
|
|
for (i=0; i<(sint)subchain._Vertices.size()-1; ++i)
|
||
|
|
length += (subchain._Vertices[i+1]-subchain._Vertices[i]).norm();
|
||
|
|
|
||
|
|
subchain._Length = length;
|
||
|
|
_Length += length;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// serializes the CChain
|
||
|
|
void NLPACS::CChain::serial(NLMISC::IStream &f)
|
||
|
|
{
|
||
|
|
/*
|
||
|
|
Version 0:
|
||
|
|
- base version.
|
||
|
|
*/
|
||
|
|
(void)f.serialVersion(0);
|
||
|
|
|
||
|
|
f.serialCont(_SubChains);
|
||
|
|
f.serial(_Left, _Right);
|
||
|
|
f.serial(_StartTip, _StopTip);
|
||
|
|
f.serial(_Length);
|
||
|
|
f.serial(_LeftLoop, _LeftLoopIndex);
|
||
|
|
f.serial(_RightLoop, _RightLoopIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// unifiies the chain
|
||
|
|
void NLPACS::CChain::unify(vector<NLPACS::COrderedChain> &ochains)
|
||
|
|
{
|
||
|
|
CVector2s snap;
|
||
|
|
uint i;
|
||
|
|
|
||
|
|
snap = (ochains[_SubChains[0]].isForward()) ? ochains[_SubChains[0]]._Vertices.back() : ochains[_SubChains[0]]._Vertices.front();
|
||
|
|
|
||
|
|
for (i=1; i<_SubChains.size(); ++i)
|
||
|
|
{
|
||
|
|
if (ochains[_SubChains[i]].isForward())
|
||
|
|
{
|
||
|
|
if (ochains[_SubChains[i]]._Vertices.front() != snap)
|
||
|
|
nlwarning("ochain %d and %d are not stuck together", _SubChains[i-1], _SubChains[i]);
|
||
|
|
ochains[_SubChains[i]]._Vertices.front() = snap;
|
||
|
|
snap = ochains[_SubChains[i]]._Vertices.back();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (ochains[_SubChains[i]]._Vertices.back() != snap)
|
||
|
|
nlwarning("ochain %d and %d are not stuck together", _SubChains[i-1], _SubChains[i]);
|
||
|
|
ochains[_SubChains[i]]._Vertices.back() = snap;
|
||
|
|
snap = ochains[_SubChains[i]]._Vertices.front();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
void NLPACS::CChain::setStartVector(const NLPACS::CVector2s &v, vector<NLPACS::COrderedChain> &ochains)
|
||
|
|
{
|
||
|
|
if (ochains[_SubChains.front()].isForward())
|
||
|
|
ochains[_SubChains.front()]._Vertices.front() = v;
|
||
|
|
else
|
||
|
|
ochains[_SubChains.front()]._Vertices.back() = v;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
void NLPACS::CChain::setStopVector(const NLPACS::CVector2s &v, vector<NLPACS::COrderedChain> &ochains)
|
||
|
|
{
|
||
|
|
if (ochains[_SubChains.back()].isForward())
|
||
|
|
ochains[_SubChains.back()]._Vertices.back() = v;
|
||
|
|
else
|
||
|
|
ochains[_SubChains.back()]._Vertices.front() = v;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
NLPACS::CVector2s NLPACS::CChain::getStartVector(vector<NLPACS::COrderedChain> &ochains)
|
||
|
|
{
|
||
|
|
if (ochains[_SubChains.front()].isForward())
|
||
|
|
return ochains[_SubChains.front()]._Vertices.front();
|
||
|
|
else
|
||
|
|
return ochains[_SubChains.front()]._Vertices.back();
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
NLPACS::CVector2s NLPACS::CChain::getStopVector(vector<NLPACS::COrderedChain> &ochains)
|
||
|
|
{
|
||
|
|
if (ochains[_SubChains.back()].isForward())
|
||
|
|
return ochains[_SubChains.back()]._Vertices.back();
|
||
|
|
else
|
||
|
|
return ochains[_SubChains.back()]._Vertices.front();
|
||
|
|
}
|
||
|
|
|
||
|
|
// end of CChain methods implementation
|
||
|
|
|