lod_character_shape.h

Go to the documentation of this file.

/* Copyright, 2000-2002 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_LOD_CHARACTER_SHAPE_H
#define NL_LOD_CHARACTER_SHAPE_H

#include "nel/misc/types_nl.h"
#include "nel/misc/common.h"
#include "nel/3d/mesh.h"


namespace NL3D
{


// ***************************************************************************
class CLodCharacterShapeBuild
{
public:
    class   CPixelInfo
    {
    public:
        // The associated Pos/Normal of this pixel.
        CVector     Pos;
        CVector     Normal;

        // An id for an empty pixel.
        static const CPixelInfo     EmptyPixel;

    public:
        CPixelInfo() {}
        CPixelInfo(const CVector &pos, const CVector &normal) : Pos(pos), Normal(normal) {}
        bool        operator==(const CPixelInfo &o) const
        {
            return Pos==o.Pos && Normal==o.Normal;
        }

        void        serial(NLMISC::IStream &f)
        {
            f.serial(Pos, Normal);
        }
    };

public:
    CLodCharacterShapeBuild();

    // The Vertices of the shapes
    std::vector<CVector>            Vertices;

    // Palette Skinning Vertices array (same size as Vertices).
    std::vector<CMesh::CSkinWeight> SkinWeights;

    // UVs (same size as Vertices).
    std::vector<CUV>                UVs;

    // Normals (same size as Vertices).
    std::vector<CVector>            Normals;

    // Bones name. Each matrix id used in SkinWeights must have a corresponding string in the bone name array.
    std::vector<std::string>        BonesNames;

    // Faces array
    std::vector<uint32>             TriangleIndices;


public:

    void                compile(const std::vector<bool> &triangleSelection, uint textureOverSample=25);

    void                serial(NLMISC::IStream &f);

    const CPixelInfo    *getTextureInfoPtr();
    uint                getTextureInfoWidth() const {return _Width;}
    uint                getTextureInfoHeight() const {return _Height;}

// ****************
private:
    // For each pixel of the texture (32*32), give what vertex/normal use it.
    std::vector<CPixelInfo>     _TextureInfo;
    uint32                      _Width, _Height;

};


// ***************************************************************************
class CLodCharacterShape
{
public:

    struct  CAnimBuild
    {
        std::string     Name;
        uint            NumKeys;
        float           AnimLength;

        std::vector<CVector>    Keys;
    };

    struct  CVector3s
    {
        sint16  x,y,z;

        void        serial(NLMISC::IStream &f)
        {
            f.serial(x,y,z);
        }
    };

public:

    CLodCharacterShape();

    void            buildMesh(const std::string &name, const CLodCharacterShapeBuild &lodBuild);

    bool            addAnim(const CAnimBuild &animBuild);

    void            serial(NLMISC::IStream &f);

    const std::string &     getName() const {return _Name;}

    sint            getAnimIdByName(const std::string &name) const;

    uint            getNumVertices() const {return _NumVertices;}

    uint            getNumTriangles() const {return _NumTriangles;}

    uint            getNumBones() const {return _Bones.size();}

    sint            getBoneIdByName(const std::string &name) const;

    const TLodCharacterIndexType *getTriangleArray() const;

    const std::vector<TLodCharacterIndexType>   &getTriangleIndices() const {return _TriangleIndices;}

    const CUV       *getUVs() const;

    const CVector   *getNormals() const;


    // @{

    void            startBoneAlpha(std::vector<uint8>   &tmpAlphas) const;

    void            addBoneAlpha(uint boneId, std::vector<uint8> &tmpAlphas) const;

    // @}

    const CVector3s *getAnimKey(uint animId, TGlobalAnimationTime time, bool wrapMode, CVector &unPackScaleFactor) const;


// *******************************
private:

    struct  CAnim
    {
        std::string     Name;
        uint32          NumKeys;
        float           AnimLength;
        float           OOAnimLength;
        CVector         UnPackScaleFactor;

        std::vector<CVector3s>  Keys;

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

    struct  CVertexInf
    {
        // Id of the vertex that the bone influence.
        uint32      VertexId;
        // weight of influence
        float       Influence;

        void        serial(NLMISC::IStream &f)
        {
            f.serial(VertexId);
            f.serial(Influence);
        }
    };

    struct  CBoneInfluence
    {
        // Name of the bone.
        std::string             Name;

        // list of vertex this bone influence.
        std::vector<CVertexInf> InfVertices;

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

    typedef std::map<std::string, uint32>   TStrIdMap;
    typedef TStrIdMap::iterator             ItStrIdMap;
    typedef TStrIdMap::const_iterator       CstItStrIdMap;

private:
    std::string             _Name;
    uint32                  _NumVertices;
    uint32                  _NumTriangles;
    // UVs and Normals
    std::vector<CUV>        _UVs;
    std::vector<CVector>    _Normals;
    std::vector<CBoneInfluence>     _Bones;

    // The map of bone.
    TStrIdMap               _BoneMap;

    std::vector<TLodCharacterIndexType>     _TriangleIndices;

    std::vector<CAnim>      _Anims;

    // The map of animation.
    TStrIdMap               _AnimMap;

};


} // NL3D


#endif // NL_LOD_CHARACTER_SHAPE_H

/* End of lod_character_shape.h */