mesh_mrm_skinned.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_SKINNED_H
#define NL_MESH_MRM_SKINNED_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   CRawVertexNormalSkinned1;
class   CRawVertexNormalSkinned2;
class   CRawVertexNormalSkinned3;
class   CRawVertexNormalSkinned4;
class   CRawSkinnedNormalCache;
class   CMeshMRMSkinnedInstance;
class   CSkinSpecularRdrPass;

#define NL3D_MESH_MRM_SKINNED_WEIGHT_FACTOR     (255.f)
#define NL3D_MESH_MRM_SKINNED_UV_FACTOR         (8192.f)
#define NL3D_MESH_MRM_SKINNED_NORMAL_FACTOR     (32767.f)
#define NL3D_MESH_MRM_SKINNED_DEFAULT_POS_SCALE (8.f/32767.f)
#define NL3D_MESH_MRM_SKINNED_MAX_MATRIX        4
#define NL3D_MESH_MRM_SKINNED_VERTEX_FORMAT     (CVertexBuffer::PositionFlag|CVertexBuffer::NormalFlag|CVertexBuffer::TexCoord0Flag|CVertexBuffer::PaletteSkinFlag)

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

    void            build(CMesh::CMeshBuild &m, 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);
    NLMISC_DECLARE_CLASS(CMeshMRMSkinnedGeom);

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

    // @}


    // @{

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

    void getVertexBuffer(CVertexBuffer &output) const;

    void getSkinWeights (std::vector<CMesh::CSkinWeight> &skinWeights) const;


    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() ; }


    void getRdrPassPrimitiveBlock(uint lodId, uint renderingPassIndex, CIndexBuffer &block) const
    {
        _Lods[lodId].getRdrPassPrimitiveBlock(renderingPassIndex, block);
    }


    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;
    }

    // @}


    // @{

    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 { return false; }
    virtual uint    getNumRdrPassesForMesh() const { return 0; }
    virtual uint    getNumRdrPassesForInstance(CMeshBaseInstance * /* inst */) const { return 0; }
    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 */) {}

    // @}


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


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

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

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

    uint            getNumShadowSkinVertices() const;

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

    bool            supportIntersectSkin() const {return supportShadowSkinGrouping();}
    bool            intersectSkin(CMeshMRMSkinnedInstance   *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.
        std::vector<uint16> PBlock;

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

            f.serial(MaterialId);
            f.serialCont(PBlock);
        }

        // Get num triangle
        uint getNumTriangle () const
        {
            return PBlock.size()/3;
        }
    };


    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;



        CLod()
        {
        }

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

        // Used in CMeshMRMSkinnedGeom::build().
        void        optimizeTriangleOrder();

        // Get the primitive block
        void getRdrPassPrimitiveBlock (uint renderPass, CIndexBuffer &block) const;

        // Build the primitive block
        void buildPrimitiveBlock(uint renderPass, const CIndexBuffer &block);
    };

    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;
        // @}

    };



