khanat-opennel-code/code/nel/src/pacs/chain.cpp

349 lines
8.6 KiB
C++
Raw Normal View History

2010-05-06 00:08:41 +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/>.
#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 = (sint)_Vertices.size()-1;
2010-05-06 00:08:41 +00:00
for (i=from+1; i<=to; ++i)
path.push_back(_Vertices[i]);
}
else
{
if (from < 0) from = (sint)_Vertices.size()-2;
2010-05-06 00:08:41 +00:00
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 = (uint32)chains.size();
2010-05-06 00:08:41 +00:00
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