Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   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 "3d/shape.h" #include "3d/driver.h" #include "nel/misc/aabbox.h" #include "nel/misc/uv.h" #include "3d/vertex_buffer.h" #include "3d/material.h" #include "3d/primitive_block.h" #include "3d/animated_material.h" #include "3d/mesh_base.h" #include "3d/mesh.h" #include "3d/mrm_mesh.h" #include "3d/mrm_parameters.h" #include "3d/bone.h" #include "3d/mesh_geom.h" #include "3d/mrm_level_detail.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 CMatrix3x4SSE; class CRawVertexNormalSkin1; class CRawVertexNormalSkin2; class CRawVertexNormalSkin4; class CRawSkinNormalCache; class CMeshMRMInstance; // *************************************************************************** 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); // @} // @{ 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 CPrimitiveBlock &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; } // @} // @{ bool isSkinned () const { return _Skinned; } void computeBonesId (CSkeletonModel *skeleton); void updateSkeletonUsage(CSkeletonModel *sm, bool increment); const std::vector<sint32> &getSkinBoneUsage() const {return _BonesId;} // @} // @{ virtual bool supportMeshBlockRendering () const; virtual bool sortPerMaterial() const; virtual uint getNumRdrPasses() const ; virtual void beginMesh(CMeshGeomRenderContext &rdrCtx) ; virtual void activeInstance(CMeshGeomRenderContext &rdrCtx, CMeshBaseInstance *inst, float polygonCount) ; 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(CMeshMRMInstance *mi, float alphaMRM, uint remainingVertices, uint8 *vbDest); void renderSkinGroupPrimitives(CMeshMRMInstance *mi, uint baseVertex); // @} // ************************ private: friend class CMRMBuilder; class CRdrPass { public: // The id of this material. uint32 MaterialId; // The list of primitives. CPrimitiveBlock PBlock; // Serialize a rdrpass. void serial(NLMISC::IStream &f) { (void)f.serialVersion(0); f.serial(MaterialId); f.serial(PBlock); } }; 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<CLod> _Lods; NLMISC::CAABBoxExt _BBox; std::vector<CLodInfo> _LodInfos; uint _NbLodLoaded; // @{ CMRMLevelDetail _LevelDetail; // @} // @{ CRefPtr<IVertexBufferHard> _VBHard; // a refPtr on the driver, to delete VBuffer Hard at clear(). CRefPtr<IDriver> _Driver; bool _VertexBufferHardDirty; bool _PreciseClipping; /* try to create a vertexBufferHard. NB: enlarge capacity of the VBHard as necessary. After this call, the vertexBufferHard may be NULL. */ void updateVertexBufferHard(IDriver *drv, uint32 numVertices); void deleteVertexBufferHard(); // Fill skin in AGP, with a direct ptr onto AGP void fillAGPSkinPartWithVBHardPtr(CLod &lod, uint8 *vertexDst); // @} // The Mesh Morpher CMeshMorpher _MeshMorpher; // Possible MeshVertexProgram to apply at render() NLMISC::CSmartPtr<IMeshVertexProgram> _MeshVertexProgram; private: void serialLodVertexData(NLMISC::IStream &f, uint startWedge, uint endWedge); sint chooseLod(float alphaMRM, float &alphaLod); void applyGeomorph(std::vector<CMRMWedgeGeom> &geoms, float alphaLod, IVertexBufferHard *currentVBHard); 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 applySkinWithNormalSSE(CLod &lod, const CSkeletonModel *skeleton); void applyRawSkinWithNormal(CLod &lod, CRawSkinNormalCache &rawSkinLod, const CSkeletonModel *skeleton); void applyRawSkinWithNormalSSE(CLod &lod, CRawSkinNormalCache &rawSkinLod, const CSkeletonModel *skeleton); void applySkinWithTangentSpace(CLod &lod, const CSkeletonModel *skeleton, uint tangentSpaceTexCoord); void applySkinWithTangentSpaceSSE(CLod &lod, const CSkeletonModel *skeleton, uint tangentSpaceTexCoord); void restoreOriginalSkinPart(CLod &lod, IVertexBufferHard *currentVBHard); 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 vertexSize, uint nInf); void applyArrayRawSkinNormal2(CRawVertexNormalSkin2 *src, uint8 *destVertexPtr, CMatrix3x4 *boneMat3x4, uint vertexSize, uint nInf); void applyArrayRawSkinNormal3(CRawVertexNormalSkin4 *src, uint8 *destVertexPtr, CMatrix3x4 *boneMat3x4, uint vertexSize, uint nInf); void applyArrayRawSkinNormal4(CRawVertexNormalSkin4 *src, uint8 *destVertexPtr, CMatrix3x4 *boneMat3x4, uint vertexSize, uint nInf); // Same for SSE void applyArrayRawSkinNormal1(CRawVertexNormalSkin1 *src, uint8 *destVertexPtr, CMatrix3x4SSE *boneMat3x4, uint vertexSize, uint nInf); void applyArrayRawSkinNormal2(CRawVertexNormalSkin2 *src, uint8 *destVertexPtr, CMatrix3x4SSE *boneMat3x4, uint vertexSize, uint nInf); void applyArrayRawSkinNormal3(CRawVertexNormalSkin4 *src, uint8 *destVertexPtr, CMatrix3x4SSE *boneMat3x4, uint vertexSize, uint nInf); void applyArrayRawSkinNormal4(CRawVertexNormalSkin4 *src, uint8 *destVertexPtr, CMatrix3x4SSE *boneMat3x4, uint vertexSize, uint nInf); public: static uint NumCacheVertexNormal1; static uint NumCacheVertexNormal2; 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();} // @} // @{ 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 CPrimitiveBlock &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; // @} // ************************ private: CMeshMRMGeom _MeshMRMGeom; }; } // NL3D #endif // NL_MESH_MRM_H /* End of mesh_mrm.h */