mesh_mrm.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_MESH_MRM_H
#define NL_MESH_MRM_H

#include "nel/misc/types_nl.h"
#include "nel/3d/shape.h"
#include "nel/3d/driver.h"
#include "nel/misc/aabbox.h"
#include "nel/misc/uv.h"
#include "nel/3d/vertex_buffer.h"
#include "nel/3d/material.h"
#include "nel/3d/index_buffer.h"
#include "nel/3d/animated_material.h"
#include "nel/3d/mesh_base.h"
#include "nel/3d/mesh.h"
#include "nel/3d/mrm_mesh.h"
#include "nel/3d/mrm_parameters.h"
#include "nel/3d/bone.h"
#include "nel/3d/mesh_geom.h"
#include "nel/3d/mrm_level_detail.h"
#include "nel/3d/shadow_skin.h"
#include <set>
#include <vector>


namespace NL3D
{


using   NLMISC::CVector;
using   NLMISC::CPlane;
using   NLMISC::CMatrix;
class   CMRMBuilder;
// Fast matrix in mesh_mrm_skin.cpp
class   CMatrix3x4;
class   CRawVertexNormalSkin1;
class   CRawVertexNormalSkin2;
class   CRawVertexNormalSkin3;
class   CRawVertexNormalSkin4;
class   CRawSkinNormalCache;
class   CMeshMRMInstance;
class   CSkinSpecularRdrPass;

// ***************************************************************************
class   CMeshMRMGeom : public IMeshGeom
{
public:
    CMeshMRMGeom();
    ~CMeshMRMGeom();

    void            build(CMesh::CMeshBuild &m, std::vector<CMesh::CMeshBuild*> &bsList, uint numMaxMaterial, const CMRMParameters &params= CMRMParameters());

    void            applyMaterialRemap(const std::vector<sint> &remap);


    void            changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest);


    // @{

    virtual void    initInstance(CMeshBaseInstance *mbi);

    virtual bool    clip(const std::vector<CPlane>  &pyramid, const CMatrix &worldMatrix) ;

    virtual void    render(IDriver *drv, CTransformShape *trans, float polygonCount, uint32 rdrFlags, float globalAlpha);

    virtual void    renderSkin(CTransformShape *trans, float alphaMRM);

    virtual float   getNumTriangles (float distance);

    virtual void    serial(NLMISC::IStream &f) throw(NLMISC::EStream);
    NLMISC_DECLARE_CLASS(CMeshMRMGeom);

    void    profileSceneRender(CRenderTrav *rdrTrav, CTransformShape *trans, float polygonCount, uint32 rdrFlags);

    // @}


    // @{

    uint            getNbLodLoaded() const { return _NbLodLoaded ; }


    void            loadFirstLod(NLMISC::IStream &f);


    void            loadNextLod(NLMISC::IStream &f);


    void            unloadNextLod(NLMISC::IStream &f);


    // @}


    // @{

    const NLMISC::CAABBoxExt& getBoundingBox() const
    {
        return _BBox;
    }

    const CVertexBuffer &getVertexBuffer() const { return _VBufferFinal ; }

    const std::vector<CMesh::CSkinWeight>   &getSkinWeights() const {return _SkinWeights;}

    const std::vector<std::string>          &getBonesName() const {return _BonesName;}

    uint getNbLod() const { return _Lods.size() ; }


    uint getNbRdrPass(uint lodId) const { return _Lods[lodId].RdrPass.size() ; }


    const CIndexBuffer &getRdrPassPrimitiveBlock(uint lodId, uint renderingPassIndex) const
    {
        return _Lods[lodId].RdrPass[renderingPassIndex].PBlock ;
    }


    uint32 getRdrPassMaterial(uint lodId, uint renderingPassIndex) const
    {
        return _Lods[lodId].RdrPass[renderingPassIndex].MaterialId ;
    }


    const std::vector<CMRMWedgeGeom>    &getGeomorphs(uint lodId) const
    {
        return _Lods[lodId].Geomorphs;
    }

    uint getNbBlendShapes() const { return _MeshMorpher.BlendShapes.size(); }

    bool    buildGeometryForLod(uint lodId, std::vector<CVector> &vertices, std::vector<uint32> &triangles) const;

    // @}


    // @{

    bool isSkinned () const
    {
        return _Skinned;
    }

    void            computeBonesId (CSkeletonModel *skeleton);

