NL3D::CMeshGeom Class Reference

#include <mesh.h>

Inheritance diagram for NL3D::CMeshGeom:

---

Detailed Description

A mesh geometry. Skinning support: support only palette skinning.

Author:

Lionel Berenguier

Nevrax France

Date:

2000

Definition at line 335 of file mesh.h.

Mesh Block Render Implementation
enum	TMBRSupport { MBROk = 1, MBRSortPerMaterial = 2, MBRCurrentUseVP = 4 }
	setuped at compileRunTime. More...
uint8	_SupportMBRFlags
	setuped at compileRunTime.
Skinning
enum	TSkinType { SkinPosOnly = 0, SkinWithNormal, SkinWithTgSpace }
void	applySkin (CSkeletonModel *skeleton)
void	bkupOriginalSkinVertices ()
void	buildBoneUsageVer3 ()
void	buildSkin (CMesh::CMeshBuild &m, std::vector< CFaceTmp > &tmpFaces)
void	computeSkinMatrixes (CSkeletonModel *skeleton, CMatrix3x4 *matrixes, CMatrixBlock *prevBlock, CMatrixBlock &curBlock)
void	computeSoftwarePointSkinning (CMatrix3x4 *matrixes, CVector *srcVector, CPaletteSkin *srcPal, float *srcWgt, CVector *dstVector)
void	computeSoftwareVectorSkinning (CMatrix3x4 *matrixes, CVector *srcVector, CPaletteSkin *srcPal, float *srcWgt, CVector *dstVector)
void	flagSkinVerticesForMatrixBlock (uint8 *skinFlags, CMatrixBlock &mb)
void	restoreOriginalSkinVertices ()
VBufferHard mgt.
void	updateVertexBufferHard (IDriver *drv)
	update the VertexBufferHard if NULL (ie not created or deleted by driver) or if VertexBufferDirty.
CRefPtr< IDriver >	_Driver
	This is the driver used to setup the vbuffer hard. error if a mesh has not the same driver in his life.
CRefPtr< IVertexBufferHard >	_VertexBufferHard
	The only one VBufferHard of the mesh. NULL by default.
bool	_VertexBufferHardDirty
	This tells if the VBuffer has changed since the last time or not.
Public Types
enum	TRenderFlag {   RenderOpaqueMaterial = 1, RenderTransparentMaterial = 2, RenderPassOpaque = 4, RenderGlobalAlpha = 8,   RenderGADisableZWrite = 16 }
	Render Flags, used in render. More...
Public Member Functions
void	applyMaterialRemap (const std::vector< sint > &remap)
	change materials Ids (called from CMesh::optimizeMaterialUsage())
void	build (CMesh::CMeshBuild &mbuild, uint numMaxMaterial)
	Build a meshGeom.
	CMeshGeom ()
	Constructor.
virtual std::string	getClassName ()=0
virtual bool	hasMeshVertexProgram () const
	True if this mesh has a vertexProgram.
void	renderSimpleWithMaterial (IDriver *drv, const CMatrix &worldMatrix, CMaterial &mat)
void	setBlendShapes (std::vector< CBlendShape > &bs)
virtual	~CMeshGeom ()
Mesh Block Render Implementation
virtual void	activeInstance (CMeshGeomRenderContext &rdrCtx, CMeshBaseInstance *inst, float polygonCount, void *vbDst)
virtual void	beginMesh (CMeshGeomRenderContext &rdrCtx)
virtual void	computeMeshVBHeap (void *dst, uint indexStart)
virtual void	endMesh (CMeshGeomRenderContext &rdrCtx)
virtual uint	getNumRdrPassesForInstance (CMeshBaseInstance *inst) const
virtual uint	getNumRdrPassesForMesh () const
virtual bool	getVBHeapInfo (uint &vertexFormat, uint &numVertices)
virtual void	renderPass (CMeshGeomRenderContext &rdrCtx, CMeshBaseInstance *inst, float polygonCount, uint rdrPass)
virtual bool	sortPerMaterial () const
virtual bool	supportMeshBlockRendering () const
From IMeshGeom
virtual bool	clip (const std::vector< CPlane > &pyramid, const CMatrix &worldMatrix)
	clip this mesh
virtual float	getNumTriangles (float distance)
	clip this mesh
virtual void	initInstance (CMeshBaseInstance *mbi)
	Init instance info.
	NLMISC_DECLARE_CLASS (CMeshGeom)
	clip this mesh
virtual void	profileSceneRender (CRenderTrav *rdrTrav, CTransformShape *trans, float polygonCount, uint32 rdrFlags)
	clip this mesh
virtual void	render (IDriver *drv, CTransformShape *trans, float polygonCount, uint32 rdrFlags, float globalAlpha)
	render() this mesh in a driver.
virtual void	renderSkin (CTransformShape *trans, float alphaMRM)
	render() this mesh as a skin
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
	serial this mesh.
Skinning Behavior
void	computeBonesId (CSkeletonModel *skeleton)
	Compute skinning id.
const std::vector< sint32 > &	getSkinBoneUsage () const
	return array of bones used by the skin. computeBonesId must has been called before.
bool	isSkinned () const
	Return true if the mesh is skinned, else return false.
void	updateSkeletonUsage (CSkeletonModel *sm, bool increment)
	update Skeleton Usage. increment or decrement. computeBonesId must has been called before.
Geometry accessors
const NLMISC::CAABBoxExt &	getBoundingBox () const
	get the extended axis aligned bounding box of the mesh
uint	getNbBlendShapes () const
	get the number of BlendShapes
uint	getNbMatrixBlock () const
	get the number of matrix block
uint	getNbRdrPass (uint matrixBlockIndex) const
uint32	getRdrPassMaterial (uint matrixBlockIndex, uint renderingPassIndex) const
const CPrimitiveBlock &	getRdrPassPrimitiveBlock (uint matrixBlockIndex, uint renderingPassIndex) const
const CVertexBuffer &	getVertexBuffer () const
	get the vertex buffer used by the mesh
Private Types
typedef TBoneMap::iterator	ItBoneMap
typedef TCornerSet::iterator	ItCornerSet
typedef std::map< uint, CBoneTmp >	TBoneMap
typedef std::set< CCornerTmp *, CCornerPred >	TCornerSet
Private Member Functions
void	compileRunTime ()
void	findVBId (TCornerSet &corners, const CCornerTmp *corn, sint &currentVBIndex, const CVector &vert, const CMesh::CMeshBuild &mb)
void	optimizeTriangleOrder ()
Private Attributes
NLMISC::CAABBoxExt	_BBox
	For clipping.
bool	_BoneIdComputed
	This boolean is true if the bones id have been passed in the skeleton.
bool	_BoneIdExtended
	true if the _BonesIdExt have been computed (for bone Usage).
std::vector< sint32 >	_BonesId
	This array give the index in the skeleton of the local bones used. computed at first computeBoneId().
std::vector< sint32 >	_BonesIdExt
	Same as _BonesId but with parent of bones added. (used for bone usage).
std::vector< std::string >	_BonesName
	This array give the name of the local bones used.
std::vector< CMatrixBlock >	_MatrixBlocks
	The matrix blocks.
CMeshMorpher *	_MeshMorpher
NLMISC::CSmartPtr< IMeshVertexProgram >	_MeshVertexProgram
std::vector< CVector >	_OriginalSkinNormals
bool	_OriginalSkinRestored
	This tells if the mesh VBuffer has coorect BindPos vertices.
std::vector< CVector >	_OriginalSkinVertices
std::vector< CVector >	_OriginalTGSpace
bool	_PreciseClipping
	Estimate if we must do a Precise clipping (ie with bboxes).
bool	_Skinned
	This tells if the mesh is correctly skinned.
CVertexBuffer	_VBuffer
	VBuffer of the mesh (potentially modified by the mesh morpher and skinning).
CVertexBuffer	_VBufferOri
	The original VBuffer of the mesh used only if there are blend shapes.

---

Member Typedef Documentation

typedef TBoneMap::iterator NL3D::CMeshGeom::ItBoneMap [private]

Definition at line 606 of file mesh.h. Referenced by buildSkin().

typedef TCornerSet::iterator NL3D::CMeshGeom::ItCornerSet [private]

Definition at line 730 of file mesh.h. Referenced by findVBId().

typedef std::map<uint, CBoneTmp> NL3D::CMeshGeom::TBoneMap [private]

Just for build process. A map of Bone. Definition at line 605 of file mesh.h. Referenced by buildSkin().

typedef std::set<CCornerTmp*, CCornerPred> NL3D::CMeshGeom::TCornerSet [private]

Definition at line 729 of file mesh.h. Referenced by build(), and findVBId().

---

Member Enumeration Documentation

enum NL3D::CMeshGeom::TMBRSupport [private]

setuped at compileRunTime. Enumeration values: MBROk  MBRSortPerMaterial  MBRCurrentUseVP  Definition at line 698 of file mesh.h. { MBROk= 1, MBRSortPerMaterial= 2, MBRCurrentUseVP= 4, };

enum NL3D::IMeshGeom::TRenderFlag [inherited]

