mrm_mesh.h

Go to the documentation of this file.

/* Copyright, 2000 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_MRM_MESH_H
#define NL_MRM_MESH_H

#include "nel/misc/types_nl.h"
#include "nel/misc/debug.h"
#include "nel/misc/vector_h.h"
#include "nel/misc/vector.h"
#include "nel/3d/mesh.h"
#include <vector>


namespace NL3D
{


using NLMISC::CVector;
using NLMISC::CVectorH;


// ***************************************************************************
#define NL3D_MRM_MAX_ATTRIB     12


// ***************************************************************************
struct  CMRMCorner
{
    // The id of the vertex.
    sint    Vertex;
    // The ids of the wedges. Points on Attributes of the mesh.
    sint    Attributes[NL3D_MRM_MAX_ATTRIB];

    // For CMRMMeshFinal computing, wedge ids.
    sint    WedgeStartId;
    sint    WedgeEndId;
    sint    WedgeGeomId;
};


// ***************************************************************************
struct  CMRMFace
{
public:
    // The 3 corner indices of the face.
    CMRMCorner      Corner[3];
    // The id of the material. Used for material boundaries.
    sint            MaterialId;
};


// ***************************************************************************
class   CMRMBlendShape
{
public:
    // The vertices of the MRMMesh.
    std::vector<CVector>        Vertices;
    // The attributes of the MRMMesh.
    std::vector<CVectorH>       Attributes[NL3D_MRM_MAX_ATTRIB];
    // The number of used attributes of the MRMMesh.
    sint                        NumAttributes;
};


// ***************************************************************************
class CMRMMesh
{
public:
    // The vertices of the MRMMesh.
    std::vector<CVector>                Vertices;
    // The skinWeights of the MRMMesh. same size than Vertices.
    std::vector<CMesh::CSkinWeight>     SkinWeights;
    // The link to the original meshInterface vertex. same size than Vertices.
    std::vector<CMesh::CInterfaceLink>  InterfaceLinks;
    // The attributes of the MRMMesh.
    std::vector<CVectorH>       Attributes[NL3D_MRM_MAX_ATTRIB];
    // The number of used attributes of the MRMMesh.
    sint                        NumAttributes;
    // The faces of the MRMMesh.
    std::vector<CMRMFace>       Faces;


    std::vector<CMRMBlendShape>     BlendShapes;


public:
    CMRMMesh();

};


// ***************************************************************************
class CMRMMeshGeom : public CMRMMesh
{
public:
    std::vector<CMRMFace>       CoarserFaces;


    CMRMMeshGeom    &operator=(const CMRMMesh &o)
    {
        (CMRMMesh&)(*this)= o;
        // copy faces into CoarserFaces.
        CoarserFaces= Faces;
        return *this;
    }

public:
    CMRMMeshGeom() {}
};


// ***************************************************************************
struct  CMRMWedgeGeom
{
    uint32  Start;
    uint32  End;


    void    serial(NLMISC::IStream &f)
    {
        f.serial(Start, End);
    }
};


// ***************************************************************************
class   CMRMMeshFinal
{
public:

    // An wedge value (vertex + all attribs).
    struct  CWedge
    {
        CWedge();
        CMesh::CSkinWeight      VertexSkin;
        // Number of matrix this wedge use.
        uint        NSkinMatUsed;
        CVector     Vertex;
        CVectorH    Attributes[NL3D_MRM_MAX_ATTRIB];
        static      uint    NumAttributesToCompare;
        static      bool    CompareSkinning;

        bool    operator<(const CWedge &o) const
        {
            if(Vertex!=o.Vertex)
                return Vertex<o.Vertex;
            else
            {
                nlassert(NumAttributesToCompare<=NL3D_MRM_MAX_ATTRIB);
                for(uint i=0; i<NumAttributesToCompare; i++)
                {
                    if(Attributes[i]!=o.Attributes[i])
                        return Attributes[i]<o.Attributes[i];
                }
            }

            // They may be different by their skin Weight.
            if(CompareSkinning)
            {
                for(uint i=0; i<NL3D_MESH_SKINNING_MAX_MATRIX; i++)
                {
                    if( VertexSkin.MatrixId[i] != o.VertexSkin.MatrixId[i] )
                        return VertexSkin.MatrixId[i] < o.VertexSkin.MatrixId[i];
                    if( VertexSkin.Weights[i] != o.VertexSkin.Weights[i] )
                        return VertexSkin.Weights[i] < o.VertexSkin.Weights[i];
                }
            }

            // else they are equal.
            return false;
        }
    };

    // a face.
    struct  CFace
    {
        sint        WedgeId[3];
        sint        MaterialId;
    };


    // A LOD information for the final MRM representation.
    struct  CLod
    {
        sint                        NWedges;
        std::vector<CFace>          Faces;
        std::vector<CMRMWedgeGeom>  Geomorphs;
    };


    struct  CMRMBlendShapeFinal
    {
        std::vector<CWedge>         Wedges;
    };

public:
    std::vector<CWedge>         Wedges;
    sint                        NGeomSpace;
    sint                        NumAttributes;
    bool                        Skinned;
    std::vector<CLod>           Lods;


    std::vector<CMRMBlendShapeFinal>            MRMBlendShapesFinals;


    CMRMMeshFinal()
    {
        NumAttributes= 0;
    }


    sint    findInsertWedge(const CWedge &w);


    void    reset()
    {
        Wedges.clear();
        _WedgeMap.clear();
        Lods.clear();
        NumAttributes= 0;
    }


private:
    // The map of wedges to wedges index.
    typedef std::map<CWedge, sint>      TWedgeMap;
    TWedgeMap           _WedgeMap;

};


} // NL3D


#endif // NL_MRM_MESH_H

/* End of mrm_mesh.h */