    void            updateSkeletonUsage(CSkeletonModel *sm, bool increment);

    const std::vector<sint32>           &getSkinBoneUsage() const {return _BonesId;}

    const std::vector<NLMISC::CBSphere> &getSkinBoneSphere() const {return _BonesSphere;}

    bool            getSkinBoneBBox(CSkeletonModel *skeleton, NLMISC::CAABBox &bbox, uint boneId) const;

    // @}


    // @{

    virtual bool    supportMeshBlockRendering () const;

    virtual bool    sortPerMaterial() const;
    virtual uint    getNumRdrPassesForMesh() const ;
    virtual uint    getNumRdrPassesForInstance(CMeshBaseInstance *inst) const ;
    virtual void    beginMesh(CMeshGeomRenderContext &rdrCtx) ;
    virtual void    activeInstance(CMeshGeomRenderContext &rdrCtx, CMeshBaseInstance *inst, float polygonCount, void *vbDst) ;
    virtual void    renderPass(CMeshGeomRenderContext &rdrCtx, CMeshBaseInstance *inst, float polygonCount, uint rdrPass) ;
    virtual void    endMesh(CMeshGeomRenderContext &rdrCtx) ;

    virtual bool    getVBHeapInfo(uint &vertexFormat, uint &numVertices);
    virtual void    computeMeshVBHeap(void *dst, uint indexStart);
    virtual bool    isActiveInstanceNeedVBFill() const;

    // @}


    const   CMRMLevelDetail     &getLevelDetail() const {return _LevelDetail;}


    // @{
    bool            supportSkinGrouping() const;
    sint            renderSkinGroupGeom(CMeshMRMInstance    *mi, float alphaMRM, uint remainingVertices, uint8 *vbDest);
    void            renderSkinGroupPrimitives(CMeshMRMInstance  *mi, uint baseVertex, std::vector<CSkinSpecularRdrPass> &specularRdrPasses, uint skinIndex);
    void            renderSkinGroupSpecularRdrPass(CMeshMRMInstance *mi, uint rdrPassId);
    // @}

    // Is this mesh Geom has a VertexProgram bound?
    virtual bool    hasMeshVertexProgram() const {return _MeshVertexProgram!=NULL;}

    // @{
    void            setShadowMesh(const std::vector<CShadowVertex> &shadowVertices, const std::vector<uint32> &triangles);

    uint            getNumShadowSkinVertices() const;

    bool            supportShadowSkinGrouping() const {return _SupportShadowSkinGrouping;}
    sint            renderShadowSkinGeom(CMeshMRMInstance   *mi, uint remainingVertices, uint8 *vbDest);
    void            renderShadowSkinPrimitives(CMeshMRMInstance *mi, CMaterial &castMat, IDriver *drv, uint baseVertex);

    bool            supportIntersectSkin() const {return supportShadowSkinGrouping();}
    bool            intersectSkin(CMeshMRMInstance  *mi, const CMatrix &toRaySpace, float &dist2D, float &distZ, bool computeDist2D);

    // @}

// ************************
private:
    friend class    CMRMBuilder;



    class   CRdrPass
    {
    public:
        // The id of this material.
        uint32              MaterialId;
        // The list of primitives.
        CIndexBuffer        PBlock;
        // The same, precomputed for VBHeap Index Shifting
        CIndexBuffer        VBHeapPBlock;

        // Serialize a rdrpass.
        void    serial(NLMISC::IStream &f)
        {
            (void)f.serialVersion(0);

            f.serial(MaterialId);
            f.serial(PBlock);
        }
        CRdrPass()
        {
            NL_SET_IB_NAME(PBlock, "CMeshMRM::CRdrPass::PBlock");
            NL_SET_IB_NAME(VBHeapPBlock, "CMeshMRM::CRdrPass::VBHeapPBlock");
            PBlock.setFormat(NL_MESH_MRM_INDEX_FORMAT);
        }
    };


    struct  CVertexBlock
    {
        // The index of the start vertex.
        uint32  VertexStart;
        // Number of vertices.
        uint32  NVertices;

        void    serial(NLMISC::IStream &f)
        {
            f.serial(VertexStart, NVertices);
        }
    };



    class   CLod
    {
    public:
        uint32                      NWedges;
        std::vector<CMRMWedgeGeom>  Geomorphs;
        std::vector<CRdrPass>       RdrPass;