public:

    class CPackedVertexBuffer
    {
    public:
        struct CPackedVertex
        {
            sint16  X, Y, Z;
            sint16  Nx, Ny, Nz;
            sint16  U, V;
            uint8   Matrices[NL3D_MESH_MRM_SKINNED_MAX_MATRIX];
            uint8   Weights[NL3D_MESH_MRM_SKINNED_MAX_MATRIX];

            // Decompact it
            inline void getPos (CVector &dest, float factor) const
            {
                dest.x = (float)X * factor;
                dest.y = (float)Y * factor;
                dest.z = (float)Z * factor;
            }
            inline void getNormal (CVector &dest) const
            {
                dest.x = (float)Nx * (1.f/NL3D_MESH_MRM_SKINNED_NORMAL_FACTOR);
                dest.y = (float)Ny * (1.f/NL3D_MESH_MRM_SKINNED_NORMAL_FACTOR);
                dest.z = (float)Nz * (1.f/NL3D_MESH_MRM_SKINNED_NORMAL_FACTOR);
            }
            inline void getU (float &_u) const
            {
                _u = (float)U * (1.f/NL3D_MESH_MRM_SKINNED_UV_FACTOR);
            }
            inline void getV (float &_v) const
            {
                _v = (float)V * (1.f/NL3D_MESH_MRM_SKINNED_UV_FACTOR);
            }
            inline void getWeight (float &dest, uint index) const
            {
                dest = (float)Weights[index] * (1.f/NL3D_MESH_MRM_SKINNED_WEIGHT_FACTOR);
            }

            // Compact it
            void setNormal (const CVector &pos);
            void setUV (float _u, float _v);
            void setWeight (uint weightId, float weight);
            void setPos (const CVector &pos, float scaleFactor);

            // Serial it
            void serial(NLMISC::IStream &f);
        };

        // Build it
        void build (const CVertexBuffer &buffer, const std::vector<CMesh::CSkinWeight> &skinWeight);

        // Clear it
        void clear ()
        {
            _PackedBuffer.clear();
        }

        // Reset
        void contReset()
        {
            NLMISC::contReset (_PackedBuffer);
        }

        // Access it
        const CPackedVertex *getPackedVertices() const
        {
            if (_PackedBuffer.empty())
                return NULL;
            else
                return &(_PackedBuffer[0]);
        }

        // Access it
        CPackedVertex   *getPackedVertices()
        {
            if (_PackedBuffer.empty())
                return NULL;
            else
                return &(_PackedBuffer[0]);
        }

        // Acces it
        uint getNumVertices() const
        {
            return _PackedBuffer.size();
        }

        // Decompact position
        inline void getPos (CVector &dest, const CPackedVertex &src) const
        {
            src.getPos (dest, _DecompactScale);
        }

        // Serialize it
        void serial(NLMISC::IStream &f);

    private:
        float                       _DecompactScale;

        //
        std::vector<CPackedVertex>  _PackedBuffer;
    };

private:

    // The packed vertex buffer
    CPackedVertexBuffer         _VBufferFinal;

    bool                        _BoneIdComputed;
    bool                        _BoneIdExtended;

    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;


    // @{
    CMRMLevelDetail             _LevelDetail;
    // @}


    // @{

    bool                        _PreciseClipping;

    // @}

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

private:

    sint    chooseLod(float alphaMRM, float &alphaLod);

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

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

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

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

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

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

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

private:

    // @{

    uint        _MeshDataId;

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

    // ApplySkin method
    void        applyArrayRawSkinNormal1(CRawVertexNormalSkinned1 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);
    void        applyArrayRawSkinNormal2(CRawVertexNormalSkinned2 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);
    void        applyArrayRawSkinNormal3(CRawVertexNormalSkinned3 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);
    void        applyArrayRawSkinNormal4(CRawVertexNormalSkinned4 *src, uint8 *destVertexPtr,
        CMatrix3x4 *boneMat3x4, uint nInf);


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

    // @}
};



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

    static bool     isCompatible(const CMesh::CMeshBuild &m);

    void            build ( CMeshBase::CMeshBaseBuild &mBase, CMesh::CMeshBuild &m,
                            const CMRMParameters &params= CMRMParameters() );

    void            build (CMeshBase::CMeshBaseBuild &m, const CMeshMRMSkinnedGeom &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);
    NLMISC_DECLARE_CLASS(CMeshMRMSkinned);

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

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

    // @}


    // @{

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

    void getVertexBuffer(CVertexBuffer &output) const { _MeshMRMGeom.getVertexBuffer(output); }


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


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


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


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

    const CMeshMRMSkinnedGeom& getMeshGeom () const;

    // @}


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


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

    CMeshMRMSkinnedGeom     _MeshMRMGeom;


};


} // NL3D


#endif // NL_MESH_MRM_SKINNED_H

/* End of mesh_mrm_skinned.h */