mrm_builder.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_BUILDER_H
#define NL_MRM_BUILDER_H

#include "nel/misc/types_nl.h"
#include "nel/misc/uv.h"
#include "nel/3d/mrm_mesh.h"
#include "nel/3d/mrm_internal.h"
#include "nel/3d/mrm_parameters.h"
#include "nel/3d/mesh.h"
#include "nel/3d/mesh_mrm.h"
#include "nel/3d/mesh_mrm_skinned.h"
#include <map>


namespace NL3D
{



// ***************************************************************************
class CMRMBuilder
{
public:

    CMRMBuilder();



    void    compileMRM( const CMesh::CMeshBuild &mbuild, std::vector<CMesh::CMeshBuild*> &bsList,
                        const CMRMParameters &params, CMeshMRMGeom::CMeshBuildMRM &mrmMesh,
                        uint numMaxMaterial);



    void    compileMRM( const CMesh::CMeshBuild &mbuild, std::vector<CMesh::CMeshBuild*> &bsList,
                        const CMRMParameters &params, CMeshMRMSkinnedGeom::CMeshBuildMRM &mrmMesh,
                        uint numMaxMaterial);



// ****************************
private:
// Mesh Level Part.

    // @{
    // The vertices of the MRMMesh.
    std::vector<CMRMVertex>     TmpVertices;
    // The attributes of the MRMMesh.
    std::vector<CMRMAttribute>  TmpAttributes[NL3D_MRM_MAX_ATTRIB];
    // The number of used attributes of the MRMMesh.
    sint                        NumAttributes;
    // The faces of the MRMMesh.
    std::vector<CMRMFaceBuild>  TmpFaces;
    // Ordered list of Edge collapse.
    TEdgeMap                    EdgeCollapses;

    // Say if the current build must compute skinning information.
    bool                        _Skinned;
    CMRMParameters::TSkinReduction  _SkinReduction;

    // @}


    // @{
    bool    vertexHasOneWedge(sint numvertex);
    bool    vertexHasOneMaterial(sint numvertex);
    bool    vertexContinue(sint numvertex);
    bool    vertexClosed(sint numvertex);
    float   getDeltaFaceNormals(sint numvertex);    // return a positive value of Sum(|DeltaNormals|) / NNormals.
    bool    edgeContinue(const CMRMEdge &edge);
    bool    edgeNearUniqueMatFace(const CMRMEdge &edge);
    float   computeEdgeCost(const CMRMEdge &edge);
    // @}


    // @{
    bool    faceShareWedges(CMRMFaceBuild *face, sint attribId, sint numVertex1, sint numVertex2);
    void    insertFaceIntoEdgeList(CMRMFaceBuild &tmpf);
    void    removeFaceFromEdgeList(CMRMFaceBuild &f);
    sint    collapseEdge(const CMRMEdge &edge); // return num of deleted faces.
    sint    followVertex(sint i);
    sint    followWedge(sint attribId, sint i);
    CMesh::CSkinWeight  collapseSkinWeight(const CMesh::CSkinWeight &sw1, const CMesh::CSkinWeight &sw2, float InterValue) const;
    // @}


    // @{
    void    init(const CMRMMesh &baseMesh);
    void    collapseEdges(sint nWantedFaces);
    void    makeLODMesh(CMRMMeshGeom &lodMesh);
    void    saveCoarserMesh(CMRMMesh &coarserMesh);
    void    makeFromMesh(const CMRMMesh &baseMesh, CMRMMeshGeom &lodMesh, CMRMMesh &coarserMesh, sint nWantedFaces);
    // @}


    void    computeBsVerticesAttributes(std::vector<CMRMMesh> &srcBsMeshs, std::vector<CMRMMesh> &srcBsMeshsMod);
    void    makeCoarserBS (std::vector<CMRMBlendShape> &csBsMeshs);


    // @{
    bool                        _HasMeshInterfaces;
    // the sewing meshes
    std::vector<CMRMSewingMesh> _SewingMeshes;
    // The current Lod
    uint                        _CurrentLodComputed;

    // true if the build has some Mesh sewing interface setup.
    bool    buildMRMSewingMeshes(const CMesh::CMeshBuild &mbuild, uint nWantedLods, uint divisor);

    // @}


private:
// MRM Level Part.

    // @{
    // Our comparator of CMRMWedgeGeom.
    struct  CGeomPred
    {
        bool    operator()(const CMRMWedgeGeom &a, const CMRMWedgeGeom &b) const
        {
            if(a.Start!=b.Start)
                return a.Start<b.Start;
            return a.End<b.End;
        }
    };

    // The map of geomorph. for one LOD only;
    typedef std::map<CMRMWedgeGeom, sint, CGeomPred>        TGeomMap;
    TGeomMap            _GeomMap;
    // @}


    // @{
    void buildBlendShapes (CMRMMesh &baseMesh, std::vector<CMesh::CMeshBuild*> &bsList, uint32 VertexFlags);

    void    buildAllLods(   const CMRMMesh &baseMesh, std::vector<CMRMMeshGeom> &lodMeshs,
                            uint nWantedLods= 10, uint divisor= 50 );

    void    buildFinalMRM(std::vector<CMRMMeshGeom> &lodMeshs, CMRMMeshFinal &finalMRM);

    // @}



private:
// Interface to MeshBuild Part.

    // @{


    struct  CAttributeKey
    {
        sint        VertexId;
        CVectorH    Attribute;

        bool    operator<(const CAttributeKey &o) const
        {
            if(VertexId!=o.VertexId)
                return VertexId<o.VertexId;
            return Attribute<o.Attribute;
        }
    };
    typedef std::map<CAttributeKey, sint>       TAttributeMap;
    TAttributeMap       _AttributeMap[NL3D_MRM_MAX_ATTRIB];
    sint            findInsertAttributeInBaseMesh(CMRMMesh &baseMesh, sint attId, sint vertexId, const CVectorH &att);
    sint            findInsertNormalInBaseMesh(CMRMMesh &baseMesh, sint attId, sint vertexId, const CVector &normal);
    sint            findInsertColorInBaseMesh(CMRMMesh &baseMesh, sint attId, sint vertexId, CRGBA col);
    sint            findInsertUvwInBaseMesh(CMRMMesh &baseMesh, sint attId, sint vertexId, const NLMISC::CUVW &uvw);
    CRGBA           attToColor(const CVectorH &att) const;
    NLMISC::CUVW    attToUvw(const CVectorH &att) const;


    uint32          buildMrmBaseMesh(const CMesh::CMeshBuild &mbuild, CMRMMesh &baseMesh);

    void            buildMeshBuildMrm(const CMRMMeshFinal &finalMRM, CMeshMRMGeom::CMeshBuildMRM &mbuild, uint32 vbFlags, uint32 nbMats, const CMesh::CMeshBuild &mb);

    void            buildMeshBuildMrm(const CMRMMeshFinal &finalMRM, CMeshMRMSkinnedGeom::CMeshBuildMRM &mbuild, uint32 vbFlags, uint32 nbMats, const CMesh::CMeshBuild &mb);


    void            normalizeBaseMeshSkin(CMRMMesh &baseMesh) const;
    CMesh::CSkinWeight  normalizeSkinWeight(const CMesh::CSkinWeight &sw) const;

    // @}

};


} // NL3D


#endif // NL_MRM_BUILDER_H

/* End of mrm_builder.h */