        std::vector<uint32>             InfluencedVertices[NL3D_MESH_SKINNING_MAX_MATRIX];
        std::vector<uint32>             MatrixInfluences;
        bool                        OriginalSkinRestored;
        std::vector<CVertexBlock>       SkinVertexBlocks;



        CLod()
        {
            // By default, this is supposed false.
            OriginalSkinRestored= false;
        }

        // Serialize a Lod.
        void        serial(NLMISC::IStream &f);

        // Used in CMeshMRMGeom::build().
        void        buildSkinVertexBlocks();
        void        optimizeTriangleOrder();
    };

    friend class    CLod;

    struct  CMeshBuildMRM
    {
        // This tells if the mesh is correctly skinned.
        bool                                Skinned;

        // This is the array of SkinWeights, same size as the VB.
        std::vector<CMesh::CSkinWeight>     SkinWeights;

        // This VB is computed with CMRMBuilder and is ready to used
        CVertexBuffer           VBuffer;

        // Lod array, computed with CMRMBuilder and ready to used
        std::vector<CLod>       Lods;

        // The blend shapes
        std::vector<CBlendShape>    BlendShapes;

        // @{
        float                   DistanceFinest;
        float                   DistanceMiddle;
        float                   DistanceCoarsest;
        // @}

    };


    class   CLodInfo
    {
    public:
        uint32      StartAddWedge;
        uint32      EndAddWedges;
        sint32      LodOffset;

        void    serial(NLMISC::IStream &f)
        {
            (void)f.serialVersion(0);

            f.serial(StartAddWedge);
            f.serial(EndAddWedges);
            // do not serial LodOffset here.
        }
    };



private:

    bool                        _Skinned;
    std::vector<CVector>        _OriginalSkinVertices;
    std::vector<CVector>        _OriginalSkinNormals;
    std::vector<CVector>        _OriginalTGSpace;

    CVertexBuffer               _VBufferOriginal;
    CVertexBuffer               _VBufferFinal;

    std::vector<CMesh::CSkinWeight>     _SkinWeights;

    bool                        _BoneIdComputed;
    bool                        _BoneIdExtended;

    bool                        _SupportSkinGrouping;

    uint8                       _LastLodComputed;

    std::vector<std::string>    _BonesName;
    std::vector<sint32>         _BonesId;
    std::vector<sint32>         _BonesIdExt;
    std::vector<NLMISC::CBSphere>   _BonesSphere;

    std::vector<CLod>           _Lods;
    NLMISC::CAABBoxExt          _BBox;


    std::vector<CLodInfo>       _LodInfos;
    uint                        _NbLodLoaded;


    // @{
    CMRMLevelDetail             _LevelDetail;
    // @}


    bool                        _PreciseClipping;

    // The Mesh Morpher
    CMeshMorpher                _MeshMorpher;

    // Possible MeshVertexProgram to apply at render()
    NLMISC::CSmartPtr<IMeshVertexProgram>   _MeshVertexProgram;

    // @{
    bool                            _SupportMeshBlockRendering;
    bool                            _MBRBkupNormalize;
    sint                            _MBRCurrentLodId;
    // @}


    // @{
    CShadowSkin                     _ShadowSkin;
    bool                            _SupportShadowSkinGrouping;
    // @}

private:
    void    serialLodVertexData(NLMISC::IStream &f, uint startWedge, uint endWedge);

    sint    chooseLod(float alphaMRM, float &alphaLod);

    void    applyGeomorph(std::vector<CMRMWedgeGeom>  &geoms, float alphaLod);

    void    applyGeomorphWithVBHardPtr(std::vector<CMRMWedgeGeom>  &geoms, float alphaLod, uint8 *vertexDestPtr);

    void    applyGeomorphPosNormalUV0(std::vector<CMRMWedgeGeom>  &geoms, uint8 *vertexPtr, uint8 *vertexDestPtr, sint32 vertexSize, float a, float a1);

    void    bkupOriginalSkinVertices();
    void    bkupOriginalSkinVerticesSubset(uint wedgeStart, uint wedgeEnd);
    void    restoreOriginalSkinVertices();

    void    applySkin(CLod &lod, const CSkeletonModel *skeleton);

    void    applySkinWithNormal(CLod &lod, const CSkeletonModel *skeleton);
    void    applyRawSkinWithNormal(CLod &lod, CRawSkinNormalCache &rawSkinLod, const CSkeletonModel *skeleton, uint8 *vbHard, float alphaLod);