Render Flags, used in render. Enumeration values: RenderOpaqueMaterial  RenderTransparentMaterial  RenderPassOpaque  RenderGlobalAlpha  RenderGADisableZWrite  Definition at line 82 of file mesh_geom.h. { RenderOpaqueMaterial= 1, // set when the mesh geom must render opaque material RenderTransparentMaterial= 2, // set when the mesh geom must render transparent material RenderPassOpaque=4, // set when the current traversal rdrPass is the opaque pass RenderGlobalAlpha= 8, // set when the caller wants to draw material with global alpha RenderGADisableZWrite= 16, // only when globalAlpha is used. set if must disable ZWrite };

enum NL3D::CMeshGeom::TSkinType [private]

Enumeration values: SkinPosOnly  SkinWithNormal  SkinWithTgSpace  Definition at line 799 of file mesh.h. Referenced by applySkin(). {SkinPosOnly=0, SkinWithNormal, SkinWithTgSpace};

---

Constructor & Destructor Documentation

NL3D::CMeshGeom::CMeshGeom (   )

Constructor. Definition at line 123 of file mesh.cpp. References _BoneIdComputed, _BoneIdExtended, _MeshMorpher, _OriginalSkinRestored, _PreciseClipping, _Skinned, and _VertexBufferHardDirty. { _Skinned= false; _OriginalSkinRestored= true; _VertexBufferHardDirty= true; _MeshMorpher = new CMeshMorpher; _BoneIdComputed = false; _BoneIdExtended= false; _PreciseClipping= false; }

NL3D::CMeshGeom::~CMeshGeom (   )  [virtual]

Definition at line 136 of file mesh.cpp. References _MeshMorpher, _VertexBufferHard, and nlassert. { // test (refptr) if the object still exist in memory. if(_VertexBufferHard!=NULL) { // A vbufferhard should still exist only if driver still exist. nlassert(_Driver!=NULL); // delete it from driver. _Driver->deleteVertexBufferHard(_VertexBufferHard); _VertexBufferHard= NULL; } delete _MeshMorpher; }

---

Member Function Documentation

void NL3D::CMeshGeom::activeInstance (  CMeshGeomRenderContext &  rdrCtx, CMeshBaseInstance *  inst, float  polygonCount, void *  vbDst )  [virtual]

The framework call this method any time a change of instance occurs. Implements NL3D::IMeshGeom. Definition at line 2058 of file mesh.cpp. References _MeshVertexProgram, _SupportMBRFlags, NL3D::CTransformShape::changeLightSetup(), NL3D::CMeshGeomRenderContext::Driver, NL3D::CTransform::getWorldMatrix(), NLMISC::CMatrix::inverted(), MBRCurrentUseVP, NL3D::CMeshGeomRenderContext::RenderTrav, NL3D::CMeshGeomRenderContext::Scene, and NL3D::IDriver::setupModelMatrix(). { // setup instance matrix rdrCtx.Driver->setupModelMatrix(inst->getWorldMatrix()); // setupLighting. inst->changeLightSetup(rdrCtx.RenderTrav); // MeshVertexProgram ? if( _SupportMBRFlags & MBRCurrentUseVP ) { CMatrix invertedObjectMatrix; invertedObjectMatrix = inst->getWorldMatrix().inverted(); _MeshVertexProgram->beginMBRInstance(rdrCtx.Driver, rdrCtx.Scene, inst, invertedObjectMatrix); } }

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

change materials Ids (called from CMesh::optimizeMaterialUsage()) Definition at line 458 of file mesh.cpp. References _MatrixBlocks, getNbMatrixBlock(), getNbRdrPass(), nlassert, uint, and uint32. Referenced by NL3D::CMesh::optimizeMaterialUsage(). { for(uint mb=0;mb<getNbMatrixBlock();mb++) { for(uint rp=0;rp<getNbRdrPass(mb);rp++) { // remap uint32 &matId= _MatrixBlocks[mb].RdrPass[rp].MaterialId; nlassert(remap[matId]>=0); matId= remap[matId]; } } }

void NL3D::CMeshGeom::applySkin (  CSkeletonModel *  skeleton  )  [private]

Definition at line 1715 of file mesh.cpp. References _MatrixBlocks, _OriginalSkinNormals, _OriginalSkinRestored, _OriginalSkinVertices, _OriginalTGSpace, computeSkinMatrixes(), computeSoftwarePointSkinning(), computeSoftwareVectorSkinning(), flagSkinVerticesForMatrixBlock(), NL3D::CVertexBuffer::getNormalCoordPointer(), NL3D::CVertexBuffer::getNumTexCoordUsed(), NL3D::CVertexBuffer::getPaletteSkinPointer(), NL3D::CVertexBuffer::getTexCoordPointer(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexSize(), NL3D::CVertexBuffer::getWeightPointer(), NL3D::CPaletteSkin::MatrixId, NL3D_SOFTSKIN_VCOMPUTED, NL3D_SOFTSKIN_VMUSTCOMPUTE, NL3D_SOFTSKIN_VNEEDCOMPUTE, nlassert, size, SkinPosOnly, SkinWithNormal, SkinWithTgSpace, TSkinType, uint, and uint8. Referenced by renderSkin(). { // init. //=================== if(_OriginalSkinVertices.empty()) return; // Use correct skinning TSkinType skinType; if( _OriginalSkinNormals.empty() ) skinType= SkinPosOnly; else if( _OriginalTGSpace.empty() ) skinType= SkinWithNormal; else skinType= SkinWithTgSpace; // Get VB src/dst info/ptrs. uint numVertices= _OriginalSkinVertices.size(); uint dstStride= _VBuffer.getVertexSize(); // Get dst TgSpace. uint tgSpaceStage = 0; if( skinType>= SkinWithTgSpace) { nlassert(_VBuffer.getNumTexCoordUsed() > 0); tgSpaceStage= _VBuffer.getNumTexCoordUsed() - 1; } // Mark all vertices flag to not computed. static vector<uint8> skinFlags; skinFlags.resize(numVertices); // reset all flags memset(&skinFlags[0], NL3D_SOFTSKIN_VNEEDCOMPUTE, numVertices ); // For all MatrixBlocks //=================== for(uint mb= 0; mb<_MatrixBlocks.size();mb++) { // compute matrixes for this block. static CMatrix3x4 matrixes[IDriver::MaxModelMatrix]; computeSkinMatrixes(skeleton, matrixes, mb==0?NULL:&_MatrixBlocks[mb-1], _MatrixBlocks[mb]); // check what vertex to skin for this PB. flagSkinVerticesForMatrixBlock(&skinFlags[0], _MatrixBlocks[mb]); // Get VB src/dst ptrs. uint8 *pFlag= &skinFlags[0]; CVector *srcVector= &_OriginalSkinVertices[0]; uint8 *srcPal= (uint8*)_VBuffer.getPaletteSkinPointer(0); uint8 *srcWgt= (uint8*)_VBuffer.getWeightPointer(0); uint8 *dstVector= (uint8*)_VBuffer.getVertexCoordPointer(0); // Normal. CVector *srcNormal= NULL; uint8 *dstNormal= NULL; if(skinType>=SkinWithNormal) { srcNormal= &_OriginalSkinNormals[0]; dstNormal= (uint8*)_VBuffer.getNormalCoordPointer(0); } // TgSpace. CVector *srcTgSpace= NULL; uint8 *dstTgSpace= NULL; if(skinType>=SkinWithTgSpace) { srcTgSpace= &_OriginalTGSpace[0]; dstTgSpace= (uint8*)_VBuffer.getTexCoordPointer(0, tgSpaceStage); } // For all vertices that need to be computed. uint size= numVertices; for(;size>0;size--) { // If we must compute this vertex. if(*pFlag==NL3D_SOFTSKIN_VMUSTCOMPUTE) { // Flag this vertex as computed. *pFlag=NL3D_SOFTSKIN_VCOMPUTED; CPaletteSkin *psPal= (CPaletteSkin*)srcPal; // checks indices. nlassert(psPal->MatrixId[0]<IDriver::MaxModelMatrix); nlassert(psPal->MatrixId[1]<IDriver::MaxModelMatrix); nlassert(psPal->MatrixId[2]<IDriver::MaxModelMatrix); nlassert(psPal->MatrixId[3]<IDriver::MaxModelMatrix); // compute vertex part. computeSoftwarePointSkinning(matrixes, srcVector, psPal, (float*)srcWgt, (CVector*)dstVector); // compute normal part. if(skinType>=SkinWithNormal) computeSoftwareVectorSkinning(matrixes, srcNormal, psPal, (float*)srcWgt, (CVector*)dstNormal); // compute tg part. if(skinType>=SkinWithTgSpace) computeSoftwareVectorSkinning(matrixes, srcTgSpace, psPal, (float*)srcWgt, (CVector*)dstTgSpace); } // inc flags. pFlag++; // inc src (all whatever skin type used...) srcVector++; srcNormal++; srcTgSpace++; // inc paletteSkin and dst (all whatever skin type used...) srcPal+= dstStride; srcWgt+= dstStride; dstVector+= dstStride; dstNormal+= dstStride; dstTgSpace+= dstStride; } } // dirt _OriginalSkinRestored= false; }

void NL3D::CMeshGeom::beginMesh (  CMeshGeomRenderContext &  rdrCtx  )  [virtual]

The framework call this method when he will render instances of this meshGeom soon. Implements NL3D::IMeshGeom. Definition at line 2021 of file mesh.cpp. References _MeshVertexProgram, _SupportMBRFlags, _VertexBufferHard, NL3D::IDriver::activeVertexBuffer(), NL3D::IDriver::activeVertexBufferHard(), NL3D::CMeshGeomRenderContext::Driver, MBRCurrentUseVP, nlassert, NL3D::CMeshGeomRenderContext::RenderThroughVBHeap, NL3D::CMeshGeomRenderContext::Scene, and updateVertexBufferHard(). { if(rdrCtx.RenderThroughVBHeap) { // Don't setup VB in this case, since use the VBHeap setuped one. // NB: no VertexProgram test since VBHeap not possible with it... nlassert( (_SupportMBRFlags & MBRCurrentUseVP)==0 ); } else { // update the VBufferHard (create/delete), to maybe render in AGP memory. updateVertexBufferHard ( rdrCtx.Driver ); // use MeshVertexProgram effect? if( _MeshVertexProgram != NULL && _MeshVertexProgram->isMBRVpOk(rdrCtx.Driver) ) { // Ok will use it. _SupportMBRFlags|= MBRCurrentUseVP; // Before VB activation _MeshVertexProgram->beginMBRMesh(rdrCtx.Driver, rdrCtx.Scene ); } // if VB Hard is here, use it. if(_VertexBufferHard != NULL) { // active VB Hard. rdrCtx.Driver->activeVertexBufferHard(_VertexBufferHard); } else { // active VB. SoftwareSkinning: reset flags for skinning. rdrCtx.Driver->activeVertexBuffer(_VBuffer); } } }

void NL3D::CMeshGeom::bkupOriginalSkinVertices (   )  [private]

Definition at line 1615 of file mesh.cpp. References _MeshVertexProgram, _OriginalSkinNormals, _OriginalSkinVertices, _OriginalTGSpace, _Skinned, NL3D::CVertexBuffer::getNormalCoordPointer(), NL3D::CVertexBuffer::getNumTexCoordUsed(), NL3D::CVertexBuffer::getNumVertices(), NL3D::CVertexBuffer::getTexCoordPointer(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexFormat(), nlassert, and uint. Referenced by compileRunTime(). { nlassert(_Skinned); // reset contReset(_OriginalSkinVertices); contReset(_OriginalSkinNormals); contReset(_OriginalTGSpace); // get num of vertices uint numVertices= _VBuffer.getNumVertices(); // Copy VBuffer content into Original vertices normals. if(_VBuffer.getVertexFormat() & CVertexBuffer::PositionFlag) { // copy vertices from VBuffer. (NB: unusefull geomorphed vertices are still copied, but doesn't matter). _OriginalSkinVertices.resize(numVertices); for(uint i=0; i<numVertices;i++) { _OriginalSkinVertices[i]= *(CVector*)_VBuffer.getVertexCoordPointer(i); } } if(_VBuffer.getVertexFormat() & CVertexBuffer::NormalFlag) { // copy normals from VBuffer. (NB: unusefull geomorphed normals are still copied, but doesn't matter). _OriginalSkinNormals.resize(numVertices); for(uint i=0; i<numVertices;i++) { _OriginalSkinNormals[i]= *(CVector*)_VBuffer.getNormalCoordPointer(i); } } // is there tangent space added ? if (_MeshVertexProgram && _MeshVertexProgram->needTangentSpace()) { // yes, backup it nlassert(_VBuffer.getNumTexCoordUsed() > 0); uint tgSpaceStage = _VBuffer.getNumTexCoordUsed() - 1; _OriginalTGSpace.resize(numVertices); for(uint i=0; i<numVertices;i++) { _OriginalTGSpace[i]= *(CVector*)_VBuffer.getTexCoordPointer(i, tgSpaceStage); } } }

void NL3D::CMeshGeom::build (  CMesh::CMeshBuild &  m, uint  numMaxMaterial )

Build a meshGeom. 0. First, make bbox. 1. If skinning, group by matrix Block the vertices. 2. Then, for all faces, resolve continuities, building VBuffer. 3. build the RdrPass material. 4. Then, for all faces, build the RdrPass PBlock. 5. Remove empty RdrPasses. 6. Misc. 7. Compact bones id and build bones name array. If all texture coordinates are of dimension 2, we can setup the flags as before. If this isn't the case, we must setup a custom format Todo: yoyo: TODO_OPTIMIZE: it should be interesting to sort the materials, depending on their attributes. But must change next loop too... Definition at line 172 of file mesh.cpp. References _BoneIdComputed, _BoneIdExtended, _BonesName, _MatrixBlocks, _MeshMorpher, _MeshVertexProgram, _Skinned, _VertexBufferHardDirty, NL3D::CVertexBuffer::addValueEx(), NL3D::CMesh::CMeshBuild::BlendShapes, NL3D::CMeshMorpher::BlendShapes, NL3D::CMesh::CMeshBuild::BonesNames, buildSkin(), NL3D::CVertexBuffer::clearValueEx(), compileRunTime(), NL3D::CMeshGeom::CFaceTmp::Corner, NL3D::CMesh::CMeshBuild::Faces, findVBId(), NL3D::CVertexBuffer::initEx(), NL3D::makeBBox(), NL3D::CMeshGeom::CFaceTmp::MaterialId, matrix, NL3D::CMeshGeom::CFaceTmp::MatrixBlockId, NL3D::CMeshGeom::CMatrixBlock::MatrixId, NL3D::CMesh::CMeshBuild::MeshVertexProgram, nlassert, NL3D::CMesh::CMeshBuild::NumCoords, NL3D::CMeshGeom::CMatrixBlock::NumMatrix, optimizeTriangleOrder(), NL3D::CVertexBuffer::reserve(), NLMISC::CAABBoxExt::setCenter(), NL3D::CVertexBuffer::setNumVertices(), NLMISC::CAABBoxExt::setSize(), NL3D::CVertexBuffer::setUVRouting(), NL3D::CVertexBuffer::setVertexFormat(), sint, NL3D::CMesh::CMeshBuild::SkinWeights, TCornerSet, uint, uint32, NL3D::CMesh::CMeshBuild::UVRouting, NL3D::CMeshGeom::CCornerTmp::VBId, NL3D::CMesh::CCorner::Vertex, NL3D::CMesh::CMeshBuild::VertexFlags, NL3D::CMesh::CMeshBuild::Vertices, and NL3D::CMesh::CMeshBuild::VertLink. Referenced by NL3D::CMesh::build(). { sint i; // Dirt the VBuffer. _VertexBufferHardDirty= true; // Empty geometry? if(m.Vertices.size()==0 || m.Faces.size()==0) { _VBuffer.setNumVertices(0); _VBuffer.reserve(0); _MatrixBlocks.clear(); _BBox.setCenter(CVector::Null); _BBox.setSize(CVector::Null); return; } nlassert(numMaxMaterial>0); // Copy the UV routing table for (i=0; i<CVertexBuffer::MaxStage; i++) _VBuffer.setUVRouting (i, m.UVRouting[i]); //====================== _BBox= makeBBox(m.Vertices); //================================================ // First, copy Face array. vector<CFaceTmp> tmpFaces; tmpFaces.resize(m.Faces.size()); for(i=0;i<(sint)tmpFaces.size();i++) tmpFaces[i]= m.Faces[i]; _Skinned= ((m.VertexFlags & CVertexBuffer::PaletteSkinFlag)==CVertexBuffer::PaletteSkinFlag); // Skinning is OK only if SkinWeights are of same size as vertices. _Skinned= _Skinned && (m.Vertices.size()==m.SkinWeights.size()); // If skinning is KO, remove the Skin option. uint vbFlags= m.VertexFlags; if(!_Skinned) vbFlags&= ~CVertexBuffer::PaletteSkinFlag; // Force presence of vertex. vbFlags|= CVertexBuffer::PositionFlag; // If the mesh is not skinned, we have just 1 _MatrixBlocks. if(!_Skinned) { _MatrixBlocks.resize(1); // For each faces, assign it to the matrix block 0. for(i=0;i<(sint)tmpFaces.size();i++) tmpFaces[i].MatrixBlockId= 0; } // Else We must group/compute the matrixs blocks. else { // reset matrix blocks. _MatrixBlocks.clear(); // build matrix blocks, and link faces to good matrix blocks. buildSkin(m, tmpFaces); } //================================================ // Setup VB. _VBuffer.setNumVertices(0); _VBuffer.reserve(0); bool useFormatExt = false; for (uint k = 0; k < CVertexBuffer::MaxStage; ++k) { if ( (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) && m.NumCoords[k] != 2) { useFormatExt = true; break; } } if (!useFormatExt) { // setup standard format _VBuffer.setVertexFormat(vbFlags); } else // setup extended format { _VBuffer.clearValueEx(); if (vbFlags & CVertexBuffer::PositionFlag) _VBuffer.addValueEx(CVertexBuffer::Position, CVertexBuffer::Float3); if (vbFlags & CVertexBuffer::NormalFlag) _VBuffer.addValueEx(CVertexBuffer::Normal, CVertexBuffer::Float3); if (vbFlags & CVertexBuffer::PrimaryColorFlag) _VBuffer.addValueEx(CVertexBuffer::PrimaryColor, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::SecondaryColorFlag) _VBuffer.addValueEx(CVertexBuffer::SecondaryColor, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::WeightFlag) _VBuffer.addValueEx(CVertexBuffer::Weight, CVertexBuffer::Float4); if (vbFlags & CVertexBuffer::PaletteSkinFlag) _VBuffer.addValueEx(CVertexBuffer::PaletteSkin, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::FogFlag) _VBuffer.addValueEx(CVertexBuffer::Fog, CVertexBuffer::Float1); for (uint k = 0; k < CVertexBuffer::MaxStage; ++k) { if (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) { switch(m.NumCoords[k]) { case 2: _VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float2); break; case 3: _VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float3); break; default: nlassert(0); break; } } } _VBuffer.initEx(); } // Set local flags for corner comparison. CCornerTmp::Flags= vbFlags; // Setup locals. TCornerSet corners; const CFaceTmp *pFace= &(*tmpFaces.begin()); uint32 nFaceMB = 0; sint N= tmpFaces.size(); sint currentVBIndex=0; m.VertLink.clear (); // process each face, building up the VB. for(;N>0;N--, pFace++) { sint v0= pFace->Corner[0].Vertex; sint v1= pFace->Corner[1].Vertex; sint v2= pFace->Corner[2].Vertex; findVBId(corners, &pFace->Corner[0], currentVBIndex, m.Vertices[v0], m); findVBId(corners, &pFace->Corner[1], currentVBIndex, m.Vertices[v1], m); findVBId(corners, &pFace->Corner[2], currentVBIndex, m.Vertices[v2], m); CMesh::CVertLink vl1(nFaceMB, 0, pFace->Corner[0].VBId); CMesh::CVertLink vl2(nFaceMB, 1, pFace->Corner[1].VBId); CMesh::CVertLink vl3(nFaceMB, 2, pFace->Corner[2].VBId); m.VertLink.push_back(vl1); m.VertLink.push_back(vl2); m.VertLink.push_back(vl3); ++nFaceMB; } //================================ uint mb; // For each _MatrixBlocks, point on those materials. for(mb= 0;mb<_MatrixBlocks.size();mb++) { // Build RdrPass ids. _MatrixBlocks[mb].RdrPass.resize (numMaxMaterial); for(i=0;i<(sint)_MatrixBlocks[mb].RdrPass.size(); i++) { _MatrixBlocks[mb].RdrPass[i].MaterialId= i; } } //=================================================== pFace= &(*tmpFaces.begin()); N= tmpFaces.size(); for(;N>0;N--, pFace++) { sint mbId= pFace->MatrixBlockId; nlassert(mbId>=0 && mbId<(sint)_MatrixBlocks.size()); // Insert the face in good MatrixBlock/RdrPass. _MatrixBlocks[mbId].RdrPass[pFace->MaterialId].PBlock.addTri(pFace->Corner[0].VBId, pFace->Corner[1].VBId, pFace->Corner[2].VBId); } //============================ for(mb= 0;mb<_MatrixBlocks.size();mb++) { // NB: slow process (erase from a vector). Doens't matter since made at build. vector<CRdrPass>::iterator itPass; for( itPass=_MatrixBlocks[mb].RdrPass.begin(); itPass!=_MatrixBlocks[mb].RdrPass.end(); ) { // If this pass is empty, remove it. if( itPass->PBlock.getNumTri()==0 ) itPass= _MatrixBlocks[mb].RdrPass.erase(itPass); else itPass++; } } //============================ // BShapes this->_MeshMorpher->BlendShapes = m.BlendShapes; // sort triangles for better cache use. optimizeTriangleOrder(); // SmartPtr Copy VertexProgram effect. this->_MeshVertexProgram= m.MeshVertexProgram; //================================================= // If skinned if(_Skinned) { // Reserve some space _BonesName.reserve (m.BonesNames.size ()); // Current local bone uint currentBone = 0; // For each matrix block uint matrixBlock; for (matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++) { // Ref on the matrix block CMatrixBlock &mb = _MatrixBlocks[matrixBlock]; // Remap the skeleton index in model index std::map<uint, uint> remap; // For each matrix uint matrix; for (matrix=0; matrix<mb.NumMatrix; matrix++) { // Get bone id in the skeleton std::map<uint, uint>::iterator ite = remap.find (mb.MatrixId[matrix]); // Not found if (ite == remap.end()) { // Insert it remap.insert (std::map<uint, uint>::value_type (mb.MatrixId[matrix], currentBone)); // Check the matrix id nlassert (mb.MatrixId[matrix] < m.BonesNames.size()); // Set the bone name _BonesName.push_back (m.BonesNames[mb.MatrixId[matrix]]); // Set the id in local mb.MatrixId[matrix] = currentBone++; } else { // Set the id in local mb.MatrixId[matrix] = ite->second; } } } // Bone id in local _BoneIdComputed = false; _BoneIdExtended = false; } // End!! // Some runtime not serialized compilation compileRunTime(); }

void NL3D::CMeshGeom::buildBoneUsageVer3 (   )  [private]

Definition at line 1549 of file mesh.cpp. References _BonesId, _MatrixBlocks, _Skinned, matrix, NL3D::CMeshGeom::CMatrixBlock::MatrixId, NL3D::CMeshGeom::CMatrixBlock::NumMatrix, uint, and uint32. { if(_Skinned) { // parse all matrixBlocks, couting MaxBoneId used. uint32 maxBoneId= 0; // For each matrix block uint matrixBlock; for (matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++) { CMatrixBlock &mb = _MatrixBlocks[matrixBlock]; // For each matrix for (uint matrix=0; matrix<mb.NumMatrix; matrix++) { maxBoneId= max(mb.MatrixId[matrix], maxBoneId); } } // alloc an array of maxBoneId+1, reset to 0. std::vector<uint8> boneUsage; boneUsage.resize(maxBoneId+1, 0); // reparse all matrixBlocks, counting usage for each bone. for (matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++) { CMatrixBlock &mb = _MatrixBlocks[matrixBlock]; // For each matrix for (uint matrix=0; matrix<mb.NumMatrix; matrix++) { // mark this bone as used. boneUsage[mb.MatrixId[matrix]]= 1; } } // For each bone used _BonesId.clear(); for(uint i=0; i<boneUsage.size();i++) { // if the bone is used by the mesh, add it to BoneId. if(boneUsage[i]) _BonesId.push_back(i); } } }

void NL3D::CMeshGeom::buildSkin (  CMesh::CMeshBuild &  m, std::vector< CFaceTmp > &  tmpFaces )  [private]

Definition at line 1105 of file mesh.cpp. References _MatrixBlocks, NL3D::CMeshGeom::CFaceTmp::Corner, NL3D::CMeshGeom::CMatrixBlock::getMatrixIdLocation(), NL3D::CMeshGeom::CBoneTmp::Inserted, ItBoneMap, NL3D::CMeshGeom::CFaceTmp::MatrixBlockId, NL3D::CPaletteSkin::MatrixId, NL3D::CMeshGeom::CMatrixBlock::MatrixId, NL3D::CMesh::CSkinWeight::MatrixId, NL3D::CMeshGeom::CBoneTmp::MatrixIdInMB, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, NL3D::CMeshGeom::CMatrixBlock::NumMatrix, NL3D::CMeshGeom::CCornerTmp::Palette, NL3D::CMeshGeom::CBoneTmp::RefCount, NL3D::CMeshGeom::CMatrixBlockRemap::Remap, sint, NL3D::CMesh::CMeshBuild::SkinWeights, TBoneMap, uint, uint8, NL3D::CMesh::CCorner::Vertex, NL3D::CMeshGeom::CCornerTmp::Weights, and NL3D::CMesh::CSkinWeight::Weights. Referenced by build(). { sint i,j,k; TBoneMap remainingBones; list<uint> remainingFaces; // 0. normalize SkinWeights: for all weights at 0, copy the matrixId from 0th matrix => no random/bad use of matrix. //================================ for(i=0;i<(sint)m.SkinWeights.size();i++) { CMesh::CSkinWeight &sw= m.SkinWeights[i]; // 0th weight must not be 0. nlassert(sw.Weights[0]!=0); // Begin at 1, tests all other weights. for(j=1;j<NL3D_MESH_SKINNING_MAX_MATRIX;j++) { // We don't use this entry?? if(sw.Weights[j]==0) { // Setup MatrixId so that this vertex do no use more matrix than it really wants. sw.MatrixId[j]= sw.MatrixId[0]; } } } // 1. build the list of used/remaining bones, in ascending order. (so we use the depth-first topolgy of hierarchy). //================================ for(i=0;i<(sint)tmpFaces.size();i++) { CFaceTmp &face= tmpFaces[i]; for(j=0;j<3;j++) { CMesh::CSkinWeight &sw= m.SkinWeights[face.Corner[j].Vertex]; for(k=0;k<NL3D_MESH_SKINNING_MAX_MATRIX;k++) { // insert (if not already here) the used bone in the set. // and insert his refcount. (NB: ctor() init it to 0 :) ). remainingBones[sw.MatrixId[k]].RefCount++; } } } // 2. Create the list of un-inserted faces. //================================ for(i=0;i<(sint)tmpFaces.size();i++) { remainingFaces.push_back(i); } // 3. Create as many Blocks as necessary. //================================ // Which bones a face use (up to 12). vector<uint> boneUse; boneUse.reserve(NL3D_MESH_SKINNING_MAX_MATRIX*3); // While still exist faces. while(!remainingFaces.empty()) { // create a new matrix block. _MatrixBlocks.push_back(CMatrixBlock()); CMatrixBlock &matrixBlock= _MatrixBlocks[_MatrixBlocks.size()-1]; matrixBlock.NumMatrix=0; // a. reset remainingBones as not inserted in the current matrixBlock. //============================ ItBoneMap itBone; for(itBone= remainingBones.begin();itBone!=remainingBones.end();itBone++) { itBone->second.Inserted= false; } // b. while still exist bones, try to insert faces which use them in matrixBlock. //============================ while(!remainingBones.empty()) { // get the first bone from the map. (remind: depth-first order). uint currentBoneId= remainingBones.begin()->first; // If no more faces in the remainingFace list use this bone, remove it, and continue. if(remainingBones.begin()->second.RefCount==0) { remainingBones.erase(remainingBones.begin()); continue; } // this is a marker, to know if a face insertion will occurs. bool faceAdded= false; // traverse all faces, trying to insert them in current MatrixBlock processed. list<uint>::iterator itFace; for(itFace= remainingFaces.begin(); itFace!=remainingFaces.end();) { bool useCurrentBoneId; uint newBoneAdded; // i/ Get info on current face. //----------------------------- // build which bones this face use. tmpFaces[*itFace].buildBoneUse(boneUse, m.SkinWeights); // test if this face use the currentBoneId. useCurrentBoneId= false; for(i=0;i<(sint)boneUse.size();i++) { // if this face use the currentBoneId if(boneUse[i]==currentBoneId) { useCurrentBoneId= true; break; } } // compute how many bones that are not in the current matrixblock this face use. newBoneAdded=0; for(i=0;i<(sint)boneUse.size();i++) { // if this bone is not inserted in the current matrix block, inform it. if(!remainingBones[boneUse[i]].Inserted) newBoneAdded++; } // ii/ insert/reject face. //------------------------ // If this face do not add any more bone, we can insert it into the current matrixblock. // If it use the currentBoneId, and do not explode max count, we allow insert it too in the current matrixblock. if( newBoneAdded==0 || (useCurrentBoneId && newBoneAdded+matrixBlock.NumMatrix < IDriver::MaxModelMatrix) ) { // Insert this face in the current matrix block CFaceTmp &face= tmpFaces[*itFace]; // for all vertices of this face. for(j=0;j<3;j++) { CMesh::CSkinWeight &sw= m.SkinWeights[face.Corner[j].Vertex]; // for each corner weight (4) for(k=0;k<NL3D_MESH_SKINNING_MAX_MATRIX;k++) { // get the global boneId this corner weight use. uint boneId= sw.MatrixId[k]; // get the CBoneTmp this corner weight use. CBoneTmp &bone= remainingBones[boneId]; // decRef the bone . bone.RefCount--; // Is this bone already inserted in the MatrixBlock ? if( !bone.Inserted ) { // No, insert it. bone.Inserted= true; // link it to the MatrixId in the current matrixBlock. bone.MatrixIdInMB= matrixBlock.NumMatrix; // modify the matrixBlock matrixBlock.MatrixId[matrixBlock.NumMatrix]= boneId; // increment the number of matrix in the matrixBlock. matrixBlock.NumMatrix++; } // Copy Weight info for this Corner. // Set what matrix in the current matrix block this corner use. face.Corner[j].Palette.MatrixId[k]= bone.MatrixIdInMB; // Set weight. face.Corner[j].Weights[k]= sw.Weights[k]; } } // to Which matrixblock this face is inserted. face.MatrixBlockId= _MatrixBlocks.size()-1; // remove the face from remain face list. itFace= remainingFaces.erase(itFace); // inform the algorithm that a face has been added. faceAdded= true; } else { // do not append this face to the current matrix block, skip to the next itFace++; } } // If no faces have been added during this pass, we are blocked, and either the MatrixBlock may be full, // or there is no more face. So quit this block and process a new one. if(!faceAdded) break; } } // NB: at the end of this loop, remainingBones may not be empty(), but all remainingBones should have RefCount==0. // 4. Re-order matrix use in MatrixBlocks, for minimum matrix change between MatrixBlocks. //================================ vector<CMatrixBlockRemap> blockRemaps; blockRemaps.resize(_MatrixBlocks.size()); // For all MatrixBlocks > first, try to "mirror" bones from previous. for(i=1;i<(sint)_MatrixBlocks.size();i++) { CMatrixBlock &mBlock= _MatrixBlocks[i]; CMatrixBlock &mPrevBlock= _MatrixBlocks[i-1]; CMatrixBlockRemap &remap= blockRemaps[i]; // First bkup the bone ids in remap table. for(j=0;j<(sint)mBlock.NumMatrix;j++) { remap.Remap[j]= mBlock.MatrixId[j]; } // For all ids of this blocks, try to mirror them. for(j=0;j<(sint)mBlock.NumMatrix;j++) { // get the location of this bone in the prev bone. sint idLoc= mPrevBlock.getMatrixIdLocation(mBlock.MatrixId[j]); // If not found, or if bigger than current array, fails (cant be mirrored). // Or if already mirrored. if(idLoc==-1 || idLoc>=(sint)mBlock.NumMatrix || idLoc==j) { // next id. j++; } else { // puts me on my mirrored location. and swap with the current one at this mirrored location. swap(mBlock.MatrixId[j], mBlock.MatrixId[idLoc]); // mBlock.MatrixId[j] is now a candidate for mirror. } } // Then build the Remap table, to re-order faces matrixId which use this matrix block. for(j=0;j<(sint)mBlock.NumMatrix;j++) { // get the boneid which was at this position j before. uint boneId= remap.Remap[j]; // search his new position, and store the result in the remap table. remap.Remap[j]= mBlock.getMatrixIdLocation(boneId); } // NB: this matrixBlock is re-ordered. next matrixBlock use this state. } // For all faces/corners/weights, remap MatrixIds. for(i=0;i<(sint)tmpFaces.size();i++) { CFaceTmp &face= tmpFaces[i]; // do it but for matrixblock0. if(face.MatrixBlockId!=0) { CMatrixBlockRemap &remap= blockRemaps[face.MatrixBlockId]; // For all corners. for(j=0;j<3;j++) { for(k=0;k<NL3D_MESH_SKINNING_MAX_MATRIX;k++) { uint oldId= face.Corner[j].Palette.MatrixId[k]; face.Corner[j].Palette.MatrixId[k]= (uint8)remap.Remap[oldId]; } } } } }

bool NL3D::CMeshGeom::clip (  const std::vector< CPlane > &  pyramid, const CMatrix &  worldMatrix )  [virtual]

clip this mesh Reimplemented from NL3D::IMeshGeom. Definition at line 482 of file mesh.cpp. References _PreciseClipping, NLMISC::CBSphere::applyTransform(), NLMISC::CBSphere::Center, NLMISC::CAABBoxExt::clipBack(), NLMISC::CAABBoxExt::getCenter(), NLMISC::CAABBoxExt::getRadius(), NLMISC::CPlane::normalize(), NLMISC::CBSphere::Radius, and sint. Referenced by NL3D::CMesh::clip(). { // Speed Clip: clip just the sphere. CBSphere localSphere(_BBox.getCenter(), _BBox.getRadius()); CBSphere worldSphere; // transform the sphere in WorldMatrix (with nearly good scale info). localSphere.applyTransform(worldMatrix, worldSphere); // if out of only plane, entirely out. for(sint i=0;i<(sint)pyramid.size();i++) { // We are sure that pyramid has normalized plane normals. // if SpherMax OUT return false. float d= pyramid[i]*worldSphere.Center; if(d>worldSphere.Radius) return false; } // test if must do a precise clip, according to mesh size. if( _PreciseClipping ) { CPlane localPlane; // if out of only plane, entirely out. for(sint i=0;i<(sint)pyramid.size();i++) { // Transform the pyramid in Object space. localPlane= pyramid[i]*worldMatrix; // localPlane must be normalized, because worldMatrix mya have a scale. localPlane.normalize(); // if the box is not partially inside the plane, quit if( !_BBox.clipBack(localPlane) ) return false; } } return true; }

void NL3D::CMeshGeom::compileRunTime (   )  [private]

Definition at line 1062 of file mesh.cpp. References _MatrixBlocks, _MeshMorpher, _MeshVertexProgram, _PreciseClipping, _Skinned, _SupportMBRFlags, bkupOriginalSkinVertices(), NL3D::CMeshMorpher::BlendShapes, NLMISC::CAABBoxExt::getRadius(), MBROk, MBRSortPerMaterial, and NL3D_MESH_PRECISE_CLIP_THRESHOLD. Referenced by build(), and setBlendShapes(). { // if skinned, prepare skinning if(_Skinned) bkupOriginalSkinVertices(); // Do precise clipping for big object?? _PreciseClipping= _BBox.getRadius() >= NL3D_MESH_PRECISE_CLIP_THRESHOLD; // Support MeshBlockRendering only if not skinned/meshMorphed. bool supportMeshBlockRendering= !_Skinned && _MeshMorpher->BlendShapes.size()==0; // true only if one matrix block, and at least one rdrPass. supportMeshBlockRendering= supportMeshBlockRendering && _MatrixBlocks.size()==1 && _MatrixBlocks[0].RdrPass.size()>0; if (supportMeshBlockRendering && _MeshVertexProgram) { supportMeshBlockRendering = supportMeshBlockRendering && _MeshVertexProgram->supportMeshBlockRendering(); } // TestYoyo //supportMeshBlockRendering= false; // support MeshVertexProgram, but no material sorting... bool supportMBRPerMaterial= supportMeshBlockRendering && _MeshVertexProgram==NULL; // setup flags _SupportMBRFlags= 0; if(supportMeshBlockRendering) _SupportMBRFlags|= MBROk; if(supportMBRPerMaterial) _SupportMBRFlags|= MBRSortPerMaterial; }

void NL3D::CMeshGeom::computeBonesId (  CSkeletonModel *  skeleton  )

Compute skinning id. Definition at line 1456 of file mesh.cpp. References _BoneIdComputed, _BoneIdExtended, _BonesId, _BonesIdExt, _BonesName, _MatrixBlocks, NL3D::CSkeletonModel::Bones, NL3D::CSkeletonModel::flagBoneAndParents(), NL3D::CSkeletonModel::getBoneIdByName(), matrix, NL3D::CMeshGeom::CMatrixBlock::MatrixId, nlassert, nlwarning, NL3D::CMeshGeom::CMatrixBlock::NumMatrix, sint32, uint, and uint32. Referenced by NL3D::CMesh::computeBonesId(). { // Already computed ? if (!_BoneIdComputed) { // Get a pointer on the skeleton nlassert (skeleton); if (skeleton) { // Resize boneId to the good size. _BonesId.resize(_BonesName.size()); // For each matrix block uint matrixBlock; for (matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++) { // Ref on the matrix block CMatrixBlock &mb = _MatrixBlocks[matrixBlock]; // For each matrix uint matrix; for (matrix=0; matrix<mb.NumMatrix; matrix++) { // Get bone id in the skeleton nlassert (mb.MatrixId[matrix]<_BonesName.size()); sint32 boneId = skeleton->getBoneIdByName (_BonesName[mb.MatrixId[matrix]]); // Setup the _BoneId. _BonesId[mb.MatrixId[matrix]]= boneId; // Bones found ? if (boneId != -1) { // Set the bone id mb.MatrixId[matrix] = (uint32)boneId; } else { // Put id 0 mb.MatrixId[matrix] = 0; // Error nlwarning ("Bone %s not found in the skeleton.", _BonesName[mb.MatrixId[matrix]].c_str()); } } } // Computed _BoneIdComputed = true; } } // Already extended ? if (!_BoneIdExtended) { nlassert (skeleton); if (skeleton) { // the total bone Usage of the mesh. vector<bool> boneUsage; boneUsage.resize(skeleton->Bones.size(), false); // for all Bones marked as valid. uint i; for(i=0; i<_BonesId.size(); i++) { // if not a valid boneId, skip it. if(_BonesId[i]<0) continue; // mark him and his father in boneUsage. skeleton->flagBoneAndParents(_BonesId[i], boneUsage); } // fill _BonesIdExt with bones of _BonesId and their parents. _BonesIdExt.clear(); for(i=0; i<boneUsage.size();i++) { // if the bone is used by the mesh, add it to BoneIdExt. if(boneUsage[i]) _BonesIdExt.push_back(i); } } // Extended _BoneIdExtended= true; } }

void NL3D::CMeshGeom::computeMeshVBHeap (  void *  dst, uint  indexStart )  [virtual]

When the framework succes to allocate a VBHeap space, it call this method to fill this space and compute shifted Primitive block. Parameters: the  dest VertexBuffer. NB: start to fill at dst[0] indexStart  used to shift primitive block. Reimplemented from NL3D::IMeshGeom. Definition at line 2133 of file mesh.cpp. References _MatrixBlocks, NL3D::CPrimitiveBlock::getLinePointer(), NL3D::CPrimitiveBlock::getNumLine(), NL3D::CPrimitiveBlock::getNumQuad(), NL3D::CPrimitiveBlock::getNumTri(), NL3D::CVertexBuffer::getNumVertices(), NL3D::CPrimitiveBlock::getQuadPointer(), NL3D::CPrimitiveBlock::getTriPointer(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexSize(), nlassert, NL3D::CMeshGeom::CMatrixBlock::RdrPass, NL3D::CPrimitiveBlock::setNumLine(), NL3D::CPrimitiveBlock::setNumQuad(), NL3D::CPrimitiveBlock::setNumTri(), uint, and uint32. { // Fill dst with Buffer content. memcpy(dst, _VBuffer.getVertexCoordPointer(), _VBuffer.getNumVertices()*_VBuffer.getVertexSize() ); // NB: only 1 MB is possible ... nlassert(_MatrixBlocks.size()==1); CMatrixBlock &mBlock= _MatrixBlocks[0]; // For all rdrPass. for(uint i=0;i<mBlock.RdrPass.size();i++) { // shift the PB CPrimitiveBlock &srcPb= mBlock.RdrPass[i].PBlock; CPrimitiveBlock &dstPb= mBlock.RdrPass[i].VBHeapPBlock; uint j; // Lines. dstPb.setNumLine(srcPb.getNumLine()); uint32 *srcLinePtr= srcPb.getLinePointer(); uint32 *dstLinePtr= dstPb.getLinePointer(); for(j=0; j<dstPb.getNumLine()*2;j++) { dstLinePtr[j]= srcLinePtr[j]+indexStart; } // Tris. dstPb.setNumTri(srcPb.getNumTri()); uint32 *srcTriPtr= srcPb.getTriPointer(); uint32 *dstTriPtr= dstPb.getTriPointer(); for(j=0; j<dstPb.getNumTri()*3;j++) { dstTriPtr[j]= srcTriPtr[j]+indexStart; } // Quads. dstPb.setNumQuad(srcPb.getNumQuad()); uint32 *srcQuadPtr= srcPb.getQuadPointer(); uint32 *dstQuadPtr= dstPb.getQuadPointer(); for(j=0; j<dstPb.getNumQuad()*4;j++) { dstQuadPtr[j]= srcQuadPtr[j]+indexStart; } } }

void NL3D::CMeshGeom::computeSkinMatrixes (  CSkeletonModel *  skeleton, CMatrix3x4 *  matrixes, CMatrixBlock *  prevBlock, CMatrixBlock &  curBlock )  [private]

Definition at line 1914 of file mesh.cpp. References NL3D::CSkeletonModel::getActiveBoneSkinMatrix(), NL3D::CMeshGeom::CMatrixBlock::MatrixId, NL3D::CMeshGeom::CMatrixBlock::NumMatrix, NL3D::CMatrix3x4::set(), and uint. Referenced by applySkin(). { // For all matrix of this mBlock. for(uint idMat=0;idMat<mBlock.NumMatrix;idMat++) { uint curBoneId= mBlock.MatrixId[idMat]; // If same matrix binded as previous block, no need to bind!! if(prevBlock && idMat<prevBlock->NumMatrix && prevBlock->MatrixId[idMat]== curBoneId) continue; // Else, we must setup the matrix matrixes[idMat].set(skeleton->getActiveBoneSkinMatrix(curBoneId)); } }

void NL3D::CMeshGeom::computeSoftwarePointSkinning (  CMatrix3x4 *  matrixes, CVector *  srcVector, CPaletteSkin *  srcPal, float *  srcWgt, CVector *  dstVector )  [private]

Definition at line 1870 of file mesh.cpp. References NL3D::CPaletteSkin::MatrixId, NL3D::CMatrix3x4::mulAddPoint(), and NL3D::CMatrix3x4::mulSetPoint(). Referenced by applySkin(). { CMatrix3x4 *pMat; // \todo yoyo: TODO_OPTIMIZE: SSE verion... // 0th matrix influence. pMat= matrixes + srcPal->MatrixId[0]; pMat->mulSetPoint(*srcVec, srcWgt[0], *pDst); // 1th matrix influence. pMat= matrixes + srcPal->MatrixId[1]; pMat->mulAddPoint(*srcVec, srcWgt[1], *pDst); // 2th matrix influence. pMat= matrixes + srcPal->MatrixId[2]; pMat->mulAddPoint(*srcVec, srcWgt[2], *pDst); // 3th matrix influence. pMat= matrixes + srcPal->MatrixId[3]; pMat->mulAddPoint(*srcVec, srcWgt[3], *pDst); }

void NL3D::CMeshGeom::computeSoftwareVectorSkinning (  CMatrix3x4 *  matrixes, CVector *  srcVector, CPaletteSkin *  srcPal, float *  srcWgt, CVector *  dstVector )  [private]

Definition at line 1892 of file mesh.cpp. References NL3D::CPaletteSkin::MatrixId, NL3D::CMatrix3x4::mulAddVector(), and NL3D::CMatrix3x4::mulSetVector(). Referenced by applySkin(). { CMatrix3x4 *pMat; // \todo yoyo: TODO_OPTIMIZE: SSE verion... // 0th matrix influence. pMat= matrixes + srcPal->MatrixId[0]; pMat->mulSetVector(*srcVec, srcWgt[0], *pDst); // 1th matrix influence. pMat= matrixes + srcPal->MatrixId[1]; pMat->mulAddVector(*srcVec, srcWgt[1], *pDst); // 2th matrix influence. pMat= matrixes + srcPal->MatrixId[2]; pMat->mulAddVector(*srcVec, srcWgt[2], *pDst); // 3th matrix influence. pMat= matrixes + srcPal->MatrixId[3]; pMat->mulAddVector(*srcVec, srcWgt[3], *pDst); }

void NL3D::CMeshGeom::endMesh (  CMeshGeomRenderContext &  rdrCtx  )  [virtual]

The framework call this method when it has done with this meshGeom Implements NL3D::IMeshGeom. Definition at line 2100 of file mesh.cpp. References _MeshVertexProgram, _SupportMBRFlags, NL3D::CMeshGeomRenderContext::Driver, and MBRCurrentUseVP. { // MeshVertexProgram ? if( _SupportMBRFlags & MBRCurrentUseVP ) { // End Mesh _MeshVertexProgram->endMBRMesh( rdrCtx.Driver ); // and remove Current Flag. _SupportMBRFlags&= ~MBRCurrentUseVP; } }

void NL3D::CMeshGeom::findVBId (  TCornerSet &  corners, const CCornerTmp *  corn, sint &  currentVBIndex, const CVector &  vert, const CMesh::CMeshBuild &  mb )  [inline, private]

Definition at line 733 of file mesh.h. References ItCornerSet, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, NL3D::CMesh::CMeshBuild::NumCoords, NL3D::CVertexBuffer::setColor(), NL3D::CVertexBuffer::setNormalCoord(), NL3D::CVertexBuffer::setNumVertices(), NL3D::CVertexBuffer::setPaletteSkin(), NL3D::CVertexBuffer::setSpecular(), NL3D::CVertexBuffer::setTexCoord(), NL3D::CVertexBuffer::setValueFloat3Ex(), NL3D::CVertexBuffer::setVertexCoord(), NL3D::CVertexBuffer::setWeight(), sint, and TCornerSet. Referenced by build(). { ItCornerSet it= corners.find(const_cast<CCornerTmp *>(corn)); if(it!=corners.end()) corn->VBId= (*it)->VBId; else { // Add corner to the set to not insert same corner two times. corners.insert (const_cast<CCornerTmp *>(corn)); sint i; corn->VBId= currentVBIndex++; // Fill the VBuffer. _VBuffer.setNumVertices(currentVBIndex); sint id= currentVBIndex-1; // XYZ. _VBuffer.setVertexCoord(id, vert); // Normal if(CCornerTmp::Flags & CVertexBuffer::NormalFlag) _VBuffer.setNormalCoord(id, corn->Normal); // Uvws. for(i=0;i<CVertexBuffer::MaxStage;i++) { if(CCornerTmp::Flags & (CVertexBuffer::TexCoord0Flag<<i)) { switch(mb.NumCoords[i]) { case 2: _VBuffer.setTexCoord(id, i, corn->Uvws[i].U, corn->Uvws[i].V); break; case 3: _VBuffer.setValueFloat3Ex((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + i), id, corn->Uvws[i].U, corn->Uvws[i].V, corn->Uvws[i].W); break; default: // not supported nlassert(0); break; } } } // Color. if(CCornerTmp::Flags & CVertexBuffer::PrimaryColorFlag) _VBuffer.setColor(id, corn->Color); // Specular. if(CCornerTmp::Flags & CVertexBuffer::SecondaryColorFlag) _VBuffer.setSpecular(id, corn->Specular); // setup palette skinning. if ((CCornerTmp::Flags & CVertexBuffer::PaletteSkinFlag)==CVertexBuffer::PaletteSkinFlag) { _VBuffer.setPaletteSkin(id, corn->Palette); for(i=0;i<NL3D_MESH_SKINNING_MAX_MATRIX;i++) _VBuffer.setWeight(id, i, corn->Weights[i]); } } }

void NL3D::CMeshGeom::flagSkinVerticesForMatrixBlock (  uint8 *  skinFlags, CMatrixBlock &  mb )  [private]

Definition at line 1836 of file mesh.cpp. References NL3D::CPrimitiveBlock::getLinePointer(), NL3D::CPrimitiveBlock::getNumLine(), NL3D::CPrimitiveBlock::getNumQuad(), NL3D::CPrimitiveBlock::getNumTri(), NL3D::CPrimitiveBlock::getQuadPointer(), NL3D::CPrimitiveBlock::getTriPointer(), NL3D_SOFTSKIN_VMUSTCOMPUTE, NL3D::CMeshGeom::CMatrixBlock::RdrPass, uint, uint32, and uint8. Referenced by applySkin(). { for(uint i=0; i<mb.RdrPass.size(); i++) { CPrimitiveBlock &PB= mb.RdrPass[i].PBlock; uint32 *pIndex; uint nIndex; // This may be better to flags in 2 pass (first traverse primitives, then test vertices). // Better sol for BTB..., because number of tests are divided by 6 (for triangles). // for all prims, indicate which vertex we must compute. // nothing if not already computed (ie 0), because 0&1==0. // Lines. pIndex= (uint32*)PB.getLinePointer(); nIndex= PB.getNumLine()*2; for(;nIndex>0;nIndex--, pIndex++) skinFlags[*pIndex]&= NL3D_SOFTSKIN_VMUSTCOMPUTE; // Tris. pIndex= (uint32*)PB.getTriPointer(); nIndex= PB.getNumTri()*3; for(;nIndex>0;nIndex--, pIndex++) skinFlags[*pIndex]&= NL3D_SOFTSKIN_VMUSTCOMPUTE; // Quads. pIndex= (uint32*)PB.getQuadPointer(); nIndex= PB.getNumQuad()*4; for(;nIndex>0;nIndex--, pIndex++) skinFlags[*pIndex]&= NL3D_SOFTSKIN_VMUSTCOMPUTE; } }

const NLMISC::CAABBoxExt& NL3D::CMeshGeom::getBoundingBox (   )  const [inline, virtual]

get the extended axis aligned bounding box of the mesh Implements NL3D::IMeshGeom. Definition at line 384 of file mesh.h. Referenced by NL3D::CMesh::getBoundingBox(). { return _BBox; }

virtual std::string NLMISC::IClassable::getClassName (   )  [pure virtual, inherited]

Implemented in NLAIAGENT::CNumericIndex, NLAIC::IPointerGestion, NLAIC::CIdentType, and CAutomataDesc. Referenced by NLMISC::CClassRegistry::checkObject(), and NL3D::GetTextureSize().

uint NL3D::CMeshGeom::getNbBlendShapes (   )  const [inline]

get the number of BlendShapes Definition at line 419 of file mesh.h. References _MeshMorpher, NL3D::CMeshMorpher::BlendShapes, and uint. { if(_MeshMorpher) return _MeshMorpher->BlendShapes.size(); }

uint NL3D::CMeshGeom::getNbMatrixBlock (   )  const [inline]

get the number of matrix block Definition at line 393 of file mesh.h. References _MatrixBlocks, and uint. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CInstanceLighter::addTriangles(), applyMaterialRemap(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CMeshMultiLod::compileCoarseMeshes(), NL3D::UShape::getMeshTriangles(), NL3D::CMesh::getNbMatrixBlock(), and NL3D::CCoarseMeshBuild::remapCoordinates(). { return _MatrixBlocks.size() ; }

uint NL3D::CMeshGeom::getNbRdrPass (  uint  matrixBlockIndex  )  const [inline]

get the number of rendering pass for a given matrix block Parameters: matrixBlockIndex  the index of the matrix block the rendering passes belong to Definition at line 398 of file mesh.h. References _MatrixBlocks, and uint. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CInstanceLighter::addTriangles(), applyMaterialRemap(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CMeshMultiLod::compileCoarseMeshes(), NL3D::UShape::getMeshTriangles(), NL3D::CMesh::getNbRdrPass(), and NL3D::CCoarseMeshBuild::remapCoordinates(). { return _MatrixBlocks[matrixBlockIndex].RdrPass.size() ; }

uint NL3D::CMeshGeom::getNumRdrPassesForInstance (  CMeshBaseInstance *  inst  )  const [virtual]

return the number of renderPasses for this instance. Called after activateInstance() Used only if sortPerMaterial()) is false Implements NL3D::IMeshGeom. Definition at line 2016 of file mesh.cpp. References _MatrixBlocks, and uint. { return _MatrixBlocks[0].RdrPass.size(); }

uint NL3D::CMeshGeom::getNumRdrPassesForMesh (   )  const [virtual]

return the number of renderPasses for this mesh. Used only if sortPerMaterial()) is true Implements NL3D::IMeshGeom. Definition at line 2011 of file mesh.cpp. References _MatrixBlocks, and uint. { return _MatrixBlocks[0].RdrPass.size(); }

float NL3D::CMeshGeom::getNumTriangles (  float  distance  )  [virtual]

clip this mesh Implements NL3D::IMeshGeom. Definition at line 1429 of file mesh.cpp. References _MatrixBlocks, NL3D::CPrimitiveBlock::getNumTriangles(), NL3D::CMeshGeom::CRdrPass::PBlock, NL3D::CMeshGeom::CMatrixBlock::RdrPass, uint, and uint32. { // Sum of triangles uint32 triCount=0; // For each matrix block uint mbCount=_MatrixBlocks.size(); for (uint mb=0; mb<mbCount; mb++) { CMatrixBlock &block=_MatrixBlocks[mb]; // Count of primitive block uint pCount=block.RdrPass.size(); for (uint pb=0; pb<pCount; pb++) { // Ref on the primitive block CRdrPass &pass=block.RdrPass[pb]; // Sum tri triCount+=pass.PBlock.getNumTriangles (); } } return (float)triCount; }

uint32 NL3D::CMeshGeom::getRdrPassMaterial (  uint  matrixBlockIndex, uint  renderingPassIndex )  const [inline]

get the material ID associated with a rendering pass of a matrix block Parameters: matrixBlockIndex  the index of the matrix block the renderin pass belong to renderingPassIndex  the index of the rendering pass in the matrix block Definition at line 413 of file mesh.h. References _MatrixBlocks, uint, and uint32. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CMesh::getRdrPassMaterial(), and NL3D::CCoarseMeshBuild::remapCoordinates(). { return _MatrixBlocks[matrixBlockIndex].RdrPass[renderingPassIndex].MaterialId ; }

const CPrimitiveBlock& NL3D::CMeshGeom::getRdrPassPrimitiveBlock (  uint  matrixBlockIndex, uint  renderingPassIndex )  const [inline]

get the primitive block associated with a rendering pass of a matrix block Parameters: matrixBlockIndex  the index of the matrix block the renderin pass belong to renderingPassIndex  the index of the rendering pass in the matrix block Definition at line 404 of file mesh.h. References _MatrixBlocks, and uint. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CInstanceLighter::addTriangles(), NL3D::CMeshMultiLod::compileCoarseMeshes(), NL3D::UShape::getMeshTriangles(), NL3D::CMesh::getRdrPassPrimitiveBlock(), and NL3D::CCoarseMeshBuild::remapCoordinates(). { return _MatrixBlocks[matrixBlockIndex].RdrPass[renderingPassIndex].PBlock ; }

const std::vector<sint32>& NL3D::CMeshGeom::getSkinBoneUsage (   )  const [inline]

return array of bones used by the skin. computeBonesId must has been called before. Definition at line 440 of file mesh.h. References _BonesId. Referenced by NL3D::CMeshInstance::getSkinBoneUsage(). {return _BonesId;}

bool NL3D::CMeshGeom::getVBHeapInfo (  uint &  vertexFormat, uint &  numVertices )  [virtual]

The framework call this method to know if the mesh can fit in VBHeap. if yes, deriver must return mesh vertexFormat and num of vertices. Reimplemented from NL3D::IMeshGeom. Definition at line 2114 of file mesh.cpp. References _MeshVertexProgram, _SupportMBRFlags, NL3D::CVertexBuffer::getNumVertices(), NL3D::CVertexBuffer::getVertexFormat(), and uint. { // CMeshGeom support VBHeap rendering, assuming supportMeshBlockRendering is true. if( _SupportMBRFlags ) /* Yoyo: If VertexProgram, DON'T SUPPORT!! because VB need to be activated AFTER meshVP activation NB: still possible with complex code to do it (sort per VP type (with or not)...), but tests in Ryzom shows that VBHeap is not really important (not so much different shapes...) */ if( _MeshVertexProgram==NULL ) { vertexFormat= _VBuffer.getVertexFormat(); numVertices= _VBuffer.getNumVertices(); return true; } return false; }

const CVertexBuffer& NL3D::CMeshGeom::getVertexBuffer (   )  const [inline]

get the vertex buffer used by the mesh Definition at line 390 of file mesh.h. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CInstanceLighter::addTriangles(), NL3D::UShape::getMeshTriangles(), NL3D::CMesh::getVertexBuffer(), NL3D::CMeshMultiLod::instanciateCoarseMeshSpace(), NL3D::CCoarseMeshBuild::remapCoordinates(), NL3D::CMeshMultiLod::renderCoarseMesh(), NL3D::CMeshMultiLodInstance::setPosCoarseMesh(), and NL3D::CMeshMultiLodInstance::setUVCoarseMesh(). { return _VBuffer ; }

virtual bool NL3D::CMeshGeom::hasMeshVertexProgram (   )  const [inline, virtual]

True if this mesh has a vertexProgram. Reimplemented from NL3D::IMeshGeom. Definition at line 478 of file mesh.h. References _MeshVertexProgram. Referenced by NL3D::CMeshInstance::initRenderFilterType(). {return _MeshVertexProgram!=NULL;}

void NL3D::CMeshGeom::initInstance (  CMeshBaseInstance *  mbi  )  [virtual]

Init instance info. Implements NL3D::IMeshGeom. Definition at line 474 of file mesh.cpp. References _MeshVertexProgram. Referenced by NL3D::CMesh::createInstance(). { // init the instance with _MeshVertexProgram infos if(_MeshVertexProgram) _MeshVertexProgram->initInstance(mbi); }

virtual bool NL3D::IMeshGeom::isActiveInstanceNeedVBFill (   )  const [inline, virtual, inherited]

Return true if the meshGeom has to Fill some Vertices at activeInstance() time if VBHeap enabled at this time, then vbDst in activeInstance(,,,vbDst) will contains the vb to write to. Reimplemented in NL3D::CMeshMRMGeom. Definition at line 212 of file mesh_geom.h. Referenced by NL3D::CMeshBlockManager::render(). {return false;}

bool NL3D::IMeshGeom::isMeshInVBHeap (   )  const [inline, inherited]

Return true if the meshGeom has to Fill some Vertices at activeInstance() time if VBHeap enabled at this time, then vbDst in activeInstance(,,,vbDst) will contains the vb to write to. Definition at line 215 of file mesh_geom.h. References NL3D::IMeshGeom::_MeshVBHeapId. Referenced by NL3D::CMeshMRMGeom::profileSceneRender(), and profileSceneRender(). {return _MeshVBHeapId!=0;}

bool NL3D::CMeshGeom::isSkinned (   )  const [inline]

Return true if the mesh is skinned, else return false. Definition at line 428 of file mesh.h. References _Skinned. Referenced by NL3D::CMeshInstance::isSkinnable(). { return _Skinned; }

NL3D::CMeshGeom::NLMISC_DECLARE_CLASS (  CMeshGeom   )

clip this mesh

void NL3D::CMeshGeom::optimizeTriangleOrder (   )  [private]

Definition at line 153 of file mesh.cpp. References _MatrixBlocks, NL3D::CStripifier::optimizeTriangles(), NL3D::CMeshGeom::CRdrPass::PBlock, and uint. Referenced by build(). { CStripifier stripifier; // for all rdrpass of all matrix blocks. for(uint mb= 0;mb<_MatrixBlocks.size();mb++) { for(uint rp=0; rp<_MatrixBlocks[mb].RdrPass.size(); rp++ ) { // stripify list of triangles of this pass. CRdrPass &pass= _MatrixBlocks[mb].RdrPass[rp]; stripifier.optimizeTriangles(pass.PBlock, pass.PBlock); } } }

void NL3D::CMeshGeom::profileSceneRender (  CRenderTrav *  rdrTrav, CTransformShape *  trans, float  polygonCount, uint32  rdrFlags )  [virtual]

clip this mesh Implements NL3D::IMeshGeom. Definition at line 1932 of file mesh.cpp. References _MatrixBlocks, _VertexBufferHard, NL3D::CScene::BenchRes, NL3D::CPrimitiveBlock::getNumTri(), NL3D::CVertexBuffer::getVertexFormat(), NL3D::CScene::incrementProfileTriVBFormat(), NL3D::IMeshGeom::isMeshInVBHeap(), NL3D::CMeshGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, NL3D::UScene::CBenchResults::MeshProfileTriVBFormat, NL3D::UScene::CBenchResults::NumMeshRdrBlock, NL3D::UScene::CBenchResults::NumMeshRdrBlockWithVBHeap, NL3D::UScene::CBenchResults::NumMeshRdrNormal, NL3D::UScene::CBenchResults::NumMeshTriRdrBlock, NL3D::UScene::CBenchResults::NumMeshTriRdrBlockWithVBHeap, NL3D::UScene::CBenchResults::NumMeshTriRdrNormal, NL3D::UScene::CBenchResults::NumMeshVBufferHard, NL3D::UScene::CBenchResults::NumMeshVBufferStd, NL3D::CMeshGeom::CRdrPass::PBlock, NL3D::CMeshGeom::CMatrixBlock::RdrPass, NL3D::CTraversal::Scene, supportMeshBlockRendering(), uint, and uint32. Referenced by NL3D::CMesh::profileSceneRender(). { // get the mesh instance. CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans); // For all _MatrixBlocks uint triCount= 0; for(uint mb=0;mb<_MatrixBlocks.size();mb++) { CMatrixBlock &mBlock= _MatrixBlocks[mb]; // Profile all pass. for (uint i=0;i<mBlock.RdrPass.size();i++) { CRdrPass &rdrPass= mBlock.RdrPass[i]; // Profile with the Materials of the MeshInstance. if ( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) || ( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) ) { triCount+= rdrPass.PBlock.getNumTri(); } } } // Profile if(triCount) { // tri per VBFormat rdrTrav->Scene->incrementProfileTriVBFormat(rdrTrav->Scene->BenchRes.MeshProfileTriVBFormat, _VBuffer.getVertexFormat(), triCount); // VBHard if(_VertexBufferHard) rdrTrav->Scene->BenchRes.NumMeshVBufferHard++; else rdrTrav->Scene->BenchRes.NumMeshVBufferStd++; // rendered in BlockRendering, only if not transparent pass (known it if RenderTransparentMaterial is set) if(supportMeshBlockRendering() && (rdrFlags & IMeshGeom::RenderTransparentMaterial)==0 ) { if(isMeshInVBHeap()) { rdrTrav->Scene->BenchRes.NumMeshRdrBlockWithVBHeap++; rdrTrav->Scene->BenchRes.NumMeshTriRdrBlockWithVBHeap+= triCount; } else { rdrTrav->Scene->BenchRes.NumMeshRdrBlock++; rdrTrav->Scene->BenchRes.NumMeshTriRdrBlock+= triCount; } } else { rdrTrav->Scene->BenchRes.NumMeshRdrNormal++; rdrTrav->Scene->BenchRes.NumMeshTriRdrNormal+= triCount; } } }

void NL3D::CMeshGeom::render (  IDriver *  drv, CTransformShape *  trans, float  polygonCount, uint32  rdrFlags, float  globalAlpha )  [virtual]

render() this mesh in a driver. Implements NL3D::IMeshGeom. Definition at line 598 of file mesh.cpp. References _MatrixBlocks, _MeshMorpher, _MeshVertexProgram, _OriginalSkinNormals, _OriginalSkinRestored, _OriginalSkinVertices, _OriginalTGSpace, _Skinned, _VBufferOri, _VertexBufferHard, NL3D::IDriver::activeVertexBuffer(), NL3D::IDriver::activeVertexBufferHard(), NL3D::CMeshMorpher::BlendShapes, NL3D::CTravCameraScene::CamPos, NL3D::CMeshBaseInstance::getBlendShapeFactors(), NL3D::CTransform::getOwnerScene(), NL3D::CScene::getRenderTrav(), NL3D::CTransform::getSkeletonModel(), NL3D::CTransform::getWorldMatrix(), H_AUTO, NL3D::CMeshMorpher::init(), NL3D::CMeshMorpher::initSkinned(), NLMISC::CMatrix::inverted(), NL3D::CTransform::isSkinned(), NL3D::CMeshGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, nlassert, NLMISC::OptFastFloor(), NL3D::CMeshGeom::CRdrPass::PBlock, NL3D::CMeshBlender::prepareRenderForGlobalAlpha(), NL3D::CMeshGeom::CMatrixBlock::RdrPass, NL3D::IDriver::render(), restoreOriginalSkinVertices(), NL3D::CMeshBlender::restoreRender(), NL3D::IDriver::setupModelMatrix(), uint, uint32, uint8, NL3D::CMeshMorpher::update(), NL3D::CMeshMorpher::updateSkinned(), and updateVertexBufferHard(). Referenced by NL3D::CMesh::render(). { nlassert(drv); // get the mesh instance. CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans); // get a ptr on scene CScene *ownerScene= mi->getOwnerScene(); // get a ptr on renderTrav CRenderTrav *renderTrav= &ownerScene->getRenderTrav(); // update the VBufferHard (create/delete), to maybe render in AGP memory. updateVertexBufferHard (drv); /* currentVBHard is NULL if must disable it temporarily For now, never disable it, but switch of VBHard may be VERY EXPENSIVE if NV_vertex_array_range2 is not supported (old drivers). */ IVertexBufferHard *currentVBHard= _VertexBufferHard; // get the skeleton model to which I am binded (else NULL). CSkeletonModel *skeleton; skeleton= mi->getSkeletonModel(); // The mesh must not be skinned for render() nlassert(!(_Skinned && mi->isSkinned() && skeleton)); bool bMorphApplied = _MeshMorpher->BlendShapes.size() > 0; bool useTangentSpace = _MeshVertexProgram && _MeshVertexProgram->needTangentSpace(); // Profiling //=========== H_AUTO( NL3D_MeshGeom_RenderNormal ); // Morphing // ======== if (bMorphApplied) { // If _Skinned (NB: the skin is not applied) and if lod.OriginalSkinRestored, then restoreOriginalSkinPart is // not called but mush morpher write changed vertices into VBHard so its ok. The unchanged vertices // are written in the preceding call to restoreOriginalSkinPart. if (_Skinned) { _MeshMorpher->initSkinned(&_VBufferOri, &_VBuffer, currentVBHard, useTangentSpace, &_OriginalSkinVertices, &_OriginalSkinNormals, useTangentSpace ? &_OriginalTGSpace : NULL, false ); _MeshMorpher->updateSkinned (mi->getBlendShapeFactors()); } else // Not even skinned so we have to do all the stuff { _MeshMorpher->init(&_VBufferOri, &_VBuffer, currentVBHard, useTangentSpace); _MeshMorpher->update (mi->getBlendShapeFactors()); } } // Skinning // ======== // else setup instance matrix drv->setupModelMatrix(trans->getWorldMatrix()); // since instance skin is invalid but mesh is skinned , we must copy vertices/normals from original vertices. if (_Skinned) { // do it for this Lod only, and if cache say it is necessary. if (!_OriginalSkinRestored) restoreOriginalSkinVertices(); } // Setup meshVertexProgram //=========== // use MeshVertexProgram effect? bool useMeshVP= _MeshVertexProgram != NULL; if( useMeshVP ) { CMatrix invertedObjectMatrix; invertedObjectMatrix = trans->getWorldMatrix().inverted(); // really ok if success to begin VP useMeshVP= _MeshVertexProgram->begin(drv, ownerScene, mi, invertedObjectMatrix, renderTrav->CamPos); } // Render the mesh. //=========== // active VB. if(currentVBHard != NULL) drv->activeVertexBufferHard(currentVBHard); else drv->activeVertexBuffer(_VBuffer); // Global alpha used ? uint32 globalAlphaUsed= rdrFlags & IMeshGeom::RenderGlobalAlpha; uint8 globalAlphaInt=(uint8)NLMISC::OptFastFloor(globalAlpha*255); // For all _MatrixBlocks for(uint mb=0;mb<_MatrixBlocks.size();mb++) { CMatrixBlock &mBlock= _MatrixBlocks[mb]; if(mBlock.RdrPass.size()==0) continue; // Global alpha ? if (globalAlphaUsed) { bool gaDisableZWrite= (rdrFlags & IMeshGeom::RenderGADisableZWrite)?true:false; // Render all pass. for (uint i=0;i<mBlock.RdrPass.size();i++) { CRdrPass &rdrPass= mBlock.RdrPass[i]; // Render with the Materials of the MeshInstance. if ( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) || ( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) ) { // CMaterial Ref CMaterial &material=mi->Materials[rdrPass.MaterialId]; // Use a MeshBlender to modify material and driver. CMeshBlender blender; blender.prepareRenderForGlobalAlpha(material, drv, globalAlpha, globalAlphaInt, gaDisableZWrite); // Setup VP material if (useMeshVP) { if(currentVBHard) _MeshVertexProgram->setupForMaterial(material, drv, ownerScene, currentVBHard); else _MeshVertexProgram->setupForMaterial(material, drv, ownerScene, &_VBuffer); } // Render drv->render(rdrPass.PBlock, material); // Resetup material/driver blender.restoreRender(material, drv, gaDisableZWrite); } } } else { // Render all pass. for(uint i=0;i<mBlock.RdrPass.size();i++) { CRdrPass &rdrPass= mBlock.RdrPass[i]; // Render with the Materials of the MeshInstance. if( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) || ( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) ) { // CMaterial Ref CMaterial &material=mi->Materials[rdrPass.MaterialId]; // Setup VP material if (useMeshVP) { if(currentVBHard) _MeshVertexProgram->setupForMaterial(material, drv, ownerScene, currentVBHard); else _MeshVertexProgram->setupForMaterial(material, drv, ownerScene, &_VBuffer); } // render primitives drv->render(rdrPass.PBlock, material); } } } } // End VertexProgram effect if(useMeshVP) { // Apply it. _MeshVertexProgram->end(drv); } }

void NL3D::CMeshGeom::renderPass (  CMeshGeomRenderContext &  rdrCtx, CMeshBaseInstance *  inst, float  polygonCount, uint  rdrPass )  [virtual]

The framework call this method to render the current renderPass, with the current instance NB: if the material is blended, DON'T render it!! Implements NL3D::IMeshGeom. Definition at line 2075 of file mesh.cpp. References _MatrixBlocks, _SupportMBRFlags, NL3D::CRenderTrav::changeVPLightSetupMaterial(), NL3D::CMeshGeomRenderContext::Driver, NL3D::CMeshGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, MBRCurrentUseVP, NL3D::CMeshGeom::CRdrPass::PBlock, NL3D::CMeshGeom::CMatrixBlock::RdrPass, NL3D::IDriver::render(), NL3D::CMeshGeomRenderContext::RenderThroughVBHeap, NL3D::CMeshGeomRenderContext::RenderTrav, uint, and NL3D::CMeshGeom::CRdrPass::VBHeapPBlock. { CMatrixBlock &mBlock= _MatrixBlocks[0]; CRdrPass &rdrPass= mBlock.RdrPass[rdrPassId]; // Render with the Materials of the MeshInstance, only if not blended. if( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) ) ) { CMaterial &material= mi->Materials[rdrPass.MaterialId]; // MeshVertexProgram ? if( _SupportMBRFlags & MBRCurrentUseVP ) { rdrCtx.RenderTrav->changeVPLightSetupMaterial(material, false); } if(rdrCtx.RenderThroughVBHeap) // render shifted primitives rdrCtx.Driver->render(rdrPass.VBHeapPBlock, material); else // render primitives rdrCtx.Driver->render(rdrPass.PBlock, material); } }

void NL3D::CMeshGeom::renderSimpleWithMaterial (  IDriver *  drv, const CMatrix &  worldMatrix, CMaterial &  mat )

render the mesh geometry with a single material. Render is said "Simple" because no special features are used: mesh is rendered without VertexProgram (if it has one). mesh is rendered without Skinning. mesh is rendered without use of VertexBufferHard. mesh is rendered without MeshMorpher. ..... Definition at line 915 of file mesh.cpp. References _MatrixBlocks, NL3D::IDriver::activeVertexBuffer(), H_AUTO, nlassert, NL3D::CMeshGeom::CRdrPass::PBlock, NL3D::CMeshGeom::CMatrixBlock::RdrPass, NL3D::IDriver::render(), NL3D::IDriver::setupModelMatrix(), and uint. Referenced by NL3D::CMeshMultiLod::renderMeshGeom(). { H_AUTO( NL3D_MeshGeom_RenderSimpleWithMaterial ); nlassert(drv); // setup matrix drv->setupModelMatrix(worldMatrix); // Active simple VB. drv->activeVertexBuffer(_VBuffer); // For all _MatrixBlocks for(uint mb=0;mb<_MatrixBlocks.size();mb++) { CMatrixBlock &mBlock= _MatrixBlocks[mb]; if(mBlock.RdrPass.size()==0) continue; // Render all pass. for(uint i=0;i<mBlock.RdrPass.size();i++) { CRdrPass &rdrPass= mBlock.RdrPass[i]; // render primitives drv->render(rdrPass.PBlock, mat); } } }

void NL3D::CMeshGeom::renderSkin (  CTransformShape *  trans, float  alphaMRM )  [virtual]

render() this mesh as a skin Implements NL3D::IMeshGeom. Definition at line 788 of file mesh.cpp. References _MatrixBlocks, _MeshMorpher, _MeshVertexProgram, _OriginalSkinNormals, _OriginalSkinVertices, _OriginalTGSpace, _Skinned, _VBufferOri, _VertexBufferHard, NL3D::IDriver::activeVertexBuffer(), NL3D::IDriver::activeVertexBufferHard(), applySkin(), NL3D::CMeshMorpher::BlendShapes, NL3D::CTravCameraScene::CamPos, NL3D::CMeshBaseInstance::getBlendShapeFactors(), NL3D::CRenderTrav::getDriver(), NL3D::CTransform::getOwnerScene(), NL3D::CScene::getRenderTrav(), NL3D::CTransform::getSkeletonModel(), NL3D::CTransform::getWorldMatrix(), H_AUTO, NL3D::CMeshMorpher::initSkinned(), NLMISC::CMatrix::inverted(), NL3D::CTransform::isSkinned(), NL3D::CMeshGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, nlassert, NL3D::CMeshGeom::CRdrPass::PBlock, NL3D::CMeshGeom::CMatrixBlock::RdrPass, NL3D::IDriver::render(), uint, NL3D::CMeshMorpher::updateSkinned(), and updateVertexBufferHard(). Referenced by NL3D::CMeshInstance::renderSkin(). { // get the mesh instance. CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans); // get a ptr on scene CScene *ownerScene= mi->getOwnerScene(); // get a ptr on renderTrav CRenderTrav *renderTrav= &ownerScene->getRenderTrav(); // get a ptr on the driver IDriver *drv= renderTrav->getDriver(); nlassert(drv); // update the VBufferHard (create/delete), to maybe render in AGP memory. updateVertexBufferHard (drv); /* currentVBHard is NULL if must disable it temporarily For now, never disable it, but switch of VBHard may be VERY EXPENSIVE if NV_vertex_array_range2 is not supported (old drivers). */ IVertexBufferHard *currentVBHard= _VertexBufferHard; // get the skeleton model to which I am binded (else NULL). CSkeletonModel *skeleton; skeleton= mi->getSkeletonModel(); // must be skinned for renderSkin() nlassert(_Skinned && mi->isSkinned() && skeleton); bool bMorphApplied = _MeshMorpher->BlendShapes.size() > 0; bool useTangentSpace = _MeshVertexProgram && _MeshVertexProgram->needTangentSpace(); // Profiling //=========== H_AUTO( NL3D_MeshGeom_RenderSkinned ); // Morphing // ======== if (bMorphApplied) { // Since Skinned we must update original skin vertices and normals because skinning use it _MeshMorpher->initSkinned(&_VBufferOri, &_VBuffer, currentVBHard, useTangentSpace, &_OriginalSkinVertices, &_OriginalSkinNormals, useTangentSpace ? &_OriginalTGSpace : NULL, true ); _MeshMorpher->updateSkinned (mi->getBlendShapeFactors()); } // Skinning // ======== // NB: the skeleton matrix has already been setuped by CSkeletonModel // NB: the normalize flag has already been setuped by CSkeletonModel // apply the skinning: _VBuffer is modified. applySkin(skeleton); // Setup meshVertexProgram //=========== // use MeshVertexProgram effect? bool useMeshVP= _MeshVertexProgram != NULL; if( useMeshVP ) { CMatrix invertedObjectMatrix; invertedObjectMatrix = skeleton->getWorldMatrix().inverted(); // really ok if success to begin VP useMeshVP= _MeshVertexProgram->begin(drv, ownerScene, mi, invertedObjectMatrix, renderTrav->CamPos); } // Render the mesh. //=========== // active VB. if(currentVBHard != NULL) drv->activeVertexBufferHard(currentVBHard); else drv->activeVertexBuffer(_VBuffer); // For all _MatrixBlocks for(uint mb=0;mb<_MatrixBlocks.size();mb++) { CMatrixBlock &mBlock= _MatrixBlocks[mb]; if(mBlock.RdrPass.size()==0) continue; // Render all pass. for(uint i=0;i<mBlock.RdrPass.size();i++) { CRdrPass &rdrPass= mBlock.RdrPass[i]; // CMaterial Ref CMaterial &material=mi->Materials[rdrPass.MaterialId]; // Setup VP material if (useMeshVP) { if(currentVBHard) _MeshVertexProgram->setupForMaterial(material, drv, ownerScene, currentVBHard); else _MeshVertexProgram->setupForMaterial(material, drv, ownerScene, &_VBuffer); } // render primitives drv->render(rdrPass.PBlock, material); } } // End VertexProgram effect if(useMeshVP) { // Apply it. _MeshVertexProgram->end(drv); } }

void NL3D::CMeshGeom::restoreOriginalSkinVertices (   )  [private]

Definition at line 1663 of file mesh.cpp. References _MeshVertexProgram, _OriginalSkinNormals, _OriginalSkinRestored, _OriginalSkinVertices, _OriginalTGSpace, _Skinned, NL3D::CVertexBuffer::getNormalCoordPointer(), NL3D::CVertexBuffer::getNumTexCoordUsed(), NL3D::CVertexBuffer::getNumVertices(), NL3D::CVertexBuffer::getTexCoordPointer(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexFormat(), nlassert, and uint. Referenced by render(). { nlassert(_Skinned); // get num of vertices uint numVertices= _VBuffer.getNumVertices(); // Copy VBuffer content into Original vertices normals. if(_VBuffer.getVertexFormat() & CVertexBuffer::PositionFlag) { // copy vertices from VBuffer. (NB: unusefull geomorphed vertices are still copied, but doesn't matter). for(uint i=0; i<numVertices;i++) { *(CVector*)_VBuffer.getVertexCoordPointer(i)= _OriginalSkinVertices[i]; } } if(_VBuffer.getVertexFormat() & CVertexBuffer::NormalFlag) { // copy normals from VBuffer. (NB: unusefull geomorphed normals are still copied, but doesn't matter). for(uint i=0; i<numVertices;i++) { *(CVector*)_VBuffer.getNormalCoordPointer(i)= _OriginalSkinNormals[i]; } } if (_MeshVertexProgram && _MeshVertexProgram->needTangentSpace()) { uint numTexCoords = _VBuffer.getNumTexCoordUsed(); nlassert(numTexCoords >= 2); nlassert(_OriginalTGSpace.size() == numVertices); // copy tangent space vectors for(uint i = 0; i < numVertices; ++i) { *(CVector*)_VBuffer.getTexCoordPointer(i, numTexCoords - 1)= _OriginalTGSpace[i]; } } // cleared _OriginalSkinRestored= true; }

void NL3D::CMeshGeom::serial (  NLMISC::IStream &  f  )  throw (NLMISC::EStream) [virtual]

serial this mesh. Implements NLMISC::IStreamable. Definition at line 948 of file mesh.cpp. References nlassert, and sint. { /* Version 4: - BonesName. Version 3: - MeshVertexProgram. Version 2: - precompute of triangle order. (nothing more to load). Version 1: - added blend shapes Version 0: - separate serialisation CMesh / CMeshGeom. */ sint ver = f.serialVersion (4); // must have good original Skinned Vertex before writing. if( !f.isReading() && _Skinned && !_OriginalSkinRestored ) { restoreOriginalSkinVertices(); } // Version 4+: Array of bone name if (ver >= 4) { f.serialCont (_BonesName); } if (f.isReading()) { // Version3-: Bones index are in skeleton model id list _BoneIdComputed = (ver < 4); // In all case, must recompute usage of parents. _BoneIdExtended= false; } else { // Warning, if you have skinned this shape, you can't write it anymore because skinning id have been changed! nlassert (_BoneIdComputed==false); } // Version3+: MeshVertexProgram. if (ver >= 3) { IMeshVertexProgram *mvp= NULL; if(f.isReading()) { f.serialPolyPtr(mvp); _MeshVertexProgram= mvp; } else { mvp= _MeshVertexProgram; f.serialPolyPtr(mvp); } } else if(f.isReading()) { // release vp _MeshVertexProgram= NULL; } // TestYoyo //_MeshVertexProgram= NULL; // Version1+: _MeshMorpher. if (ver >= 1) f.serial (*_MeshMorpher); // serial geometry. f.serial (_VBuffer); f.serialCont (_MatrixBlocks); f.serial (_BBox); f.serial (_Skinned); // If _VertexBuffer changed, flag the VertexBufferHard. if(f.isReading()) { _VertexBufferHardDirty = true; // if >= version 2, reorder of triangles is precomputed, else compute it now. if(ver < 2 ) { optimizeTriangleOrder(); } } // Skinning: If Version < 4, _BonesName are not present, must compute _BonesId from localId // Else it is computed at first computeBonesId(). if(ver < 4) buildBoneUsageVer3(); // TestYoyo //_MeshVertexProgram= NULL; /*{ uint numTris= 0; for(uint i=0;i<_MatrixBlocks.size();i++) { for(uint j=0;j<_MatrixBlocks[i].RdrPass.size();j++) numTris+= _MatrixBlocks[i].RdrPass[j].PBlock.getNumTri(); } nlinfo("YOYO: %d Vertices. %d Triangles.", _VBuffer.getNumVertices(), numTris); }*/ // Some runtime not serialized compilation if(f.isReading()) compileRunTime(); }

void NL3D::CMeshGeom::setBlendShapes (  std::vector< CBlendShape > &  bs  )

Definition at line 449 of file mesh.cpp. References _MeshMorpher, NL3D::CMeshMorpher::BlendShapes, and compileRunTime(). Referenced by NL3D::CMesh::setBlendShapes(). { _MeshMorpher->BlendShapes = bs; // must update some RunTime parameters compileRunTime(); }

bool NL3D::CMeshGeom::sortPerMaterial (   )  const [virtual]

true if the sort criterion must be by material. Else, sort per instance. Implements NL3D::IMeshGeom. Definition at line 2006 of file mesh.cpp. References _SupportMBRFlags, and MBRSortPerMaterial. { return (_SupportMBRFlags & MBRSortPerMaterial)!=0; }

bool NL3D::CMeshGeom::supportMeshBlockRendering (   )  const [virtual]

true if this meshGeom support meshBlock rendering. return false if skinned/meshMorphed. Implements NL3D::IMeshGeom. Definition at line 2000 of file mesh.cpp. References _SupportMBRFlags. Referenced by profileSceneRender(), and NL3D::CMesh::supportMeshBlockRendering(). { return _SupportMBRFlags!=0; }

void NL3D::CMeshGeom::updateSkeletonUsage (  CSkeletonModel *  sm, bool  increment )

update Skeleton Usage. increment or decrement. computeBonesId must has been called before. Definition at line 1596 of file mesh.cpp. References _BonesIdExt, NL3D::CSkeletonModel::Bones, NL3D::CSkeletonModel::decBoneUsage(), NL3D::CSkeletonModel::incBoneUsage(), nlerror, and uint. Referenced by NL3D::CMesh::updateSkeletonUsage(). { // For all Bones used by this mesh. for(uint i=0; i<_BonesIdExt.size();i++) { uint boneId= _BonesIdExt[i]; // Some explicit Error. if(boneId>=sm->Bones.size()) nlerror(" Skin is incompatible with Skeleton: tries to use bone %d", boneId); // increment or decrement not Forced, because CMeshGeom use getActiveBoneSkinMatrix(). if(increment) sm->incBoneUsage(boneId, CSkeletonModel::UsageNormal); else sm->decBoneUsage(boneId, CSkeletonModel::UsageNormal); } }

void NL3D::CMeshGeom::updateVertexBufferHard (  IDriver *  drv  )  [private]

update the VertexBufferHard if NULL (ie not created or deleted by driver) or if VertexBufferDirty. Definition at line 523 of file mesh.cpp. References _MeshMorpher, _Skinned, _VertexBufferHard, _VertexBufferHardDirty, NL3D::CMeshMorpher::BlendShapes, NL3D::CVertexBuffer::getNumVertices(), NL3D::CVertexBuffer::getUVRouting(), NL3D::CVertexBuffer::getValueTypePointer(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexFormat(), NL3D::CVertexBuffer::getVertexSize(), nlassert, NL3D::IDriver::slowUnlockVertexBufferHard(), and NL3D::IDriver::supportVertexBufferHard(). Referenced by beginMesh(), render(), and renderSkin(). { if(!drv->supportVertexBufferHard()) return; /* If the mesh is skinned, still use normal CVertexBuffer. * \todo yoyo: optimize. not done now because CMesh Skinned are not so used in game, * and CMesh skinning is far not optimized (4 matrix mul all the time). Should use later the renderSkinGroupGeom() * scheme * Also, if the driver has slow VBhard unlock() (ie ATI gl extension), avoid use of them if MeshMorpher * is used. */ bool avoidVBHard; avoidVBHard= _Skinned || ( _MeshMorpher && _MeshMorpher->BlendShapes.size()>0 && drv->slowUnlockVertexBufferHard() ); if( _VertexBufferHardDirty && avoidVBHard ) { // delete possible old VBHard. if(_VertexBufferHard!=NULL) { // VertexBufferHard lifetime < Driver lifetime. nlassert(_Driver!=NULL); _Driver->deleteVertexBufferHard(_VertexBufferHard); } return; } // If the vbufferhard is not synced to the vbuffer. if(_VertexBufferHardDirty || _VertexBufferHard==NULL) { _VertexBufferHardDirty= false; // delete possible old VBHard. if(_VertexBufferHard!=NULL) { // VertexBufferHard lifetime < Driver lifetime. nlassert(_Driver!=NULL); _Driver->deleteVertexBufferHard(_VertexBufferHard); } // bkup drv in a refptr. (so we know if the vbuffer hard has to be deleted). _Driver= drv; // try to create new one, in AGP Ram _VertexBufferHard= _Driver->createVertexBufferHard(_VBuffer.getVertexFormat(), _VBuffer.getValueTypePointer (), _VBuffer.getNumVertices(), IDriver::VBHardAGP, _VBuffer.getUVRouting()); // If KO, use normal VertexBuffer. if(_VertexBufferHard==NULL) return; // else, setup and Fill it with VertexBuffer. else { // If the mesh is static: not skinned/no meshMorpher, then setup a static VBHard -> runs faster under NVidia if( !_Skinned && ( !_MeshMorpher || _MeshMorpher->BlendShapes.size()==0) ) _VertexBufferHard->lockHintStatic(true); // Fill VB void *vertexPtr= _VertexBufferHard->lock(); nlassert(_VBuffer.getVertexFormat() == _VertexBufferHard->getVertexFormat()); nlassert(_VBuffer.getNumVertices() == _VertexBufferHard->getNumVertices()); nlassert(_VBuffer.getVertexSize() == _VertexBufferHard->getVertexSize()); // \todo yoyo: TODO_DX8 and DX8 ??? // Because same internal format, just copy all block. memcpy(vertexPtr, _VBuffer.getVertexCoordPointer(), _VBuffer.getNumVertices() * _VBuffer.getVertexSize() ); _VertexBufferHard->unlock(); } } }

---

Field Documentation

NLMISC::CAABBoxExt NL3D::CMeshGeom::_BBox [private]

For clipping. Definition at line 662 of file mesh.h.

bool NL3D::CMeshGeom::_BoneIdComputed [private]

This boolean is true if the bones id have been passed in the skeleton. Definition at line 669 of file mesh.h. Referenced by build(), CMeshGeom(), and computeBonesId().

bool NL3D::CMeshGeom::_BoneIdExtended [private]

true if the _BonesIdExt have been computed (for bone Usage). Definition at line 671 of file mesh.h. Referenced by build(), CMeshGeom(), and computeBonesId().

std::vector<sint32> NL3D::CMeshGeom::_BonesId [private]

This array give the index in the skeleton of the local bones used. computed at first computeBoneId(). Definition at line 676 of file mesh.h. Referenced by buildBoneUsageVer3(), computeBonesId(), and getSkinBoneUsage().

std::vector<sint32> NL3D::CMeshGeom::_BonesIdExt [private]

Same as _BonesId but with parent of bones added. (used for bone usage). Definition at line 678 of file mesh.h. Referenced by computeBonesId(), and updateSkeletonUsage().

std::vector<std::string> NL3D::CMeshGeom::_BonesName [private]

This array give the name of the local bones used. Definition at line 674 of file mesh.h. Referenced by build(), and computeBonesId().

CRefPtr<IDriver> NL3D::CMeshGeom::_Driver [private]

This is the driver used to setup the vbuffer hard. error if a mesh has not the same driver in his life. Definition at line 686 of file mesh.h.

std::vector<CMatrixBlock> NL3D::CMeshGeom::_MatrixBlocks [private]

The matrix blocks. Definition at line 660 of file mesh.h. Referenced by applyMaterialRemap(), applySkin(), build(), buildBoneUsageVer3(), buildSkin(), compileRunTime(), computeBonesId(), computeMeshVBHeap(), getNbMatrixBlock(), getNbRdrPass(), getNumRdrPassesForInstance(), getNumRdrPassesForMesh(), getNumTriangles(), getRdrPassMaterial(), getRdrPassPrimitiveBlock(), optimizeTriangleOrder(), profileSceneRender(), render(), renderPass(), renderSimpleWithMaterial(), and renderSkin().

CMeshMorpher* NL3D::CMeshGeom::_MeshMorpher [private]

Definition at line 712 of file mesh.h. Referenced by build(), CMeshGeom(), compileRunTime(), getNbBlendShapes(), render(), renderSkin(), setBlendShapes(), updateVertexBufferHard(), and ~CMeshGeom().

NLMISC::CSmartPtr<IMeshVertexProgram> NL3D::CMeshGeom::_MeshVertexProgram [private]

Definition at line 716 of file mesh.h. Referenced by activeInstance(), beginMesh(), bkupOriginalSkinVertices(), build(), compileRunTime(), endMesh(), getVBHeapInfo(), hasMeshVertexProgram(), initInstance(), render(), renderSkin(), and restoreOriginalSkinVertices().

std::vector<CVector> NL3D::CMeshGeom::_OriginalSkinNormals [private]

Definition at line 652 of file mesh.h. Referenced by applySkin(), bkupOriginalSkinVertices(), render(), renderSkin(), and restoreOriginalSkinVertices().

bool NL3D::CMeshGeom::_OriginalSkinRestored [private]

This tells if the mesh VBuffer has coorect BindPos vertices. Definition at line 666 of file mesh.h. Referenced by applySkin(), CMeshGeom(), render(), and restoreOriginalSkinVertices().

std::vector<CVector> NL3D::CMeshGeom::_OriginalSkinVertices [private]

Skinning: this is the list of vertices (mirror of VBuffer), at the bind Pos. Potentially modified by the mesh morpher Definition at line 651 of file mesh.h. Referenced by applySkin(), bkupOriginalSkinVertices(), render(), renderSkin(), and restoreOriginalSkinVertices().

std::vector<CVector> NL3D::CMeshGeom::_OriginalTGSpace [private]

Definition at line 653 of file mesh.h. Referenced by applySkin(), bkupOriginalSkinVertices(), render(), renderSkin(), and restoreOriginalSkinVertices().

bool NL3D::CMeshGeom::_PreciseClipping [private]

Estimate if we must do a Precise clipping (ie with bboxes). Definition at line 709 of file mesh.h. Referenced by clip(), CMeshGeom(), and compileRunTime().

bool NL3D::CMeshGeom::_Skinned [private]

This tells if the mesh is correctly skinned. Definition at line 664 of file mesh.h. Referenced by bkupOriginalSkinVertices(), build(), buildBoneUsageVer3(), CMeshGeom(), compileRunTime(), isSkinned(), render(), renderSkin(), restoreOriginalSkinVertices(), and updateVertexBufferHard().

uint8 NL3D::CMeshGeom::_SupportMBRFlags [private]

setuped at compileRunTime. Definition at line 705 of file mesh.h. Referenced by activeInstance(), beginMesh(), compileRunTime(), endMesh(), getVBHeapInfo(), renderPass(), sortPerMaterial(), and supportMeshBlockRendering().

CVertexBuffer NL3D::CMeshGeom::_VBuffer [private]

VBuffer of the mesh (potentially modified by the mesh morpher and skinning). Definition at line 656 of file mesh.h.

CVertexBuffer NL3D::CMeshGeom::_VBufferOri [private]

The original VBuffer of the mesh used only if there are blend shapes. Definition at line 658 of file mesh.h. Referenced by render(), and renderSkin().

CRefPtr<IVertexBufferHard> NL3D::CMeshGeom::_VertexBufferHard [private]

The only one VBufferHard of the mesh. NULL by default. Definition at line 684 of file mesh.h. Referenced by beginMesh(), profileSceneRender(), render(), renderSkin(), updateVertexBufferHard(), and ~CMeshGeom().

bool NL3D::CMeshGeom::_VertexBufferHardDirty [private]

This tells if the VBuffer has changed since the last time or not. Definition at line 688 of file mesh.h. Referenced by build(), CMeshGeom(), and updateVertexBufferHard().

---

The documentation for this class was generated from the following files:

• mesh.h
• mesh.cpp

---