chain.h

Go to the documentation of this file.

/* Copyright, 2001 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL 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
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_CHAIN_H
#define NL_CHAIN_H

#include <vector>
#include "nel/misc/types_nl.h"
#include "nel/misc/vector.h"
#include "vector_2s.h"
#include "nel/misc/file.h"

namespace NLPACS
{
class COrderedChain;

class COrderedChain3f
{
protected:
    friend class CChain;
    friend class CRetrievableSurface;

    std::vector<NLMISC::CVector>        _Vertices;

    bool                                _Forward;

    uint16                              _ParentId;

    uint16                              _IndexInParent;

public:
    const std::vector<NLMISC::CVector>  &getVertices() const { return _Vertices; }

    bool                                isForward() const { return _Forward; }

    uint16                              getParentId() const { return _ParentId; }

    uint16                              getIndexInParent() const { return _IndexInParent; }

    const NLMISC::CVector               &operator[] (uint n) const { return _Vertices[n]; }

    void                                unpack(const COrderedChain &ochain);

    void                                translate(const NLMISC::CVector &translation)
    {
        uint    i;
        for (i=0; i<_Vertices.size(); ++i)
            _Vertices[i] += translation;
    }

    void                                serial(NLMISC::IStream &f);
};

class COrderedChain
{
protected:
    friend class CChain;
    friend class CRetrievableSurface;

    std::vector<CVector2s>              _Vertices;

    bool                                _Forward;

    uint16                              _ParentId;

    uint16                              _IndexInParent;

    float                               _Length;

    CVector2s                           _Min, _Max;

public:
    const std::vector<CVector2s>        &getVertices() const { return _Vertices; }

    bool                                isForward() const { return _Forward; }

    uint16                              getParentId() const { return _ParentId; }

    uint16                              getIndexInParent() const { return _IndexInParent; }

    float                               getLength() const { return _Length; }

    const CVector2s                     &operator[] (uint n) const { return _Vertices[n]; }

    const CVector2s                     &getMin() const { return _Min; };

    const CVector2s                     &getMax() const { return _Max; };


    void                                translate(const NLMISC::CVector &translation);

    void                                pack(const COrderedChain3f &chain)
    {
        uint    i;
        const std::vector<NLMISC::CVector>  &vertices = chain.getVertices();
        _Vertices.resize(vertices.size());
        _Forward = chain.isForward();
        _ParentId = chain.getParentId();
        _IndexInParent = chain.getIndexInParent();
        for (i=0; i<vertices.size(); ++i)
        {
            _Vertices[i] = CVector2s(vertices[i]);
            _Min.minof(_Min, _Vertices[i]);
            _Max.maxof(_Max, _Vertices[i]);
        }
    }

    void                                computeMinMax()
    {
        _Min = _Max = CVector2s(0, 0);

        if (_Vertices.empty())
            return;

        _Min = _Max = _Vertices[0];
        uint    i;
        for (i=1; i<_Vertices.size(); ++i)
        {
            _Min.minof(_Min, _Vertices[i]);
            _Max.maxof(_Max, _Vertices[i]);
        }
    }

    void                                traverse(sint from, sint to, bool forward, std::vector<CVector2s> &path) const;

    float                               distance(const NLMISC::CVector &position) const;

    void                                serial(NLMISC::IStream &f);
};

class CChain
{
protected:
    friend class CRetrievableSurface;
    friend class CLocalRetriever;

    std::vector<uint16>                 _SubChains;

    sint32                              _Left;

    sint32                              _Right;

    uint16                              _StartTip;
    uint16                              _StopTip;

    float                               _Length;

    uint8                               _LeftLoop, _LeftLoopIndex;
    uint8                               _RightLoop, _RightLoopIndex;

protected:
    void                                make(const std::vector<NLMISC::CVector> &vertices, sint32 left, sint32 right, std::vector<COrderedChain> &chains, uint16 thisId,
                                             std::vector<COrderedChain3f> &fullChains, std::vector<uint> &useOChainId);

    void                                setLoopIndexes(sint32 surface, uint loop, uint loopIndex)
    {
        if (_Left == surface)
        {
            _LeftLoop = uint8(loop);
            _LeftLoopIndex = uint8(loopIndex);
        }
        else
        {
            _RightLoop = uint8(loop);
            _RightLoopIndex = uint8(loopIndex);
        }
    }

    void                                setBorderChainIndex(sint32 id)  { _Right = convertBorderChainId(id); }

public:

    CChain() :  _Left(-1), _Right(-1), _StartTip(0xffff), _StopTip(0xffff), _Length(0.0f),
                _LeftLoop(0), _LeftLoopIndex(0), _RightLoop(0), _RightLoopIndex(0) {}

    const std::vector<uint16>           &getSubChains() const { return _SubChains; }

    uint16                              getSubChain(uint n) const { return _SubChains[n]; }

    sint32                              getLeft() const { return _Left; }
    uint8                               getLeftLoop() const { return _LeftLoop; }
    uint8                               getLeftLoopIndex() const { return _LeftLoopIndex; }

    sint32                              getRight() const { return _Right; }
    uint8                               getRightLoop() const { return _RightLoop; }
    uint8                               getRightLoopIndex() const { return _RightLoopIndex; }

    float                               getLength() const { return _Length; }

    sint32                              getBorderChainIndex() const
    {
        return (isBorderChainId(_Right)) ? convertBorderChainId(_Right) : -1;
    }

    static bool                         isBorderChainId(sint32 id) { return id <= -256; }

    static sint32                       convertBorderChainId(sint32 id) { return -(id+256); }

    bool                                isBorderChain() const { return isBorderChainId(_Right); }

    static sint32                       getDummyBorderChainId() { return convertBorderChainId(0); }

    uint16                              getStartTip() const { return _StartTip; }

    uint16                              getStopTip() const { return _StopTip; }

    void                                serial(NLMISC::IStream &f);

protected:
    void                                unify(std::vector<COrderedChain> &ochains);

    void                                setStartVector(const CVector2s &v, std::vector<COrderedChain> &ochains);

    void                                setStopVector(const CVector2s &v, std::vector<COrderedChain> &ochains);

    CVector2s                           getStartVector(std::vector<COrderedChain> &ochains);

    //
    CVector2s                           getStopVector(std::vector<COrderedChain> &ochains);
};





//
inline void                             COrderedChain3f::unpack(const COrderedChain &chain)
{
    uint    i, mx;
    const std::vector<CVector2s>    &vertices = chain.getVertices();
    mx = _Vertices.size();
    _Vertices.resize(vertices.size());
    _Forward = chain.isForward();
    _ParentId = chain.getParentId();
    _IndexInParent = chain.getIndexInParent();
    for (i=0; i<vertices.size(); ++i)
    {
        _Vertices[i] = vertices[i].unpack3f(i >= mx ? 0.0f : _Vertices[i].z);
    }
}

}; // NLPACS

#endif // NL_CHAIN_H

/* End of chain.h */