    void    applySkinWithTangentSpace(CLod &lod, const CSkeletonModel *skeleton, uint tangentSpaceTexCoord);

    void    restoreOriginalSkinPart(CLod &lod);


    sint        loadHeader(NLMISC::IStream &f) throw(NLMISC::EStream);
    void        load(NLMISC::IStream &f) throw(NLMISC::EStream);
    void        save(NLMISC::IStream &f) throw(NLMISC::EStream);

    // Build bone Usage information for serialized mesh <= version 2.
    void        buildBoneUsageVer2 ();

    // Some runtime not serialized compilation
    void        compileRunTime();

    // SkinGroup
    void        updateShiftedTriangleCache(CMeshMRMInstance *mi, sint curLodId, uint baseVertex);

private:

    // @{

    uint        _MeshDataId;

    void        updateRawSkinNormal(bool enabled, CMeshMRMInstance *mi, sint curLodId);
    void        dirtMeshDataId();

    // ApplySkin method
    void        applyArrayRawSkinNormal1(CRawVertexNormalSkin1 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);
    void        applyArrayRawSkinNormal2(CRawVertexNormalSkin2 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);
    void        applyArrayRawSkinNormal3(CRawVertexNormalSkin3 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);
    void        applyArrayRawSkinNormal4(CRawVertexNormalSkin4 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);


public:
    static  uint    NumCacheVertexNormal1;
    static  uint    NumCacheVertexNormal2;
    static  uint    NumCacheVertexNormal3;
    static  uint    NumCacheVertexNormal4;

    // @}
};



// ***************************************************************************
class CMeshMRM : public CMeshBase
{
public:
    CMeshMRM();

    void            build ( CMeshBase::CMeshBaseBuild &mBase, CMesh::CMeshBuild &m,
                            std::vector<CMesh::CMeshBuild*> &listBS,
                            const CMRMParameters &params= CMRMParameters() );

    void            build (CMeshBase::CMeshBaseBuild &m, const CMeshMRMGeom &mgeom);

    void            optimizeMaterialUsage(std::vector<sint> &remap);


    void            computeBonesId (CSkeletonModel *skeleton);

    void            updateSkeletonUsage(CSkeletonModel *sm, bool increment);

    void            changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest);

    // @{

    virtual CTransformShape     *createInstance(CScene &scene);

    virtual bool    clip(const std::vector<CPlane>  &pyramid, const CMatrix &worldMatrix) ;

    virtual void    render(IDriver *drv, CTransformShape *trans, bool passOpaque);

    virtual float   getNumTriangles (float distance);

    virtual void    serial(NLMISC::IStream &f) throw(NLMISC::EStream);
    NLMISC_DECLARE_CLASS(CMeshMRM);

    virtual void    getAABBox(NLMISC::CAABBox &bbox) const {bbox= getBoundingBox().getAABBox();}

    virtual void    profileSceneRender(CRenderTrav *rdrTrav, CTransformShape *trans, bool opaquePass);

    virtual void    buildSystemGeometry();

    // @}


    // @{

    const NLMISC::CAABBoxExt& getBoundingBox() const
    {
        return _MeshMRMGeom.getBoundingBox();
    }

    const CVertexBuffer &getVertexBuffer() const { return _MeshMRMGeom.getVertexBuffer(); }


    uint getNbLod() const { return _MeshMRMGeom.getNbLod()  ; }


    uint getNbRdrPass(uint lodId) const { return _MeshMRMGeom.getNbRdrPass(lodId) ; }


    const CIndexBuffer &getRdrPassPrimitiveBlock(uint lodId, uint renderingPassIndex) const
    {
        return _MeshMRMGeom.getRdrPassPrimitiveBlock(lodId, renderingPassIndex) ;
    }


    uint32 getRdrPassMaterial(uint lodId, uint renderingPassIndex) const
    {
        return _MeshMRMGeom.getRdrPassMaterial(lodId, renderingPassIndex) ;
    }

    const CMeshMRMGeom& getMeshGeom () const;

    // @}


    // @{
    virtual IMeshGeom   *supportMeshBlockRendering (CTransformShape *trans, float &polygonCount ) const;
    // @}


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

    CMeshMRMGeom        _MeshMRMGeom;


};


} // NL3D


#endif // NL_MESH_MRM_H

/* End of mesh_mrm.h */