NL3D::CMeshMRMGeom Class Reference

#include <mesh_mrm.h>

Inheritance diagram for NL3D::CMeshMRMGeom:

---

Detailed Description

An MRM mesh geometry, with no materials information.

To build a CMeshMRMGeom, you should:

• build a CMesh::CMeshBuild meshBuild (see CMesh)
• call MeshMRMGeom.build(MeshBuild);

NB: internally, build() use CMRMBuilder, a builder of MRM.

Author:

Lionel Berenguier

Nevrax France

Date:

2001

Definition at line 81 of file mesh_mrm.h.

RawSkin optimisation.
uint	NumCacheVertexNormal1 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin1)
uint	NumCacheVertexNormal2 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin2)
uint	NumCacheVertexNormal3 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin3)
uint	NumCacheVertexNormal4 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin4)
uint	NumCacheVertexShadow = NL_BlockByteL1 / sizeof(CMeshMRMGeom::CShadowVertex)
void	applyArrayRawSkinNormal1 (CRawVertexNormalSkin1 *src, uint8 *destVertexPtr, CMatrix3x4 *boneMat3x4, uint nInf)
void	applyArrayRawSkinNormal2 (CRawVertexNormalSkin2 *src, uint8 *destVertexPtr, CMatrix3x4 *boneMat3x4, uint nInf)
void	applyArrayRawSkinNormal3 (CRawVertexNormalSkin3 *src, uint8 *destVertexPtr, CMatrix3x4 *boneMat3x4, uint nInf)
void	applyArrayRawSkinNormal4 (CRawVertexNormalSkin4 *src, uint8 *destVertexPtr, CMatrix3x4 *boneMat3x4, uint nInf)
void	dirtMeshDataId ()
	Increment the refCount, so instances RawSkins are no longer valid.
void	updateRawSkinNormal (bool enabled, CMeshMRMInstance *mi, sint curLodId)
	compute RawSkin info in the MRMInstance according to current skin setup.
uint	_MeshDataId
	Each time the mesh is loaded/built, this increment.
ShadowMap Skin rendering
void	applyArrayShadowSkin (CShadowVertex *src, CVector *dst, CSkeletonModel *skeleton, uint numVerts)
std::vector< uint32 >	_ShadowSkinTriangles
std::vector< CShadowVertex >	_ShadowSkinVertices
bool	_SupportShadowSkinGrouping
Hard VB
void	deleteVertexBufferHard ()
void	fillAGPSkinPartWithVBHardPtr (CLod &lod, uint8 *vertexDst)
void	updateVertexBufferHard (IDriver *drv, uint32 numVertices)
CRefPtr< IDriver >	_Driver
bool	_PreciseClipping
	NB: HERE FOR PACKING ONLY. For clipping. Estimate if we must do a Precise clipping (ie with bboxes).
CRefPtr< IVertexBufferHard >	_VBHard
bool	_VertexBufferHardDirty
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 &m, std::vector< CMesh::CMeshBuild * > &bsList, uint numMaxMaterial, const CMRMParameters &params=CMRMParameters())
void	changeMRMDistanceSetup (float distanceFinest, float distanceMiddle, float distanceCoarsest)
	CMeshMRMGeom ()
	Constructor.
virtual std::string	getClassName ()=0
const CMRMLevelDetail &	getLevelDetail () const
	get the MRM level detail information
virtual bool	hasMeshVertexProgram () const
	True if this mesh has a vertexProgram.
	~CMeshMRMGeom ()
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 bool	isActiveInstanceNeedVBFill () const
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 in a driver. true if visible.
virtual float	getNumTriangles (float distance)
	get an approximation of the number of triangles this instance will render for a fixed distance.
virtual void	initInstance (CMeshBaseInstance *mbi)
	Init instance info.
	NLMISC_DECLARE_CLASS (CMeshMRMGeom)
	clip this mesh in a driver. true if visible.
void	profileSceneRender (CRenderTrav *rdrTrav, CTransformShape *trans, float polygonCount, uint32 rdrFlags)
	Scene profile.
virtual void	render (IDriver *drv, CTransformShape *trans, float polygonCount, uint32 rdrFlags, float globalAlpha)
	render() this mesh in a driver, given an instance and his materials.
virtual void	renderSkin (CTransformShape *trans, float alphaMRM)
	render() this mesh as a skin
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
	serial this meshGeom.
Skinning Behavior
void	computeBonesId (CSkeletonModel *skeleton)
	Compute skinning id.
const std::vector< NLMISC::CBSphere > &	getSkinBoneSphere () const
	see CTransform::getSkinBoneSphere() doc for the meaning of this value. computeBonesId must has been called before.
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 std::vector< std::string > &	getBonesName () const
	get the bone names of the meshMRM.
const NLMISC::CAABBoxExt &	getBoundingBox () const
	get the extended axis aligned bounding box of the mesh
const std::vector< CMRMWedgeGeom > &	getGeomorphs (uint lodId) const
	Advanced. get the geomorphs for a special lod.
uint	getNbBlendShapes () const
	get the number of BlendShapes
uint	getNbLod () const
uint	getNbRdrPass (uint lodId) const
uint32	getRdrPassMaterial (uint lodId, uint renderingPassIndex) const
const CPrimitiveBlock &	getRdrPassPrimitiveBlock (uint lodId, uint renderingPassIndex) const
const std::vector< CMesh::CSkinWeight > &	getSkinWeights () const
	get the skinWeights used by the mrm mesh. NB: same size of the vertexBuffer. empty if !isSkinned()
const CVertexBuffer &	getVertexBuffer () const
	get the vertex buffer used by the mrm mesh. NB: this VB store all Vertices used by All LODs.
Lod management.
uint	getNbLodLoaded () const
void	loadFirstLod (NLMISC::IStream &f)
void	loadNextLod (NLMISC::IStream &f)
void	unloadNextLod (NLMISC::IStream &f)
ShadowMap Skin rendering
uint	getNumShadowSkinVertices () const
	Get the num of shadow skin vertices.
sint	renderShadowSkinGeom (CMeshMRMInstance *mi, uint remainingVertices, uint8 *vbDest)
	Get the num of shadow skin vertices.
void	renderShadowSkinPrimitives (CMeshMRMInstance *mi, CMaterial &castMat, IDriver *drv, uint baseVertex)
	Get the num of shadow skin vertices.
void	setShadowMesh (const std::vector< CShadowVertex > &shadowVertices, const std::vector< uint32 > &triangles)
	Setup the ShadowMesh.
bool	supportShadowSkinGrouping () const
	Render the ShadowSkin (SkinGroup like).
Special SkinGrouping Rendering
sint	renderSkinGroupGeom (CMeshMRMInstance *mi, float alphaMRM, uint remainingVertices, uint8 *vbDest)
void	renderSkinGroupPrimitives (CMeshMRMInstance *mi, uint baseVertex, std::vector< CSkinSpecularRdrPass > &specularRdrPasses, uint skinIndex)
void	renderSkinGroupSpecularRdrPass (CMeshMRMInstance *mi, uint rdrPassId)
bool	supportSkinGrouping () const
Private Member Functions
void	applyGeomorph (std::vector< CMRMWedgeGeom > &geoms, float alphaLod, IVertexBufferHard *currentVBHard)
	Apply the geomorph to the _VBuffer, or the VBhard, if exist/used.
void	applyGeomorphPosNormalUV0 (std::vector< CMRMWedgeGeom > &geoms, uint8 *vertexPtr, uint8 *vertexDestPtr, sint32 vertexSize, float a, float a1)
	Faster, but common geomorph apply.
void	applyGeomorphWithVBHardPtr (std::vector< CMRMWedgeGeom > &geoms, float alphaLod, uint8 *vertexDestPtr)
	Apply the geomorph to the VBhard ptr, if not NULL.
void	applyRawSkinWithNormal (CLod &lod, CRawSkinNormalCache &rawSkinLod, const CSkeletonModel *skeleton, uint8 *vbHard, float alphaLod)
void	applySkin (CLod &lod, const CSkeletonModel *skeleton)
	Skinning: Apply skinning to the _VBuffer (before geomorph).
void	applySkinWithNormal (CLod &lod, const CSkeletonModel *skeleton)
void	applySkinWithTangentSpace (CLod &lod, const CSkeletonModel *skeleton, uint tangentSpaceTexCoord)
void	bkupOriginalSkinVertices ()
	Skinning: bkup Vertex/Normal into _OriginalSkin* from VBuffer.
void	bkupOriginalSkinVerticesSubset (uint wedgeStart, uint wedgeEnd)
void	buildBoneUsageVer2 ()
sint	chooseLod (float alphaMRM, float &alphaLod)
	choose the lod according to the alphaMRM [0,1] given.
void	compileRunTime ()
void	load (NLMISC::IStream &f) throw (NLMISC::EStream)
	load this mesh.
sint	loadHeader (NLMISC::IStream &f) throw (NLMISC::EStream)
	load the header of this mesh. return the version of the header.
void	restoreOriginalSkinPart (CLod &lod, IVertexBufferHard *currentVBHard)
	Skinning: same as restoreOriginalSkinVertices(), but for one Lod only.
void	restoreOriginalSkinVertices ()
	Skinning: restore Vertex/Normal from _OriginalSkin* to VBuffer.
void	save (NLMISC::IStream &f) throw (NLMISC::EStream)
	save the entire mesh.
void	serialLodVertexData (NLMISC::IStream &f, uint startWedge, uint endWedge)
	serial a subset of the vertices.
void	updateShiftedTriangleCache (CMeshMRMInstance *mi, sint curLodId, uint baseVertex)
Private Attributes
NLMISC::CAABBoxExt	_BBox
	For clipping. this is the BB of all vertices of all Lods.
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.
std::vector< NLMISC::CBSphere >	_BonesSphere
	see CTransform::getSkinBoneSphere() doc for the meaning of this value
uint8	_LastLodComputed
	Last lod rendered. used with renderSkinGroup*() only.
std::vector< CLodInfo >	_LodInfos
	Info for pre-loading Lods.
std::vector< CLod >	_Lods
	List of Lods.
CMeshMorpher	_MeshMorpher
NLMISC::CSmartPtr< IMeshVertexProgram >	_MeshVertexProgram
uint	_NbLodLoaded
std::vector< CVector >	_OriginalSkinNormals
std::vector< CVector >	_OriginalSkinVertices
	Skinning: this is the list of vertices (mirror of VBuffer), at the bind Pos.
std::vector< CVector >	_OriginalTGSpace
bool	_Skinned
	Skinning: This tells if the mesh is correctly skinned (suuport skinning).
std::vector< CMesh::CSkinWeight >	_SkinWeights
	This is the array of SkinWeights, same size as the VB.
bool	_SupportSkinGrouping
	if true, then maybe use faster render
CVertexBuffer	_VBufferFinal
	The Final VBuffer.
CVertexBuffer	_VBufferOriginal
	The Original VBuffer.
CMRMLevelDetail	_LevelDetail
Mesh Block Render Implementation
bool	_MBRBkupNormalize
	BeginMesh setup.
sint	_MBRCurrentLodId
	global setup at activateInstance()
bool	_SupportMeshBlockRendering
	setuped at compileRunTime.
Friends
class	CMRMBuilder
Structures for building a MRM mesh.
class	CLod

---

Member Enumeration Documentation

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

---

Constructor & Destructor Documentation

NL3D::CMeshMRMGeom::CMeshMRMGeom (   )

Constructor. Definition at line 204 of file mesh_mrm.cpp. References _MBRCurrentLodId, _MeshDataId, _NbLodLoaded, _SupportMeshBlockRendering, _SupportShadowSkinGrouping, and _SupportSkinGrouping. { _VertexBufferHardDirty= true; _Skinned= false; _NbLodLoaded= 0; _BoneIdComputed = false; _BoneIdExtended = false; _PreciseClipping= false; _SupportSkinGrouping= false; _MeshDataId= 0; _SupportMeshBlockRendering= false; _MBRCurrentLodId= 0; _SupportShadowSkinGrouping= false; }

NL3D::CMeshMRMGeom::~CMeshMRMGeom (   )

Definition at line 221 of file mesh_mrm.cpp. References deleteVertexBufferHard(). { deleteVertexBufferHard(); }

---

Member Function Documentation

void NL3D::CMeshMRMGeom::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 2738 of file mesh_mrm.cpp. References _LevelDetail, _Lods, _MBRCurrentLodId, applyGeomorph(), applyGeomorphWithVBHardPtr(), NL3D::CTransformShape::changeLightSetup(), chooseLod(), NL3D::CMeshGeomRenderContext::Driver, NL3D::CMRMLevelDetail::getLevelDetailFromPolyCount(), NL3D::CTransform::getWorldMatrix(), H_AUTO, NL3D::CMeshGeomRenderContext::RenderThroughVBHeap, NL3D::CMeshGeomRenderContext::RenderTrav, NL3D::IDriver::setupModelMatrix(), and uint8. { H_AUTO( NL3D_MeshMRMGeom_RenderNormal ); if(_Lods.empty()) return; // get the result of the Load Balancing. float alphaMRM= _LevelDetail.getLevelDetailFromPolyCount(polygonCount); // choose the lod. float alphaLod; _MBRCurrentLodId= chooseLod(alphaMRM, alphaLod); // Geomorph the choosen Lod (if not the coarser mesh). if(_MBRCurrentLodId>0) { if(rdrCtx.RenderThroughVBHeap) applyGeomorphWithVBHardPtr(_Lods[_MBRCurrentLodId].Geomorphs, alphaLod, (uint8*)vbDst); else applyGeomorph(_Lods[_MBRCurrentLodId].Geomorphs, alphaLod, _VBHard); } // set the instance worldmatrix. rdrCtx.Driver->setupModelMatrix(inst->getWorldMatrix()); // setupLighting. inst->changeLightSetup(rdrCtx.RenderTrav); }

void NL3D::CMeshMRMGeom::applyArrayRawSkinNormal1 (  CRawVertexNormalSkin1 *  src, uint8 *  destVertexPtr, CMatrix3x4 *  boneMat3x4, uint  nInf )  [private]

Definition at line 895 of file mesh_mrm_skin.cpp.

void NL3D::CMeshMRMGeom::applyArrayRawSkinNormal2 (  CRawVertexNormalSkin2 *  src, uint8 *  destVertexPtr, CMatrix3x4 *  boneMat3x4, uint  nInf )  [private]

Definition at line 1074 of file mesh_mrm_skin.cpp.

void NL3D::CMeshMRMGeom::applyArrayRawSkinNormal3 (  CRawVertexNormalSkin3 *  src, uint8 *  destVertexPtr, CMatrix3x4 *  boneMat3x4, uint  nInf )  [private]

Definition at line 1377 of file mesh_mrm_skin.cpp.

void NL3D::CMeshMRMGeom::applyArrayRawSkinNormal4 (  CRawVertexNormalSkin4 *  src, uint8 *  destVertexPtr, CMatrix3x4 *  boneMat3x4, uint  nInf )  [private]

Definition at line 1771 of file mesh_mrm_skin.cpp.

void NL3D::CMeshMRMGeom::applyArrayShadowSkin (  CShadowVertex *  src, CVector *  dst, CSkeletonModel *  skeleton, uint  numVerts )  [private]

Definition at line 339 of file mesh_mrm_skin.cpp. References _Lods, NL3D::computeBoneMatrixes3x4(), NL3D::CMeshMRMGeom::CLod::MatrixInfluences, min, NumCacheVertexShadow, src, and uint. Referenced by renderShadowSkinGeom(). { // For all matrix this Mesh use. (the shadow geometry cannot use other Matrix than the mesh use). // NB: take the best lod since the lower lods cannot use other Matrix than the higher one. static vector<CMatrix3x4> boneMat3x4; CLod &lod= _Lods[_Lods.size()-1]; computeBoneMatrixes3x4(boneMat3x4, lod.MatrixInfluences, skeleton); // Then do the skin for(;numVerts>0;) { // number of vertices to process for this block. uint nBlockInf= min(NumCacheVertexShadow, numVerts); // next block. numVerts-= nBlockInf; // cache the data in L1 cache. CFastMem::precache(src, nBlockInf * sizeof(CShadowVertex)); // for all InfluencedVertices only. for(;nBlockInf>0;nBlockInf--, src++, dst++) { boneMat3x4[ src->MatrixId ].mulSetPoint( src->Vertex, *dst ); } } }

void NL3D::CMeshMRMGeom::applyGeomorph (  std::vector< CMRMWedgeGeom > &  geoms, float  alphaLod, IVertexBufferHard *  currentVBHard )  [private]

Apply the geomorph to the _VBuffer, or the VBhard, if exist/used. Definition at line 477 of file mesh_mrm.cpp. References _VBufferFinal, applyGeomorphWithVBHardPtr(), NL3D::IVertexBufferHard::getVertexSize(), NL3D::CVertexBuffer::getVertexSize(), NL3D::IVertexBufferHard::lock(), nlassert, uint8, and NL3D::IVertexBufferHard::unlock(). Referenced by activeInstance(), render(), and renderSkin(). { if(currentVBHard!=NULL) { // must write into it uint8 *vertexDestPtr= (uint8*)currentVBHard->lock(); nlassert(_VBufferFinal.getVertexSize() == currentVBHard->getVertexSize()); // apply the geomorph applyGeomorphWithVBHardPtr(geoms, alphaLod, vertexDestPtr); // unlock. ATI: copy only geomorphed vertices. currentVBHard->unlock(0, geoms.size()); } else applyGeomorphWithVBHardPtr(geoms, alphaLod, NULL); }

void NL3D::CMeshMRMGeom::applyGeomorphPosNormalUV0 (  std::vector< CMRMWedgeGeom > &  geoms, uint8 *  vertexPtr, uint8 *  vertexDestPtr, sint32  vertexSize, float  a, float  a1 )  [private]

Faster, but common geomorph apply. Definition at line 817 of file mesh_mrm.cpp. References NL3D::CMRMWedgeGeom::End, nlassert, sint32, NL3D::CMRMWedgeGeom::Start, uint, and uint8. Referenced by applyGeomorphWithVBHardPtr(). { nlassert(vertexSize==32); // For all geomorphs. uint nGeoms= geoms.size(); CMRMWedgeGeom *ptrGeom= &(geoms[0]); uint8 *destPtr= vertexDestPtr; for(; nGeoms>0; nGeoms--, ptrGeom++, destPtr+= vertexSize ) { // Consider the Pos/Normal/UV as an array of 8 float to interpolate. float *start= (float*)(vertexPtr + (ptrGeom->Start<<5)); float *end= (float*)(vertexPtr + (ptrGeom->End<<5)); float *dst= (float*)(destPtr); // unrolled dst[0]= start[0] * a + end[0]* a1; dst[1]= start[1] * a + end[1]* a1; dst[2]= start[2] * a + end[2]* a1; dst[3]= start[3] * a + end[3]* a1; dst[4]= start[4] * a + end[4]* a1; dst[5]= start[5] * a + end[5]* a1; dst[6]= start[6] * a + end[6]* a1; dst[7]= start[7] * a + end[7]* a1; } }

void NL3D::CMeshMRMGeom::applyGeomorphWithVBHardPtr (  std::vector< CMRMWedgeGeom > &  geoms, float  alphaLod, uint8 *  vertexDestPtr )  [private]

Apply the geomorph to the VBhard ptr, if not NULL. Definition at line 498 of file mesh_mrm.cpp. References _VBufferFinal, applyGeomorphPosNormalUV0(), NLMISC::CRGBA::blendFromui(), NLMISC::clamp(), NL3D::CMRMWedgeGeom::End, NL3D::CVertexBuffer::getColorOff(), NL3D::CVertexBuffer::getNormalOff(), NL3D::CVertexBuffer::getSpecularOff(), NL3D::CVertexBuffer::getTexCoordOff(), NL3D::CVertexBuffer::getValueType(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexFormat(), NL3D::CVertexBuffer::getVertexSize(), nlassert, sint32, NL3D::CMRMWedgeGeom::Start, uint, and uint8. Referenced by activeInstance(), and applyGeomorph(). { // no geomorphs? quit. if(geoms.size()==0) return; clamp(alphaLod, 0.f, 1.f); float a= alphaLod; float a1= 1 - alphaLod; // info from VBuffer. uint8 *vertexPtr= (uint8*)_VBufferFinal.getVertexCoordPointer(); uint flags= _VBufferFinal.getVertexFormat(); sint32 vertexSize= _VBufferFinal.getVertexSize(); // because of the unrolled code for 4 first UV, must assert this. nlassert(CVertexBuffer::MaxStage>=4); // must have XYZ. nlassert(flags & CVertexBuffer::PositionFlag); // If VBuffer Hard disabled if(vertexDestPtr==NULL) { // write into vertexPtr. vertexDestPtr= vertexPtr; } // if it is a common format if( flags== (CVertexBuffer::PositionFlag | CVertexBuffer::NormalFlag | CVertexBuffer::TexCoord0Flag) && _VBufferFinal.getValueType(CVertexBuffer::TexCoord0) == CVertexBuffer::Float2 ) { // use a faster method applyGeomorphPosNormalUV0(geoms, vertexPtr, vertexDestPtr, vertexSize, a, a1); } else { // for color interp uint i; uint ua= (uint)(a*256); clamp(ua, (uint)0, (uint)256); uint ua1= 256 - ua; // if an offset is 0, it means that the component is not in the VBuffer. sint32 normalOff; sint32 colorOff; sint32 specularOff; sint32 uvOff[CVertexBuffer::MaxStage]; bool has3Coords[CVertexBuffer::MaxStage]; // Compute offset of each component of the VB. if(flags & CVertexBuffer::NormalFlag) normalOff= _VBufferFinal.getNormalOff(); else normalOff= 0; if(flags & CVertexBuffer::PrimaryColorFlag) colorOff= _VBufferFinal.getColorOff(); else colorOff= 0; if(flags & CVertexBuffer::SecondaryColorFlag) specularOff= _VBufferFinal.getSpecularOff(); else specularOff= 0; for(i= 0; i<CVertexBuffer::MaxStage;i++) { if(flags & (CVertexBuffer::TexCoord0Flag<<i)) { uvOff[i]= _VBufferFinal.getTexCoordOff(i); has3Coords[i] = (_VBufferFinal.getValueType(i + CVertexBuffer::TexCoord0) == CVertexBuffer::Float3); } else { uvOff[i]= 0; } } // For all geomorphs. uint nGeoms= geoms.size(); CMRMWedgeGeom *ptrGeom= &(geoms[0]); uint8 *destPtr= vertexDestPtr; /* NB: optimisation: lot of "if" in this Loop, but because of BTB, they always cost nothing (prediction is good). NB: this also is why we unroll the 4 1st Uv. The other (if any), are done in the other loop. NB: optimisation for AGP write cominers: the order of write (vertex, normal, uvs...) is important for good use of AGP write combiners. We have 2 version : one that tests for 3 coordinates texture coords, and one that doesn't */ if (!has3Coords[0] && !has3Coords[1] && !has3Coords[2] && !has3Coords[3]) { // there are no texture coordinate of dimension 3 for(; nGeoms>0; nGeoms--, ptrGeom++, destPtr+= vertexSize ) { uint8 *startPtr= vertexPtr + ptrGeom->Start*vertexSize; uint8 *endPtr= vertexPtr + ptrGeom->End*vertexSize; // Vertex. { CVector *start= (CVector*)startPtr; CVector *end= (CVector*)endPtr; CVector *dst= (CVector*)destPtr; *dst= *start * a + *end * a1; } // Normal. if(normalOff) { CVector *start= (CVector*)(startPtr + normalOff); CVector *end= (CVector*)(endPtr + normalOff); CVector *dst= (CVector*)(destPtr + normalOff); *dst= *start * a + *end * a1; } // Uvs. // uv[0]. if(uvOff[0]) { // Uv. CUV *start= (CUV*)(startPtr + uvOff[0]); CUV *end= (CUV*)(endPtr + uvOff[0]); CUV *dst= (CUV*)(destPtr + uvOff[0]); *dst= *start * a + *end * a1; } // uv[1]. if(uvOff[1]) { // Uv. CUV *start= (CUV*)(startPtr + uvOff[1]); CUV *end= (CUV*)(endPtr + uvOff[1]); CUV *dst= (CUV*)(destPtr + uvOff[1]); *dst= *start * a + *end * a1; } // uv[2]. if(uvOff[2]) { CUV *start= (CUV*)(startPtr + uvOff[2]); CUV *end= (CUV*)(endPtr + uvOff[2]); CUV *dst= (CUV*)(destPtr + uvOff[2]); *dst= *start * a + *end * a1; } // uv[3]. if(uvOff[3]) { // Uv. CUV *start= (CUV*)(startPtr + uvOff[3]); CUV *end= (CUV*)(endPtr + uvOff[3]); CUV *dst= (CUV*)(destPtr + uvOff[3]); *dst= *start * a + *end * a1; } } } else // THERE ARE TEXTURE COORDINATES OF DIMENSION 3 { for(; nGeoms>0; nGeoms--, ptrGeom++, destPtr+= vertexSize ) { uint8 *startPtr= vertexPtr + ptrGeom->Start*vertexSize; uint8 *endPtr= vertexPtr + ptrGeom->End*vertexSize; // Vertex. { CVector *start= (CVector*)startPtr; CVector *end= (CVector*)endPtr; CVector *dst= (CVector*)destPtr; *dst= *start * a + *end * a1; } // Normal. if(normalOff) { CVector *start= (CVector*)(startPtr + normalOff); CVector *end= (CVector*)(endPtr + normalOff); CVector *dst= (CVector*)(destPtr + normalOff); *dst= *start * a + *end * a1; } // Uvs. // uv[0]. if(uvOff[0]) { if (!has3Coords[0]) { // Uv. CUV *start= (CUV*)(startPtr + uvOff[0]); CUV *end= (CUV*)(endPtr + uvOff[0]); CUV *dst= (CUV*)(destPtr + uvOff[0]); *dst= *start * a + *end * a1; } else { // Uv. CUVW *start= (CUVW*)(startPtr + uvOff[0]); CUVW *end= (CUVW*)(endPtr + uvOff[0]); CUVW *dst= (CUVW*)(destPtr + uvOff[0]); *dst= *start * a + *end * a1; } } // uv[1]. if(uvOff[1]) { if (!has3Coords[1]) { // Uv. CUV *start= (CUV*)(startPtr + uvOff[1]); CUV *end= (CUV*)(endPtr + uvOff[1]); CUV *dst= (CUV*)(destPtr + uvOff[1]); *dst= *start * a + *end * a1; } else { // Uv. CUVW *start= (CUVW*)(startPtr + uvOff[1]); CUVW *end= (CUVW*)(endPtr + uvOff[1]); CUVW *dst= (CUVW*)(destPtr + uvOff[1]); *dst= *start * a + *end * a1; } } // uv[2]. if(uvOff[2]) { if (!has3Coords[2]) { // Uv. CUV *start= (CUV*)(startPtr + uvOff[2]); CUV *end= (CUV*)(endPtr + uvOff[2]); CUV *dst= (CUV*)(destPtr + uvOff[2]); *dst= *start * a + *end * a1; } else { // Uv. CUVW *start= (CUVW*)(startPtr + uvOff[2]); CUVW *end= (CUVW*)(endPtr + uvOff[2]); CUVW *dst= (CUVW*)(destPtr + uvOff[2]); *dst= *start * a + *end * a1; } } // uv[3]. if(uvOff[3]) { if (!has3Coords[3]) { // Uv. CUV *start= (CUV*)(startPtr + uvOff[3]); CUV *end= (CUV*)(endPtr + uvOff[3]); CUV *dst= (CUV*)(destPtr + uvOff[3]); *dst= *start * a + *end * a1; } else { // Uv. CUVW *start= (CUVW*)(startPtr + uvOff[3]); CUVW *end= (CUVW*)(endPtr + uvOff[3]); CUVW *dst= (CUVW*)(destPtr + uvOff[3]); *dst= *start * a + *end * a1; } } // color. if(colorOff) { CRGBA *start= (CRGBA*)(startPtr + colorOff); CRGBA *end= (CRGBA*)(endPtr + colorOff); CRGBA *dst= (CRGBA*)(destPtr + colorOff); dst->blendFromui(*start, *end, ua1); } // specular. if(specularOff) { CRGBA *start= (CRGBA*)(startPtr + specularOff); CRGBA *end= (CRGBA*)(endPtr + specularOff); CRGBA *dst= (CRGBA*)(destPtr + specularOff); dst->blendFromui(*start, *end, ua1); } } } // Process extra UVs (maybe never, so don't bother optims :)). // For all stages after 4. for(i=4;i<CVertexBuffer::MaxStage;i++) { uint nGeoms= geoms.size(); CMRMWedgeGeom *ptrGeom= &(geoms[0]); uint8 *destPtr= vertexDestPtr; if(uvOff[i]==0) continue; // For all geomorphs. for(; nGeoms>0; nGeoms--, ptrGeom++, destPtr+= vertexSize ) { uint8 *startPtr= vertexPtr + ptrGeom->Start*vertexSize; uint8 *endPtr= vertexPtr + ptrGeom->End*vertexSize; // uv[i]. // Uv. if (!has3Coords[i]) { CUV *start= (CUV*)(startPtr + uvOff[i]); CUV *end= (CUV*)(endPtr + uvOff[i]); CUV *dst= (CUV*)(destPtr + uvOff[i]); *dst= *start * a + *end * a1; } else { CUVW *start= (CUVW*)(startPtr + uvOff[i]); CUVW *end= (CUVW*)(endPtr + uvOff[i]); CUVW *dst= (CUVW*)(destPtr + uvOff[i]); *dst= *start * a + *end * a1; } } } } }

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

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

void NL3D::CMeshMRMGeom::applyRawSkinWithNormal (  CLod &  lod, CRawSkinNormalCache &  rawSkinLod, const CSkeletonModel *  skeleton, uint8 *  vbHard, float  alphaLod )  [private]

Definition at line 1825 of file mesh_mrm_skin.cpp. Referenced by renderSkinGroupGeom().

void NL3D::CMeshMRMGeom::applySkin (  CLod &  lod, const CSkeletonModel *  skeleton )  [private]

Skinning: Apply skinning to the _VBuffer (before geomorph). Definition at line 207 of file mesh_mrm_skin.cpp. References _SkinWeights, _VBufferFinal, NL3D::computeBoneMatrixes3x4(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexFormat(), NL3D::CVertexBuffer::getVertexSize(), index, NL3D::CMeshMRMGeom::CLod::InfluencedVertices, NL3D::CMesh::CSkinWeight::MatrixId, NL3D::CMeshMRMGeom::CLod::MatrixInfluences, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, sint32, uint, uint32, uint8, and NL3D::CMesh::CSkinWeight::Weights. Referenced by renderSkin(). { nlassert(_Skinned); if(_SkinWeights.size()==0) return; // get vertexPtr. //=========================== uint8 *destVertexPtr= (uint8*)_VBufferFinal.getVertexCoordPointer(); uint flags= _VBufferFinal.getVertexFormat(); sint32 vertexSize= _VBufferFinal.getVertexSize(); // must have XYZ. nlassert(flags & CVertexBuffer::PositionFlag); // compute src array. CMesh::CSkinWeight *srcSkinPtr; CVector *srcVertexPtr; srcSkinPtr= &_SkinWeights[0]; srcVertexPtr= &_OriginalSkinVertices[0]; // Compute usefull Matrix for this lod. //=========================== // Those arrays map the array of bones in skeleton. static vector<CMatrix3x4> boneMat3x4; computeBoneMatrixes3x4(boneMat3x4, lod.MatrixInfluences, skeleton); // apply skinning. //=========================== // assert, code below is written especially for 4 per vertex. nlassert(NL3D_MESH_SKINNING_MAX_MATRIX==4); for(uint i=0;i<NL3D_MESH_SKINNING_MAX_MATRIX;i++) { uint nInf= lod.InfluencedVertices[i].size(); if( nInf==0 ) continue; uint32 *infPtr= &(lod.InfluencedVertices[i][0]); // apply the skin to the vertices switch(i) { //========= case 0: // Special case for Vertices influenced by one matrix. Just copy result of mul. // for all InfluencedVertices only. for(;nInf>0;nInf--, infPtr++) { uint index= *infPtr; CMesh::CSkinWeight *srcSkin= srcSkinPtr + index; CVector *srcVertex= srcVertexPtr + index; uint8 *dstVertexVB= destVertexPtr + index * vertexSize; CVector *dstVertex= (CVector*)(dstVertexVB); // Vertex. boneMat3x4[ srcSkin->MatrixId[0] ].mulSetPoint( *srcVertex, *dstVertex); } break; //========= case 1: // for all InfluencedVertices only. for(;nInf>0;nInf--, infPtr++) { uint index= *infPtr; CMesh::CSkinWeight *srcSkin= srcSkinPtr + index; CVector *srcVertex= srcVertexPtr + index; uint8 *dstVertexVB= destVertexPtr + index * vertexSize; CVector *dstVertex= (CVector*)(dstVertexVB); // Vertex. boneMat3x4[ srcSkin->MatrixId[0] ].mulSetPoint( *srcVertex, srcSkin->Weights[0], *dstVertex); boneMat3x4[ srcSkin->MatrixId[1] ].mulAddPoint( *srcVertex, srcSkin->Weights[1], *dstVertex); } break; //========= case 2: // for all InfluencedVertices only. for(;nInf>0;nInf--, infPtr++) { uint index= *infPtr; CMesh::CSkinWeight *srcSkin= srcSkinPtr + index; CVector *srcVertex= srcVertexPtr + index; uint8 *dstVertexVB= destVertexPtr + index * vertexSize; CVector *dstVertex= (CVector*)(dstVertexVB); // Vertex. boneMat3x4[ srcSkin->MatrixId[0] ].mulSetPoint( *srcVertex, srcSkin->Weights[0], *dstVertex); boneMat3x4[ srcSkin->MatrixId[1] ].mulAddPoint( *srcVertex, srcSkin->Weights[1], *dstVertex); boneMat3x4[ srcSkin->MatrixId[2] ].mulAddPoint( *srcVertex, srcSkin->Weights[2], *dstVertex); } break; //========= case 3: // for all InfluencedVertices only. for(;nInf>0;nInf--, infPtr++) { uint index= *infPtr; CMesh::CSkinWeight *srcSkin= srcSkinPtr + index; CVector *srcVertex= srcVertexPtr + index; uint8 *dstVertexVB= destVertexPtr + index * vertexSize; CVector *dstVertex= (CVector*)(dstVertexVB); // Vertex. boneMat3x4[ srcSkin->MatrixId[0] ].mulSetPoint( *srcVertex, srcSkin->Weights[0], *dstVertex); boneMat3x4[ srcSkin->MatrixId[1] ].mulAddPoint( *srcVertex, srcSkin->Weights[1], *dstVertex); boneMat3x4[ srcSkin->MatrixId[2] ].mulAddPoint( *srcVertex, srcSkin->Weights[2], *dstVertex); boneMat3x4[ srcSkin->MatrixId[3] ].mulAddPoint( *srcVertex, srcSkin->Weights[3], *dstVertex); } break; } } }

void NL3D::CMeshMRMGeom::applySkinWithNormal (  CLod &  lod, const CSkeletonModel *  skeleton )  [private]

The same as apply skin, but with normal modified. Normal is not normalized. 4 versions from slower to faster. Definition at line 741 of file mesh_mrm_skin.cpp. Referenced by renderSkin().

void NL3D::CMeshMRMGeom::applySkinWithTangentSpace (  CLod &  lod, const CSkeletonModel *  skeleton, uint  tangentSpaceTexCoord )  [private]

The same as apply skin with normal, but with a tangent space added (encoded in a texture coordinate). The tangent space is modified, but not normalized (must be done in a vertex program). 4 versions from slower to faster. Definition at line 804 of file mesh_mrm_skin.cpp. Referenced by renderSkin().

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

The framework call this method when he will render instances of this meshGeom soon. Implements NL3D::IMeshGeom. Definition at line 2705 of file mesh_mrm.cpp. References _Lods, _MBRBkupNormalize, _VBufferFinal, NL3D::IDriver::activeVertexBuffer(), NL3D::IDriver::activeVertexBufferHard(), NL3D::CMeshGeomRenderContext::Driver, NL3D::IDriver::forceNormalize(), NL3D::CVertexBuffer::getNumVertices(), NL3D::IDriver::isForceNormalize(), NL3D::CMeshGeomRenderContext::RenderThroughVBHeap, and updateVertexBufferHard(). { if(_Lods.empty()) return; IDriver *drv= rdrCtx.Driver; if(rdrCtx.RenderThroughVBHeap) { // Don't setup VB in this case, since use the VBHeap setuped one. } else { updateVertexBufferHard(drv, _VBufferFinal.getNumVertices()); // active VB. if(_VBHard) { drv->activeVertexBufferHard(_VBHard); } else { drv->activeVertexBuffer(_VBufferFinal); } } // force normalisation of normals.. _MBRBkupNormalize= drv->isForceNormalize(); drv->forceNormalize(true); }

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

Skinning: bkup Vertex/Normal into _OriginalSkin* from VBuffer. Definition at line 2045 of file mesh_mrm.cpp. References _VBufferFinal, bkupOriginalSkinVerticesSubset(), NL3D::CVertexBuffer::getNumVertices(), and nlassert. Referenced by build(). { nlassert(_Skinned); // bkup the entire array. bkupOriginalSkinVerticesSubset(0, _VBufferFinal.getNumVertices()); }

void NL3D::CMeshMRMGeom::bkupOriginalSkinVerticesSubset (  uint  wedgeStart, uint  wedgeEnd )  [private]

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

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

Build a mesh, replacing old. this is much slower than CMeshGeom::build(), because it computes the MRM. Parameters: params  parameters of the MRM build process. Definition at line 246 of file mesh_mrm.cpp. References _LevelDetail, _LodInfos, _Lods, _NbLodLoaded, _SkinWeights, _VBufferFinal, bkupOriginalSkinVertices(), NL3D::CMeshMRMGeom::CMeshBuildMRM::BlendShapes, NL3D::CMeshMorpher::BlendShapes, NL3D::CMesh::CMeshBuild::BonesNames, NL3D::CMRMLevelDetail::compileDistanceSetup(), NL3D::CMRMBuilder::compileMRM(), compileRunTime(), dirtMeshDataId(), NL3D::CMeshMRMGeom::CMeshBuildMRM::DistanceCoarsest, NL3D::CMRMLevelDetail::DistanceCoarsest, NL3D::CMeshMRMGeom::CMeshBuildMRM::DistanceFinest, NL3D::CMRMLevelDetail::DistanceFinest, NL3D::CMeshMRMGeom::CMeshBuildMRM::DistanceMiddle, NL3D::CMRMLevelDetail::DistanceMiddle, NL3D::CMesh::CMeshBuild::Faces, NL3D::CPrimitiveBlock::getNumTriangles(), NL3D::CMeshMRMGeom::CMeshBuildMRM::Lods, NL3D::makeBBox(), matrix, NL3D::CMRMLevelDetail::MaxFaceUsed, NL3D::CMesh::CMeshBuild::MeshVertexProgram, NL3D::CMRMLevelDetail::MinFaceUsed, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, params, NL3D::CMeshMRMGeom::CRdrPass::PBlock, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::CVertexBuffer::reserve(), NLMISC::CAABBoxExt::setCenter(), NL3D::CVertexBuffer::setNumVertices(), NLMISC::CAABBoxExt::setSize(), NL3D::CMeshMRMGeom::CMeshBuildMRM::Skinned, NL3D::CMeshMRMGeom::CMeshBuildMRM::SkinWeights, uint, uint32, NL3D::CMeshMRMGeom::CMeshBuildMRM::VBuffer, and NL3D::CMesh::CMeshBuild::Vertices. Referenced by NL3D::CMeshMRM::build(). { // Dirt the VBuffer. _VertexBufferHardDirty= true; // Empty geometry? if(m.Vertices.size()==0 || m.Faces.size()==0) { _VBufferFinal.setNumVertices(0); _VBufferFinal.reserve(0); _Lods.clear(); _BBox.setCenter(CVector::Null); _BBox.setSize(CVector::Null); return; } nlassert(numMaxMaterial>0); // SmartPtr Copy VertexProgram effect. //================================================ this->_MeshVertexProgram= m.MeshVertexProgram; //====================== // NB: this is equivalent as building BBox from MRM VBuffer, because CMRMBuilder create new vertices // which are just interpolation of original vertices. _BBox= makeBBox(m.Vertices); //================================================ CMRMBuilder mrmBuilder; CMeshBuildMRM meshBuildMRM; mrmBuilder.compileMRM(m, bsList, params, meshBuildMRM, numMaxMaterial); // Then just copy result! //================================================ _VBufferFinal= meshBuildMRM.VBuffer; _Lods= meshBuildMRM.Lods; _Skinned= meshBuildMRM.Skinned; _SkinWeights= meshBuildMRM.SkinWeights; // Compute degradation control. //================================================ _LevelDetail.DistanceFinest= meshBuildMRM.DistanceFinest; _LevelDetail.DistanceMiddle= meshBuildMRM.DistanceMiddle; _LevelDetail.DistanceCoarsest= meshBuildMRM.DistanceCoarsest; nlassert(_LevelDetail.DistanceFinest>=0); nlassert(_LevelDetail.DistanceMiddle > _LevelDetail.DistanceFinest); nlassert(_LevelDetail.DistanceCoarsest > _LevelDetail.DistanceMiddle); // Compute OODistDelta and DistancePow _LevelDetail.compileDistanceSetup(); // Build the _LodInfos. //================================================ _LodInfos.resize(_Lods.size()); uint32 precNWedges= 0; uint i; for(i=0;i<_Lods.size();i++) { _LodInfos[i].StartAddWedge= precNWedges; _LodInfos[i].EndAddWedges= _Lods[i].NWedges; precNWedges= _Lods[i].NWedges; // LodOffset is filled in serial() when stream is input. } // After build, all lods are present in memory. _NbLodLoaded= _Lods.size(); // For load balancing. //================================================ // compute Max Face Used _LevelDetail.MaxFaceUsed= 0; _LevelDetail.MinFaceUsed= 0; // Count of primitive block if(_Lods.size()>0) { uint pb; // Compute MinFaces. CLod &firstLod= _Lods[0]; for (pb=0; pb<firstLod.RdrPass.size(); pb++) { CRdrPass &pass= firstLod.RdrPass[pb]; // Sum tri _LevelDetail.MinFaceUsed+= pass.PBlock.getNumTriangles (); } // Compute MaxFaces. CLod &lastLod= _Lods[_Lods.size()-1]; for (pb=0; pb<lastLod.RdrPass.size(); pb++) { CRdrPass &pass= lastLod.RdrPass[pb]; // Sum tri _LevelDetail.MaxFaceUsed+= pass.PBlock.getNumTriangles (); } } // For skinning. //================================================ if( _Skinned ) { bkupOriginalSkinVertices(); } // Inform that the mesh data has changed dirtMeshDataId(); // For AGP SKinning optim, and for Render optim //================================================ for(i=0;i<_Lods.size();i++) { _Lods[i].buildSkinVertexBlocks(); // sort triangles for better cache use. _Lods[i].optimizeTriangleOrder(); } // Copy Blend Shapes //================================================ _MeshMorpher.BlendShapes = meshBuildMRM.BlendShapes; // Compact bone id and build a bone id names //================================================ // Skinned ? if (_Skinned) { // Remap std::map<uint, uint> remap; // Current bone uint currentBone = 0; // Reserve memory _BonesName.reserve (m.BonesNames.size()); // For each vertices uint vert; for (vert=0; vert<_SkinWeights.size(); vert++) { // Found one ? bool found=false; // For each weight uint weight; for (weight=0; weight<NL3D_MESH_SKINNING_MAX_MATRIX; weight++) { // Active ? if ((_SkinWeights[vert].Weights[weight]>0)||(weight==0)) { // Look for it std::map<uint, uint>::iterator ite = remap.find (_SkinWeights[vert].MatrixId[weight]); // Find ? if (ite == remap.end()) { // Insert it remap.insert (std::map<uint, uint>::value_type (_SkinWeights[vert].MatrixId[weight], currentBone)); // Check the id nlassert (_SkinWeights[vert].MatrixId[weight]<m.BonesNames.size()); // Set the bone name _BonesName.push_back (m.BonesNames[_SkinWeights[vert].MatrixId[weight]]); // Set the local bone id _SkinWeights[vert].MatrixId[weight] = currentBone++; } else { // Set the local bone id _SkinWeights[vert].MatrixId[weight] = ite->second; } // Found one found = true; } } // Found one ? nlassert (found); } // Remap the vertex influence by lods uint lod; for (lod=0; lod<_Lods.size(); lod++) { // For each matrix used uint matrix; for (matrix=0; matrix<_Lods[lod].MatrixInfluences.size(); matrix++) { // Remap std::map<uint, uint>::iterator ite = remap.find (_Lods[lod].MatrixInfluences[matrix]); // Find ? nlassert (ite != remap.end()); // Remap _Lods[lod].MatrixInfluences[matrix] = ite->second; } } } // Misc. //=================== // Some runtime not serialized compilation compileRunTime(); }

void NL3D::CMeshMRMGeom::buildBoneUsageVer2 (   )  [private]

Definition at line 2482 of file mesh_mrm.cpp. References _SkinWeights, NL3D_MESH_SKINNING_MAX_MATRIX, uint, and uint32. Referenced by loadFirstLod(). { if(_Skinned) { // parse all vertices, couting MaxBoneId used. uint32 maxBoneId= 0; // for each vertex uint vert; for (vert=0; vert<_SkinWeights.size(); vert++) { // For each weight for (uint weight=0; weight<NL3D_MESH_SKINNING_MAX_MATRIX; weight++) { // Active ? if ((_SkinWeights[vert].Weights[weight]>0)||(weight==0)) { maxBoneId= max(_SkinWeights[vert].MatrixId[weight], maxBoneId); } } } // alloc an array of maxBoneId+1, reset to 0. std::vector<uint8> boneUsage; boneUsage.resize(maxBoneId+1, 0); // reparse all vertices, counting usage for each bone. for (vert=0; vert<_SkinWeights.size(); vert++) { // For each weight for (uint weight=0; weight<NL3D_MESH_SKINNING_MAX_MATRIX; weight++) { // Active ? if ((_SkinWeights[vert].Weights[weight]>0)||(weight==0)) { // mark this bone as used. boneUsage[_SkinWeights[vert].MatrixId[weight]]= 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::CMeshMRMGeom::changeMRMDistanceSetup (  float  distanceFinest, float  distanceMiddle, float  distanceCoarsest )

Change MRM Distance setup. NB: no-op if distanceFinest<0, distanceMiddle<=distanceFinest or if distanceCoarsest<=distanceMiddle. Parameters: distanceFinest  The MRM has its max faces when dist<=distanceFinest. distanceMiddle  The MRM has 50% of its faces at dist==distanceMiddle. distanceCoarsest  The MRM has faces/Divisor (ie near 0) when dist>=distanceCoarsest. Definition at line 228 of file mesh_mrm.cpp. References _LevelDetail, NL3D::CMRMLevelDetail::compileDistanceSetup(), NL3D::CMRMLevelDetail::DistanceCoarsest, NL3D::CMRMLevelDetail::DistanceFinest, and NL3D::CMRMLevelDetail::DistanceMiddle. Referenced by NL3D::CMeshMultiLod::changeMRMDistanceSetup(), and NL3D::CMeshMRM::changeMRMDistanceSetup(). { // check input. if(distanceFinest<0) return; if(distanceMiddle<=distanceFinest) return; if(distanceCoarsest<=distanceMiddle) return; // Change. _LevelDetail.DistanceFinest= distanceFinest; _LevelDetail.DistanceMiddle= distanceMiddle; _LevelDetail.DistanceCoarsest= distanceCoarsest; // compile _LevelDetail.compileDistanceSetup(); }

sint NL3D::CMeshMRMGeom::chooseLod (  float  alphaMRM, float &  alphaLod )  [inline, private]

choose the lod according to the alphaMRM [0,1] given. Definition at line 898 of file mesh_mrm.cpp. References _Lods, _NbLodLoaded, and sint. Referenced by activeInstance(), profileSceneRender(), render(), renderSkin(), and renderSkinGroupGeom(). { // Choose what Lod to draw. alphaMRM*= _Lods.size()-1; sint numLod= (sint)ceil(alphaMRM); if(numLod==0) { numLod= 0; alphaLod= 0; } else { // Lerp beetween lod i-1 and lod i. alphaLod= alphaMRM-(numLod-1); } // If lod chosen is not loaded, take the best loaded. if(numLod>=(sint)_NbLodLoaded) { numLod= _NbLodLoaded-1; alphaLod= 1; } return numLod; }

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

clip this mesh in a driver. true if visible. Reimplemented from NL3D::IMeshGeom. Definition at line 856 of file mesh_mrm.cpp. References 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::CMeshMRM::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::CMeshMRMGeom::compileRunTime (   )  [private]

Definition at line 2554 of file mesh_mrm.cpp. References _Lods, _ShadowSkinVertices, _SupportMeshBlockRendering, _SupportShadowSkinGrouping, _SupportSkinGrouping, _VBufferFinal, NL3D::CMeshMorpher::BlendShapes, NL3D::CPrimitiveBlock::getNumLine(), NL3D::CPrimitiveBlock::getNumQuad(), NL3D::CVertexBuffer::getNumVertices(), NLMISC::CAABBoxExt::getRadius(), NL3D::CVertexBuffer::getVertexFormat(), NL3D_MESH_PRECISE_CLIP_THRESHOLD, NL3D_MESH_SKIN_MANAGER_MAXVERTICES, NL3D_MESH_SKIN_MANAGER_VERTEXFORMAT, NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES, NL3D_SHADOW_MESH_SKIN_MANAGER_VERTEXFORMAT, and uint. Referenced by build(). { _PreciseClipping= _BBox.getRadius() >= NL3D_MESH_PRECISE_CLIP_THRESHOLD; // Compute if can support SkinGrouping rendering if(_Lods.size()==0 || !_Skinned) { _SupportSkinGrouping= false; _SupportShadowSkinGrouping= false; } else { // The Mesh must follow those restrictions, to support group skinning _SupportSkinGrouping= _VBufferFinal.getVertexFormat() == NL3D_MESH_SKIN_MANAGER_VERTEXFORMAT && _VBufferFinal.getNumVertices() < NL3D_MESH_SKIN_MANAGER_MAXVERTICES && !_MeshVertexProgram; // Additionally, NONE of the RdrPass should have Quads or lines... for(uint i=0;i<_Lods.size();i++) { for(uint j=0;j<_Lods[i].RdrPass.size();j++) { CPrimitiveBlock &pb= _Lods[i].RdrPass[j].PBlock; if( pb.getNumQuad() || pb.getNumLine() ) { _SupportSkinGrouping= false; break; } } } // Support Shadow SkinGrouping if Shadow setuped, and if not too many vertices. _SupportShadowSkinGrouping= !_ShadowSkinVertices.empty() && NL3D_SHADOW_MESH_SKIN_MANAGER_VERTEXFORMAT==CVertexBuffer::PositionFlag && _ShadowSkinVertices.size() <= NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES; } // Support MeshBlockRendering only if not skinned/meshMorphed. _SupportMeshBlockRendering= !_Skinned && _MeshMorpher.BlendShapes.size()==0; // \todo yoyo: support later MeshVertexProgram _SupportMeshBlockRendering= _SupportMeshBlockRendering && _MeshVertexProgram==NULL; }

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

Compute skinning id. Definition at line 2293 of file mesh_mrm.cpp. References _BonesSphere, _Lods, _ShadowSkinVertices, _SkinWeights, NL3D::CSkeletonModel::Bones, NL3D::CSkeletonModel::flagBoneAndParents(), NL3D::CSkeletonModel::getBoneIdByName(), matrix, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, nlwarning, sint32, uint, uint32, and v. Referenced by NL3D::CMeshMRM::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()); // Remap bones id table std::vector<uint> remap (_BonesName.size()); // **** For each bones, compute remap uint bone; for (bone=0; bone<remap.size(); bone++) { // Look for the bone sint32 boneId = skeleton->getBoneIdByName (_BonesName[bone]); // Setup the _BoneId. _BonesId[bone]= boneId; // Bones found ? if (boneId != -1) { // Set the bone id remap[bone] = (uint32)boneId; } else { // Put id 0 remap[bone] = 0; // Error nlwarning ("Bone %s not found in the skeleton.", _BonesName[bone].c_str()); } } // **** Remap the vertices, and compute Bone Spheres. // Find the Geomorph space: to process only real vertices, not geomorphed ones. uint nGeomSpace= 0; uint lod; for (lod=0; lod<_Lods.size(); lod++) { nGeomSpace= max(nGeomSpace, (uint)_Lods[lod].Geomorphs.size()); } // Prepare Sphere compute nlassert(_OriginalSkinVertices.size() == _SkinWeights.size()); static std::vector<CAABBox> boneBBoxes; static std::vector<bool> boneBBEmpty; boneBBoxes.clear(); boneBBEmpty.clear(); boneBBoxes.resize(_BonesId.size()); boneBBEmpty.resize(_BonesId.size(), true); // Remap the vertex, and compute the bone spheres. see CTransform::getSkinBoneSphere() doc. // for true vertices uint vert; for (vert=nGeomSpace; vert<_SkinWeights.size(); vert++) { // get the vertex position. CVector vertex= _OriginalSkinVertices[vert]; // For each weight uint weight; for (weight=0; weight<NL3D_MESH_SKINNING_MAX_MATRIX; weight++) { // Active ? if ((_SkinWeights[vert].Weights[weight]>0)||(weight==0)) { // Check id uint srcId= _SkinWeights[vert].MatrixId[weight]; nlassert (srcId < remap.size()); // remap _SkinWeights[vert].MatrixId[weight] = remap[srcId]; // if the boneId is valid (ie found) if(_BonesId[srcId]>=0) { // transform the vertex pos in BoneSpace CVector p= skeleton->Bones[_BonesId[srcId]].getBoneBase().InvBindPos * vertex; // extend the bone bbox. if(boneBBEmpty[srcId]) { boneBBoxes[srcId].setCenter(p); boneBBEmpty[srcId]= false; } else { boneBBoxes[srcId].extend(p); } } } else break; } } // Compile spheres _BonesSphere.resize(_BonesId.size()); for(bone=0;bone<_BonesSphere.size();bone++) { // If the bone is empty, mark with -1 in the radius. if(boneBBEmpty[bone]) { _BonesSphere[bone].Radius= -1; } else { _BonesSphere[bone].Center= boneBBoxes[bone].getCenter(); _BonesSphere[bone].Radius= boneBBoxes[bone].getRadius(); } } // **** Remap the vertex influence by lods for (lod=0; lod<_Lods.size(); lod++) { // For each matrix used uint matrix; for (matrix=0; matrix<_Lods[lod].MatrixInfluences.size(); matrix++) { // Check nlassert (_Lods[lod].MatrixInfluences[matrix]<remap.size()); // Remap _Lods[lod].MatrixInfluences[matrix] = remap[_Lods[lod].MatrixInfluences[matrix]]; } } // **** Remap Shadow Vertices. for(vert=0;vert<_ShadowSkinVertices.size();vert++) { CShadowVertex &v= _ShadowSkinVertices[vert]; // Check id nlassert (v.MatrixId < remap.size()); v.MatrixId= remap[v.MatrixId]; } // 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::CMeshMRMGeom::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 2811 of file mesh_mrm.cpp. References _Lods, _VBufferFinal, 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(), NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::CPrimitiveBlock::setNumLine(), NL3D::CPrimitiveBlock::setNumQuad(), NL3D::CPrimitiveBlock::setNumTri(), uint, and uint32. { // Fill dst with Buffer content. memcpy(dst, _VBufferFinal.getVertexCoordPointer(), _VBufferFinal.getNumVertices()*_VBufferFinal.getVertexSize() ); // For All Lods for(uint lodId=0; lodId<_Lods.size();lodId++) { CLod &lod= _Lods[lodId]; // For all rdrPass. for(uint i=0;i<lod.RdrPass.size();i++) { // shift the PB CPrimitiveBlock &srcPb= lod.RdrPass[i].PBlock; CPrimitiveBlock &dstPb= lod.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::CMeshMRMGeom::deleteVertexBufferHard (   )  [private]

Definition at line 2209 of file mesh_mrm.cpp. References nlassert. Referenced by ~CMeshMRMGeom(). { // test (refptr) if the object still exist in memory. if(_VBHard!=NULL) { // A vbufferhard should still exist only if driver still exist. nlassert(_Driver!=NULL); // delete it from driver. _Driver->deleteVertexBufferHard(_VBHard); _VBHard= NULL; } }

void NL3D::CMeshMRMGeom::dirtMeshDataId (   )  [private]

Increment the refCount, so instances RawSkins are no longer valid. Definition at line 3052 of file mesh_mrm.cpp. References _MeshDataId. Referenced by build(). { // see updateRawSkinNormal() _MeshDataId++; }

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

The framework call this method when it has done with this meshGeom Implements NL3D::IMeshGeom. Definition at line 2791 of file mesh_mrm.cpp. References _Lods, _MBRBkupNormalize, NL3D::CMeshGeomRenderContext::Driver, and NL3D::IDriver::forceNormalize(). { if(_Lods.empty()) return; // bkup force normalisation. rdrCtx.Driver->forceNormalize(_MBRBkupNormalize); }

void NL3D::CMeshMRMGeom::fillAGPSkinPartWithVBHardPtr (  CLod &  lod, uint8 *  vertexDst )  [private]

Definition at line 1978 of file mesh_mrm_skin.cpp.

const std::vector<std::string>& NL3D::CMeshMRMGeom::getBonesName (   )  const [inline]

get the bone names of the meshMRM. Definition at line 182 of file mesh_mrm.h. {return _BonesName;}

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

get the extended axis aligned bounding box of the mesh Implements NL3D::IMeshGeom. Definition at line 170 of file mesh_mrm.h. Referenced by NL3D::CMeshMRM::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().

const std::vector<CMRMWedgeGeom>& NL3D::CMeshMRMGeom::getGeomorphs (  uint  lodId  )  const [inline]

Advanced. get the geomorphs for a special lod. Definition at line 216 of file mesh_mrm.h. References _Lods, and uint. { return _Lods[lodId].Geomorphs; }

const CMRMLevelDetail& NL3D::CMeshMRMGeom::getLevelDetail (   )  const [inline]

get the MRM level detail information Definition at line 275 of file mesh_mrm.h. References _LevelDetail. Referenced by NL3D::CMeshMRMInstance::getMRMLevelDetail(). {return _LevelDetail;}

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

get the number of BlendShapes Definition at line 222 of file mesh_mrm.h. References NL3D::CMeshMorpher::BlendShapes, and uint. { return _MeshMorpher.BlendShapes.size(); }

uint NL3D::CMeshMRMGeom::getNbLod (   )  const [inline]

get the number of LOD. Definition at line 186 of file mesh_mrm.h. References _Lods, and uint. Referenced by applyMaterialRemap(), NL3D::CMeshMRM::getNbLod(), and loadNextLod(). { return _Lods.size() ; }

uint NL3D::CMeshMRMGeom::getNbLodLoaded (   )  const [inline]

get the number of LOD currently loaded. Definition at line 140 of file mesh_mrm.h. References _NbLodLoaded, and uint. Referenced by loadNextLod(), and unloadNextLod(). { return _NbLodLoaded ; }

uint NL3D::CMeshMRMGeom::getNbRdrPass (  uint  lodId  )  const [inline]

get the number of rendering pass of a LOD. Parameters: lodId  the id of the LOD. Definition at line 192 of file mesh_mrm.h. References _Lods, and uint. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CInstanceLighter::addTriangles(), applyMaterialRemap(), and NL3D::CMeshMRM::getNbRdrPass(). { return _Lods[lodId].RdrPass.size() ; }

uint NL3D::CMeshMRMGeom::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 2700 of file mesh_mrm.cpp. References _Lods, _MBRCurrentLodId, and uint. { return _Lods[_MBRCurrentLodId].RdrPass.size(); }

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

return the number of renderPasses for this mesh. Used only if sortPerMaterial()) is true Implements NL3D::IMeshGeom. Definition at line 2693 of file mesh_mrm.cpp. References uint. { // not used... return 0; }

uint NL3D::CMeshMRMGeom::getNumShadowSkinVertices (   )  const

Get the num of shadow skin vertices. Definition at line 3370 of file mesh_mrm.cpp. References _ShadowSkinVertices, and uint. { return _ShadowSkinVertices.size(); }

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

get an approximation of the number of triangles this instance will render for a fixed distance. Implements NL3D::IMeshGeom. Definition at line 2200 of file mesh_mrm.cpp. References _LevelDetail, and NL3D::CMRMLevelDetail::getNumTriangles(). Referenced by NL3D::CMeshMRM::getNumTriangles(). { // NB: this is an approximation, but this is continious. return _LevelDetail.getNumTriangles(distance); }

uint32 NL3D::CMeshMRMGeom::getRdrPassMaterial (  uint  lodId, uint  renderingPassIndex )  const [inline]

get the material ID associated with a rendering pass of a LOD. Parameters: lodId  the id of the LOD. renderingPassIndex  the index of the rendering pass in the matrix block Definition at line 209 of file mesh_mrm.h. References _Lods, uint, and uint32. Referenced by NL3D::CZoneLighter::addTriangles(), and NL3D::CMeshMRM::getRdrPassMaterial(). { return _Lods[lodId].RdrPass[renderingPassIndex].MaterialId ; }

const CPrimitiveBlock& NL3D::CMeshMRMGeom::getRdrPassPrimitiveBlock (  uint  lodId, uint  renderingPassIndex )  const [inline]

get the primitive block associated with a rendering pass of a LOD. Parameters: lodId  the id of the LOD. renderingPassIndex  the index of the rendering pass Definition at line 199 of file mesh_mrm.h. References _Lods, and uint. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CInstanceLighter::addTriangles(), and NL3D::CMeshMRM::getRdrPassPrimitiveBlock(). { return _Lods[lodId].RdrPass[renderingPassIndex].PBlock ; }

const std::vector<NLMISC::CBSphere>& NL3D::CMeshMRMGeom::getSkinBoneSphere (   )  const [inline]

see CTransform::getSkinBoneSphere() doc for the meaning of this value. computeBonesId must has been called before. Definition at line 246 of file mesh_mrm.h. References _BonesSphere. Referenced by NL3D::CMeshMRMInstance::getSkinBoneSphere(). {return _BonesSphere;}

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

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

const std::vector<CMesh::CSkinWeight>& NL3D::CMeshMRMGeom::getSkinWeights (   )  const [inline]

get the skinWeights used by the mrm mesh. NB: same size of the vertexBuffer. empty if !isSkinned() Definition at line 179 of file mesh_mrm.h. References _SkinWeights. {return _SkinWeights;}

bool NL3D::CMeshMRMGeom::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 2802 of file mesh_mrm.cpp. References _SupportMeshBlockRendering, _VBufferFinal, NL3D::CVertexBuffer::getNumVertices(), NL3D::CVertexBuffer::getVertexFormat(), and uint. { // CMeshMRMGeom support VBHeap rendering, assuming _SupportMeshBlockRendering is true vertexFormat= _VBufferFinal.getVertexFormat(); numVertices= _VBufferFinal.getNumVertices(); return _SupportMeshBlockRendering; }

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

get the vertex buffer used by the mrm mesh. NB: this VB store all Vertices used by All LODs. Definition at line 176 of file mesh_mrm.h. References _VBufferFinal. Referenced by NL3D::CZoneLighter::addTriangles(), NL3D::CInstanceLighter::addTriangles(), and NL3D::CMeshMRM::getVertexBuffer(). { return _VBufferFinal ; }

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

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

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

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

bool NL3D::CMeshMRMGeom::isActiveInstanceNeedVBFill (   )  const [virtual]

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 from NL3D::IMeshGeom. Definition at line 2858 of file mesh_mrm.cpp. { // Yes, need it for geomorph return true; }

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 profileSceneRender(), and NL3D::CMeshGeom::profileSceneRender(). {return _MeshVBHeapId!=0;}

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

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

void NL3D::CMeshMRMGeom::load (  NLMISC::IStream &  f  )  throw (NLMISC::EStream) [private]

load this mesh. Definition at line 1757 of file mesh_mrm.cpp. References sint, and uint. { // because loading, flag the VertexBufferHard. _VertexBufferHardDirty= true; // Load the header of the stream. // ================== sint verHeader= loadHeader(f); // Read All lod subsets. // ================== for(uint i=0;i<_LodInfos.size(); i++) { // read the lod face data. f.serial(_Lods[i]); // read the lod vertex data. serialLodVertexData(f, _LodInfos[i].StartAddWedge, _LodInfos[i].EndAddWedges); // if reading, must bkup all original vertices from VB. // this is done in serialLodVertexData(). by subset } // Now, all lods are loaded. _NbLodLoaded= _Lods.size(); // If version doen't have boneNames, must build BoneId now. if(verHeader <= 2) { buildBoneUsageVer2 (); } }

void NL3D::CMeshMRMGeom::loadFirstLod (  NLMISC::IStream &  f  )

Load the header and the first lod of a MRM in a stream. Parameters: f  the input stream to read. NB: after load, f.getPos() return the position of the second lod in the stream. Definition at line 1951 of file mesh_mrm.cpp. References _LodInfos, _Lods, _NbLodLoaded, buildBoneUsageVer2(), loadHeader(), NLMISC::IStream::serial(), serialLodVertexData(), sint, and uint. { // because loading, flag the VertexBufferHard. _VertexBufferHardDirty= true; // Load the header of the stream. // ================== sint verHeader= loadHeader(f); // If empty MRM, quit. if(_LodInfos.size()==0) return; /* If the version is <4, then SkinWeights are serialised per Lod. But for computebonesId(), we must have all SkinWeights RIGHT NOW. Hence, if too old version (<4), serialize all the MRM.... */ uint numLodToLoad; if(verHeader<4) numLodToLoad= _LodInfos.size(); else numLodToLoad= 1; // Read lod subset(s). // ================== for(uint i=0;i<numLodToLoad; i++) { // read the lod face data. f.serial(_Lods[i]); // read the lod vertex data. serialLodVertexData(f, _LodInfos[i].StartAddWedge, _LodInfos[i].EndAddWedges); // if reading, must bkup all original vertices from VB. // this is done in serialLodVertexData(). by subset } // Now, just first lod is loaded (but if too old file) _NbLodLoaded= numLodToLoad; // If version doen't have boneNames, must build BoneId now. if(verHeader <= 2) { buildBoneUsageVer2 (); } }

sint NL3D::CMeshMRMGeom::loadHeader (  NLMISC::IStream &  f  )  throw (NLMISC::EStream) [private]

load the header of this mesh. return the version of the header. Definition at line 1627 of file mesh_mrm.cpp. References NLMISC::IStreamable::serial(), sint, sint32, uint, and uint32. Referenced by loadFirstLod(). { /* Version 5: - Shadow Skinning Version 4: - serial SkinWeights per MRM, not per Lod Version 3: - Bones names. Version 2: - Mesh Vertex Program. Version 1: - added blend shapes Version 0: - base version. */ sint ver= f.serialVersion(5); // if >= version 3, serial boens names if(ver>=3) { f.serialCont (_BonesName); } // Version3-: Bones index are in skeleton model id list _BoneIdComputed = (ver < 3); // Must always recompute usage of parents of bones used. _BoneIdExtended = false; // Mesh Vertex Program. if (ver >= 2) { IMeshVertexProgram *mvp= NULL; f.serialPolyPtr(mvp); _MeshVertexProgram= mvp; } else { // release vp _MeshVertexProgram= NULL; } // blend shapes if (ver >= 1) f.serial (_MeshMorpher); // serial Basic info. // ================== f.serial(_Skinned); f.serial(_BBox); f.serial(_LevelDetail.MaxFaceUsed); f.serial(_LevelDetail.MinFaceUsed); f.serial(_LevelDetail.DistanceFinest); f.serial(_LevelDetail.DistanceMiddle); f.serial(_LevelDetail.DistanceCoarsest); f.serial(_LevelDetail.OODistanceDelta); f.serial(_LevelDetail.DistancePow); // preload the Lods. f.serialCont(_LodInfos); // read/save number of wedges. /* NB: prepare memory space too for vertices. \todo yoyo: TODO_OPTIMIZE. for now there is no Lod memory profit with vertices / skinWeights. But resizing arrays is a problem because of reallocation... */ uint32 nWedges; f.serial(nWedges); // Prepare the VBuffer. _VBufferFinal.serialHeader(f); // If skinned, must allocate skinWeights. contReset(_SkinWeights); if(_Skinned) { _SkinWeights.resize(nWedges); } // If new version, serial SkinWeights in header, not in lods. if(ver >= 4) { f.serialCont(_SkinWeights); } // if >= version 5, serial Shadow Skin Information if(ver>=5) { f.serialCont (_ShadowSkinVertices); f.serialCont (_ShadowSkinTriangles); } // Serial lod offsets. // ================== // This is the reference pos, to load / save relative offsets. sint32 startPos = f.getPos(); // Those are the lodOffsets, relative to startPos. vector<sint32> lodOffsets; lodOffsets.resize(_LodInfos.size(), 0); // read all relative offsets, and build the absolute offset of LodInfos. for(uint i=0;i<_LodInfos.size(); i++) { f.serial(lodOffsets[i]); _LodInfos[i].LodOffset= startPos + lodOffsets[i]; } // resest the Lod arrays. NB: each Lod is empty, and ready to receive Lod data. // ================== contReset(_Lods); _Lods.resize(_LodInfos.size()); // Flag the fact that no lod is loaded for now. _NbLodLoaded= 0; // Inform that the mesh data has changed dirtMeshDataId(); // Some runtime not serialized compilation compileRunTime(); // return version of the header return ver; }

void NL3D::CMeshMRMGeom::loadNextLod (  NLMISC::IStream &  f  )

Load next lod of a stream. use getNbLodLoaded() to know what Lod will be loaded. NB: if getNbLodLoaded() == getNbLod(), no op. Parameters: f  the same input stream passed to loadFirstLod(). NB: after load, f.getPos() is "unedfined" (actually return the position of the next lod in the stream). Definition at line 2001 of file mesh_mrm.cpp. References _LodInfos, _Lods, _NbLodLoaded, getNbLod(), getNbLodLoaded(), NLMISC::IStream::seek(), NLMISC::IStream::serial(), and serialLodVertexData(). { // because loading, flag the VertexBufferHard. _VertexBufferHardDirty= true; // If all is loaded, quit. if(getNbLodLoaded() == getNbLod()) return; // Set pos to good lod. f.seek(_LodInfos[_NbLodLoaded].LodOffset, IStream::begin); // Serial this lod data. // read the lod face data. f.serial(_Lods[_NbLodLoaded]); // read the lod vertex data. serialLodVertexData(f, _LodInfos[_NbLodLoaded].StartAddWedge, _LodInfos[_NbLodLoaded].EndAddWedges); // if reading, must bkup all original vertices from VB. // this is done in serialLodVertexData(). by subset // Inc LodLoaded count. _NbLodLoaded++; }

NL3D::CMeshMRMGeom::NLMISC_DECLARE_CLASS (  CMeshMRMGeom   )

clip this mesh in a driver. true if visible.

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

Scene profile. Implements NL3D::IMeshGeom. Definition at line 2600 of file mesh_mrm.cpp. References _LevelDetail, _Lods, _VBufferFinal, NL3D::CScene::BenchRes, chooseLod(), NL3D::CMRMLevelDetail::getLevelDetailFromPolyCount(), NL3D::CPrimitiveBlock::getNumTri(), NL3D::CVertexBuffer::getVertexFormat(), NL3D::CScene::incrementProfileTriVBFormat(), NL3D::IMeshGeom::isMeshInVBHeap(), NL3D::CMeshMRMGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, NL3D::UScene::CBenchResults::MeshMRMProfileTriVBFormat, NL3D::UScene::CBenchResults::NumMeshMRMRdrBlock, NL3D::UScene::CBenchResults::NumMeshMRMRdrBlockWithVBHeap, NL3D::UScene::CBenchResults::NumMeshMRMRdrNormal, NL3D::UScene::CBenchResults::NumMeshMRMTriRdrBlock, NL3D::UScene::CBenchResults::NumMeshMRMTriRdrBlockWithVBHeap, NL3D::UScene::CBenchResults::NumMeshMRMTriRdrNormal, NL3D::UScene::CBenchResults::NumMeshMRMVBufferHard, NL3D::UScene::CBenchResults::NumMeshMRMVBufferStd, NL3D::CMeshMRMGeom::CRdrPass::PBlock, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::CTraversal::Scene, sint, supportMeshBlockRendering(), uint, and uint32. Referenced by NL3D::CMeshMRM::profileSceneRender(). { // get the result of the Load Balancing. float alphaMRM= _LevelDetail.getLevelDetailFromPolyCount(polygonCount); // choose the lod. float alphaLod; sint numLod= chooseLod(alphaMRM, alphaLod); // Render the choosen Lod. CLod &lod= _Lods[numLod]; // get the mesh instance. CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans); // Profile all pass. uint triCount= 0; for (uint i=0;i<lod.RdrPass.size();i++) { CRdrPass &rdrPass= lod.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.MeshMRMProfileTriVBFormat, _VBufferFinal.getVertexFormat(), triCount); // VBHard if(_VBHard) rdrTrav->Scene->BenchRes.NumMeshMRMVBufferHard++; else rdrTrav->Scene->BenchRes.NumMeshMRMVBufferStd++; // 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.NumMeshMRMRdrBlockWithVBHeap++; rdrTrav->Scene->BenchRes.NumMeshMRMTriRdrBlockWithVBHeap+= triCount; } else { rdrTrav->Scene->BenchRes.NumMeshMRMRdrBlock++; rdrTrav->Scene->BenchRes.NumMeshMRMTriRdrBlock+= triCount; } } else { rdrTrav->Scene->BenchRes.NumMeshMRMRdrNormal++; rdrTrav->Scene->BenchRes.NumMeshMRMTriRdrNormal+= triCount; } } }

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

render() this mesh in a driver, given an instance and his materials. Implements NL3D::IMeshGeom. Definition at line 927 of file mesh_mrm.cpp. References _LevelDetail, _Lods, _VBufferFinal, _VBufferOriginal, NL3D::IDriver::activeVertexBuffer(), NL3D::IDriver::activeVertexBufferHard(), applyGeomorph(), NL3D::CMeshMorpher::BlendShapes, NL3D::CTravCameraScene::CamPos, chooseLod(), NL3D::IDriver::forceNormalize(), NL3D::CMeshMRMGeom::CLod::Geomorphs, NL3D::CMeshBaseInstance::getBlendShapeFactors(), NL3D::CMRMLevelDetail::getLevelDetailFromPolyCount(), NL3D::CVertexBuffer::getNumVertices(), NL3D::CTransform::getOwnerScene(), NL3D::CScene::getRenderTrav(), NL3D::CTransform::getSkeletonModel(), NL3D::CTransform::getWorldMatrix(), H_AUTO, NL3D::CMeshMorpher::init(), NL3D::CMeshMorpher::initSkinned(), NLMISC::CMatrix::inverted(), NL3D::IDriver::isForceNormalize(), NL3D::CTransform::isSkinned(), NL3D::CMeshMRMGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, nlassert, NLMISC::OptFastFloor(), NL3D::CMeshMRMGeom::CLod::OriginalSkinRestored, NL3D::CMeshMRMGeom::CRdrPass::PBlock, NL3D::CMeshBlender::prepareRenderForGlobalAlpha(), NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::IDriver::render(), restoreOriginalSkinPart(), NL3D::CMeshBlender::restoreRender(), NL3D::IDriver::setupModelMatrix(), sint, uint, uint32, uint8, NL3D::CMeshMorpher::update(), NL3D::CMeshMorpher::updateSkinned(), and updateVertexBufferHard(). Referenced by NL3D::CMeshMRM::render(). { nlassert(drv); if(_Lods.size()==0) return; // get the meshMRM 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 the result of the Load Balancing. float alphaMRM= _LevelDetail.getLevelDetailFromPolyCount(polygonCount); // choose the lod. float alphaLod; sint numLod= chooseLod(alphaMRM, alphaLod); // Render the choosen Lod. CLod &lod= _Lods[numLod]; if(lod.RdrPass.size()==0) return; // Update the vertexBufferHard (if possible). // \toto yoyo: TODO_OPTIMIZE: allocate only what is needed for the current Lod (Max of all instances, like // the loading....) (see loadHeader()). updateVertexBufferHard(drv, _VBufferFinal.getNumVertices()); /* 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= _VBHard; // 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_MeshMRMGeom_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(&_VBufferOriginal, &_VBufferFinal, 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(&_VBufferOriginal, &_VBufferFinal, currentVBHard, useTangentSpace); _MeshMorpher.update (mi->getBlendShapeFactors()); } } // Skinning. //=========== // if mesh is skinned (but here skin not applied), we must copy vertices/normals from original vertices. if (_Skinned) { // do it for this Lod only, and if cache say it is necessary. if (!lod.OriginalSkinRestored) restoreOriginalSkinPart(lod, currentVBHard); } // set the instance worldmatrix. drv->setupModelMatrix(trans->getWorldMatrix()); // Geomorph. //=========== // Geomorph the choosen Lod (if not the coarser mesh). if(numLod>0) { applyGeomorph(lod.Geomorphs, alphaLod, currentVBHard); } // force normalisation of normals.. bool bkupNorm= drv->isForceNormalize(); drv->forceNormalize(true); // 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, mi->getOwnerScene(), mi, invertedObjectMatrix, renderTrav->CamPos); } // Render the lod. //=========== // active VB. if(currentVBHard) drv->activeVertexBufferHard(currentVBHard); else drv->activeVertexBuffer(_VBufferFinal); // Global alpha used ? uint32 globalAlphaUsed= rdrFlags & IMeshGeom::RenderGlobalAlpha; uint8 globalAlphaInt=(uint8)NLMISC::OptFastFloor(globalAlpha*255); // Render all pass. if (globalAlphaUsed) { bool gaDisableZWrite= (rdrFlags & IMeshGeom::RenderGADisableZWrite)?true:false; // for all passes for(uint i=0;i<lod.RdrPass.size();i++) { CRdrPass &rdrPass= lod.RdrPass[i]; 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, &_VBufferFinal); } // Render drv->render(rdrPass.PBlock, material); // Resetup material/driver blender.restoreRender(material, drv, gaDisableZWrite); } } } else { for(uint i=0;i<lod.RdrPass.size();i++) { CRdrPass &rdrPass= lod.RdrPass[i]; 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, &_VBufferFinal); } // Render with the Materials of the MeshInstance. drv->render(rdrPass.PBlock, material); } } } // End VertexProgram effect if(useMeshVP) { // end it. _MeshVertexProgram->end(drv); } // bkup force normalisation. drv->forceNormalize(bkupNorm); }

void NL3D::CMeshMRMGeom::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 2768 of file mesh_mrm.cpp. References _Lods, _MBRCurrentLodId, NL3D::CMeshGeomRenderContext::Driver, NL3D::CMeshMRMGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, NL3D::CMeshMRMGeom::CRdrPass::PBlock, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::IDriver::render(), NL3D::CMeshGeomRenderContext::RenderThroughVBHeap, uint, and NL3D::CMeshMRMGeom::CRdrPass::VBHeapPBlock. { if(_Lods.empty()) return; CLod &lod= _Lods[_MBRCurrentLodId]; CRdrPass &rdrPass= lod.RdrPass[rdrPassId]; if ( mi->Materials[rdrPass.MaterialId].getBlend() == false ) { // CMaterial Ref CMaterial &material=mi->Materials[rdrPass.MaterialId]; // Render with the Materials of the MeshInstance. if(rdrCtx.RenderThroughVBHeap) // render shifted primitives rdrCtx.Driver->render(rdrPass.VBHeapPBlock, material); else rdrCtx.Driver->render(rdrPass.PBlock, material); } }

sint NL3D::CMeshMRMGeom::renderShadowSkinGeom (  CMeshMRMInstance *  mi, uint  remainingVertices, uint8 *  vbDest )

Get the num of shadow skin vertices. Definition at line 3376 of file mesh_mrm.cpp. References _ShadowSkinVertices, applyArrayShadowSkin(), NL3D::CTransform::getSkeletonModel(), H_AUTO_USE, nlassert, sint, uint, and uint8. Referenced by NL3D::CMeshMRMInstance::renderShadowSkinGeom(). { uint numVerts= _ShadowSkinVertices.size(); if(numVerts==0) return 0; // If the Lod is too big to render in the VBufferHard if(numVerts>remainingVertices) // return Failure return -1; // get the skeleton model to which I am skinned CSkeletonModel *skeleton; skeleton = mi->getSkeletonModel(); // must be skinned for renderSkin() nlassert(skeleton); // Profiling //=========== H_AUTO_USE( NL3D_MeshMRMGeom_RenderShadow ); // Skinning. //=========== // skinning with normal, but no tangent space applyArrayShadowSkin(&_ShadowSkinVertices[0], (CVector*)vbDest, skeleton, numVerts); // How many vertices are added to the VBuffer ??? return numVerts; }

void NL3D::CMeshMRMGeom::renderShadowSkinPrimitives (  CMeshMRMInstance *  mi, CMaterial &  castMat, IDriver *  drv, uint  baseVertex )

Get the num of shadow skin vertices. Definition at line 3412 of file mesh_mrm.cpp. References _ShadowSkinTriangles, H_AUTO_USE, min, nlassert, NL3D::IDriver::renderTriangles(), src, uint, and uint32. Referenced by NL3D::CMeshMRMInstance::renderShadowSkinPrimitives(). { nlassert(drv); if(_ShadowSkinTriangles.empty()) return; // Profiling //=========== H_AUTO_USE( NL3D_MeshMRMGeom_RenderShadow ); // NB: the skeleton matrix has already been setuped by CSkeletonModel // NB: the normalize flag has already been setuped by CSkeletonModel // TODO_SHADOW: optim: Special triangle cache for shadow! static vector<uint32> shiftedTris; if(shiftedTris.size()<_ShadowSkinTriangles.size()) { shiftedTris.resize(_ShadowSkinTriangles.size()); } uint32 *src= &_ShadowSkinTriangles[0]; uint32 *dst= &shiftedTris[0]; for(uint n= _ShadowSkinTriangles.size();n>0;n--, src++, dst++) { *dst= *src + baseVertex; } // Render Triangles with cache //=========== uint numTris= _ShadowSkinTriangles.size()/3; // This speed up 4 ms for 80K polys. uint memToCache= numTris*12; memToCache= min(memToCache, 4096U); CFastMem::precache(&shiftedTris[0], memToCache); // Render with the Materials of the MeshInstance. drv->renderTriangles(castMat, &shiftedTris[0], numTris); }

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

render() this mesh as a skin Implements NL3D::IMeshGeom. Definition at line 1146 of file mesh_mrm.cpp. References _Lods, _VBufferFinal, _VBufferOriginal, NL3D::IDriver::activeVertexBuffer(), applyGeomorph(), applySkin(), applySkinWithNormal(), applySkinWithTangentSpace(), NL3D::CMeshMorpher::BlendShapes, NL3D::CTravCameraScene::CamPos, chooseLod(), NL3D::CMeshMRMGeom::CLod::Geomorphs, NL3D::CMeshBaseInstance::getBlendShapeFactors(), NL3D::CRenderTrav::getDriver(), NL3D::CVertexBuffer::getNumTexCoordUsed(), NL3D::CTransform::getOwnerScene(), NL3D::CScene::getRenderTrav(), NL3D::CTransform::getSkeletonModel(), NL3D::CVertexBuffer::getVertexFormat(), NL3D::CTransform::getWorldMatrix(), H_AUTO, NL3D::CMeshMorpher::initSkinned(), NLMISC::CMatrix::inverted(), NL3D::CTransform::isSkinned(), NL3D::CMeshMRMGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, nlassert, NL3D::CMeshMRMGeom::CLod::OriginalSkinRestored, NL3D::CMeshMRMGeom::CRdrPass::PBlock, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::IDriver::render(), sint, uint, updateRawSkinNormal(), and NL3D::CMeshMorpher::updateSkinned(). Referenced by NL3D::CMeshMRMInstance::renderSkin(). { H_AUTO( NL3D_MeshMRMGeom_renderSkin ); if(_Lods.size()==0) return; // get the meshMRM instance. only CMeshMRMInstance is possible when skinned (not MultiLod) CMeshMRMInstance *mi= safe_cast<CMeshMRMInstance*>(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); // choose the lod. float alphaLod; sint numLod= chooseLod(alphaMRM, alphaLod); // Render the choosen Lod. CLod &lod= _Lods[numLod]; if(lod.RdrPass.size()==0) return; /* YOYO: renderSkin() no more support vertexBufferHard()!!! for AGP Memory optimisation concern. AGP Skin rendering is made when supportSkinGrouping() is true Hence if a skin is to be rendered here, because it doesn't have a good vertex format, or it has MeshVertexProgram etc..., it will be rendered WITHOUT VBHard => slower. */ // get the skeleton model to which I am skinned CSkeletonModel *skeleton; skeleton = mi->getSkeletonModel(); // must be skinned for renderSkin() nlassert(_Skinned && mi->isSkinned() && skeleton); bool bMorphApplied = _MeshMorpher.BlendShapes.size() > 0; bool useNormal= (_VBufferFinal.getVertexFormat() & CVertexBuffer::NormalFlag)!=0; bool useTangentSpace = _MeshVertexProgram && _MeshVertexProgram->needTangentSpace(); // Profiling //=========== H_AUTO( NL3D_MeshMRMGeom_renderSkin_go ); // Morphing // ======== if (bMorphApplied) { // Since Skinned we must update original skin vertices and normals because skinning use it _MeshMorpher.initSkinned(&_VBufferOriginal, &_VBufferFinal, NULL, useTangentSpace, &_OriginalSkinVertices, &_OriginalSkinNormals, useTangentSpace ? &_OriginalTGSpace : NULL, true ); _MeshMorpher.updateSkinned (mi->getBlendShapeFactors()); } // Skinning. //=========== // Never use RawSkin. Actually used in skinGrouping. updateRawSkinNormal(false, mi, numLod); // applySkin. //-------- // If skin without normal (rare/usefull?) always simple (slow) case. if(!useNormal) { // skinning with just position applySkin (lod, skeleton); } else { // apply skin for this Lod only. if (!useTangentSpace) { // skinning with normal, but no tangent space applySkinWithNormal (lod, skeleton); } else { // Tangent space stored in the last texture coordinate applySkinWithTangentSpace(lod, skeleton, _VBufferFinal.getNumTexCoordUsed() - 1); } } // endSkin. //-------- // dirt this lod part. (NB: this is not optimal, but sufficient :) ). lod.OriginalSkinRestored= false; // NB: the skeleton matrix has already been setuped by CSkeletonModel // NB: the normalize flag has already been setuped by CSkeletonModel // Geomorph. //=========== // Geomorph the choosen Lod (if not the coarser mesh). if(numLod>0) { applyGeomorph(lod.Geomorphs, alphaLod, NULL); } // 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, mi->getOwnerScene(), mi, invertedObjectMatrix, renderTrav->CamPos); } // Render the lod. //=========== // active VB. drv->activeVertexBuffer(_VBufferFinal); // Render all pass. for(uint i=0;i<lod.RdrPass.size();i++) { CRdrPass &rdrPass= lod.RdrPass[i]; // CMaterial Ref CMaterial &material=mi->Materials[rdrPass.MaterialId]; // Setup VP material if (useMeshVP) { _MeshVertexProgram->setupForMaterial(material, drv, ownerScene, &_VBufferFinal); } // Render with the Materials of the MeshInstance. drv->render(rdrPass.PBlock, material); } // End VertexProgram effect if(useMeshVP) { // end it. _MeshVertexProgram->end(drv); } }

sint NL3D::CMeshMRMGeom::renderSkinGroupGeom (  CMeshMRMInstance *  mi, float  alphaMRM, uint  remainingVertices, uint8 *  vbDest )

Definition at line 1318 of file mesh_mrm.cpp. References _LastLodComputed, _Lods, NL3D::CMeshMRMInstance::_RawSkinCache, _VBufferFinal, applyRawSkinWithNormal(), NL3D::CMeshMorpher::BlendShapes, chooseLod(), NL3D::CRawSkinNormalCache::Geomorphs, NL3D::CMeshBaseInstance::getBlendShapeFactors(), NL3D::CRenderTrav::getDriver(), NL3D::CTransform::getOwnerScene(), NL3D::CScene::getRenderTrav(), NL3D::CTransform::getSkeletonModel(), NL3D::CVertexBuffer::getVertexFormat(), H_AUTO, NL3D::CTransform::isSkinned(), nlassert, NL3D::CMeshMRMGeom::CLod::NWedges, NL3D::CMeshMRMGeom::CLod::RdrPass, sint, NL3D::CRawSkinNormalCache::TotalHardVertices, NL3D::CRawSkinNormalCache::TotalSoftVertices, uint, uint8, NL3D::CMeshMorpher::updateRawSkin(), updateRawSkinNormal(), and NL3D::CRawSkinNormalCache::VertexRemap. Referenced by NL3D::CMeshMRMInstance::renderSkinGroupGeom(). { H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpGeom ) // 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); // choose the lod. float alphaLod; sint numLod= chooseLod(alphaMRM, alphaLod); _LastLodComputed= numLod; // Render the choosen Lod. CLod &lod= _Lods[numLod]; if(lod.RdrPass.size()==0) // return no vertices added return 0; // If the Lod is too big to render in the VBufferHard if(lod.NWedges>remainingVertices) // return Failure return -1; // get the skeleton model to which I am skinned CSkeletonModel *skeleton; skeleton = mi->getSkeletonModel(); // must be skinned for renderSkin() nlassert(_Skinned && mi->isSkinned() && skeleton); bool bMorphApplied = _MeshMorpher.BlendShapes.size() > 0; bool useNormal= (_VBufferFinal.getVertexFormat() & CVertexBuffer::NormalFlag)!=0; nlassert(useNormal); // Profiling //=========== H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpGeom_go ); // Morphing // ======== // Use RawSkin?. compute before morphing, cause of updateRawSkin updateRawSkinNormal(true, mi, numLod); nlassert(mi->_RawSkinCache); // Apply morph if (bMorphApplied) { // No need to manage lod.OriginalSkinRestored, since in case of SkinGroupGeom, the VBuffer final is not modified. // copy directly from the original VB, and apply BlendShapes. Dest is directly the RawSkin _MeshMorpher.updateRawSkin(&_VBufferFinal, mi->_RawSkinCache->VertexRemap, mi->getBlendShapeFactors()); } // Skinning. //=========== // NB: the skeleton matrix has already been setuped by CSkeletonModel // NB: the normalize flag has already been setuped by CSkeletonModel // applySkin with RawSkin. //-------- // always RawSkin now in SkinGrouping, even with MeshMorpher { H_AUTO( NL3D_RawSkinning ); // RawSkin do all the job in optimized way: Skinning, copy to VBHard and Geomorph. // skinning with normal, but no tangent space applyRawSkinWithNormal (lod, *(mi->_RawSkinCache), skeleton, vbDest, alphaLod); // Vertices are packed in RawSkin mode (ie no holes due to MRM!) return mi->_RawSkinCache->Geomorphs.size() + mi->_RawSkinCache->TotalSoftVertices + mi->_RawSkinCache->TotalHardVertices; } }

void NL3D::CMeshMRMGeom::renderSkinGroupPrimitives (  CMeshMRMInstance *  mi, uint  baseVertex, std::vector< CSkinSpecularRdrPass > &  specularRdrPasses, uint  skinIndex )

Definition at line 1406 of file mesh_mrm.cpp. References _LastLodComputed, _Lods, NL3D::CMeshMRMInstance::_ShiftedTriangleCache, NL3D::CRenderTrav::getDriver(), NL3D::CTransform::getOwnerScene(), NL3D::CScene::getRenderTrav(), NL3D::CMaterial::getShader(), NL3D::CMaterial::getTexture(), NL3D::IDriver::getTextureHandle(), H_AUTO, NL3D::CMeshMRMGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, min, nlassert, NL3D::CShiftedTriangleCache::CRdrPass::NumTriangles, NL3D::CShiftedTriangleCache::RdrPass, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::CSkinSpecularRdrPass::RdrPassIndex, NL3D::IDriver::renderTriangles(), NL3D::CSkinSpecularRdrPass::SkinIndex, NL3D::CSkinSpecularRdrPass::SpecId, NL3D::CShiftedTriangleCache::CRdrPass::Triangles, uint, and updateShiftedTriangleCache(). Referenced by NL3D::CMeshMRMInstance::renderSkinGroupPrimitives(). { H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpPrimitives ); // 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); // Get the lod choosen in renderSkinGroupGeom() CLod &lod= _Lods[_LastLodComputed]; // must update primitive cache updateShiftedTriangleCache(mi, _LastLodComputed, baseVertex); nlassert(mi->_ShiftedTriangleCache); // Render Triangles with cache //=========== for(uint i=0;i<lod.RdrPass.size();i++) { CRdrPass &rdrPass= lod.RdrPass[i]; // CMaterial Ref CMaterial &material=mi->Materials[rdrPass.MaterialId]; // TestYoyo. Material Speed Test /*if( material.getDiffuse()!=CRGBA(250, 251, 252) ) { material.setDiffuse(CRGBA(250, 251, 252)); // Set all texture the same. static CSmartPtr<ITexture> pTexFile= new CTextureFile("fy_hom_visage_c1_fy_e1.tga"); material.setTexture(0, pTexFile ); // Remove Specular. if(material.getShader()==CMaterial::Specular) { CSmartPtr<ITexture> tex= material.getTexture(0); material.setShader(CMaterial::Normal); material.setTexture(0, tex ); } // Remove MakeUp material.setTexture(1, NULL); }*/ // If the material is a specular material, don't render it now! if(material.getShader()==CMaterial::Specular) { // Add it to the rdrPass to sort! CSkinSpecularRdrPass specRdrPass; specRdrPass.SkinIndex= skinIndex; specRdrPass.RdrPassIndex= i; // Get the handle of the specular Map as the sort Key ITexture *specTex= material.getTexture(1); if(!specTex) specRdrPass.SpecId= 0; else specRdrPass.SpecId= drv->getTextureHandle( *specTex ); // Append it to the list specularRdrPasses.push_back(specRdrPass); } else { // Get the shifted triangles. CShiftedTriangleCache::CRdrPass &shiftedRdrPass= mi->_ShiftedTriangleCache->RdrPass[i]; // This speed up 4 ms for 80K polys. uint memToCache= shiftedRdrPass.NumTriangles*12; memToCache= min(memToCache, 4096U); CFastMem::precache(shiftedRdrPass.Triangles, memToCache); // Render with the Materials of the MeshInstance. drv->renderTriangles(material, shiftedRdrPass.Triangles, shiftedRdrPass.NumTriangles); } } }

void NL3D::CMeshMRMGeom::renderSkinGroupSpecularRdrPass (  CMeshMRMInstance *  mi, uint  rdrPassId )

Definition at line 1488 of file mesh_mrm.cpp. References _LastLodComputed, _Lods, NL3D::CMeshMRMInstance::_ShiftedTriangleCache, NL3D::CRenderTrav::getDriver(), NL3D::CTransform::getOwnerScene(), NL3D::CScene::getRenderTrav(), H_AUTO, NL3D::CMeshMRMGeom::CRdrPass::MaterialId, NL3D::CMeshBaseInstance::Materials, min, nlassert, NL3D::CShiftedTriangleCache::CRdrPass::NumTriangles, NL3D::CShiftedTriangleCache::RdrPass, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::IDriver::renderTriangles(), NL3D::CShiftedTriangleCache::CRdrPass::Triangles, and uint. Referenced by NL3D::CMeshMRMInstance::renderSkinGroupSpecularRdrPass(). { H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpSpecularRdrPass ); // 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); // Get the lod choosen in renderSkinGroupGeom() CLod &lod= _Lods[_LastLodComputed]; // _ShiftedTriangleCache must have been computed in renderSkinGroupPrimitives nlassert(mi->_ShiftedTriangleCache); // Render Triangles with cache //=========== CRdrPass &rdrPass= lod.RdrPass[rdrPassId]; // CMaterial Ref CMaterial &material=mi->Materials[rdrPass.MaterialId]; // Get the shifted triangles. CShiftedTriangleCache::CRdrPass &shiftedRdrPass= mi->_ShiftedTriangleCache->RdrPass[rdrPassId]; // This speed up 4 ms for 80K polys. uint memToCache= shiftedRdrPass.NumTriangles*12; memToCache= min(memToCache, 4096U); CFastMem::precache(shiftedRdrPass.Triangles, memToCache); // Render with the Materials of the MeshInstance. drv->renderTriangles(material, shiftedRdrPass.Triangles, shiftedRdrPass.NumTriangles); }

void NL3D::CMeshMRMGeom::restoreOriginalSkinPart (  CLod &  lod, IVertexBufferHard *  currentVBHard )  [private]

Skinning: same as restoreOriginalSkinVertices(), but for one Lod only. Definition at line 2131 of file mesh_mrm.cpp. References _VBufferFinal, NL3D::CVertexBuffer::getNormalOff(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexFormat(), NL3D::CVertexBuffer::getVertexSize(), index, NL3D::CMeshMRMGeom::CLod::InfluencedVertices, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, NL3D::CMeshMRMGeom::CLod::OriginalSkinRestored, sint32, uint, uint32, and uint8. Referenced by render(). { nlassert(_Skinned); /* YOYO: _Skinned mrms no more support vertexBufferHard see note in renderSkin() */ // get vertexPtr / normalOff. //=========================== uint8 *destVertexPtr= (uint8*)_VBufferFinal.getVertexCoordPointer(); uint flags= _VBufferFinal.getVertexFormat(); sint32 vertexSize= _VBufferFinal.getVertexSize(); // must have XYZ. nlassert(flags & CVertexBuffer::PositionFlag); // Compute offset of each component of the VB. sint32 normalOff; if(flags & CVertexBuffer::NormalFlag) normalOff= _VBufferFinal.getNormalOff(); else normalOff= 0; // compute src array. CVector *srcVertexPtr; CVector *srcNormalPtr= NULL; srcVertexPtr= &_OriginalSkinVertices[0]; if(normalOff) srcNormalPtr= &(_OriginalSkinNormals[0]); // copy skinning. //=========================== for(uint i=0;i<NL3D_MESH_SKINNING_MAX_MATRIX;i++) { uint nInf= lod.InfluencedVertices[i].size(); if( nInf==0 ) continue; uint32 *infPtr= &(lod.InfluencedVertices[i][0]); // for all InfluencedVertices only. for(;nInf>0;nInf--, infPtr++) { uint index= *infPtr; CVector *srcVertex= srcVertexPtr + index; CVector *srcNormal= srcNormalPtr + index; uint8 *dstVertexVB= destVertexPtr + index * vertexSize; CVector *dstVertex= (CVector*)(dstVertexVB); CVector *dstNormal= (CVector*)(dstVertexVB + normalOff); // Vertex. *dstVertex= *srcVertex; // Normal. if(normalOff) *dstNormal= *srcNormal; } } // clean this lod part. (NB: this is not optimal, but sufficient :) ). lod.OriginalSkinRestored= true; }

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

Skinning: restore Vertex/Normal from _OriginalSkin* to VBuffer. Definition at line 2095 of file mesh_mrm.cpp. References _VBufferFinal, NL3D::CVertexBuffer::getNormalCoordPointer(), NL3D::CVertexBuffer::getNumTexCoordUsed(), NL3D::CVertexBuffer::getNumVertices(), NL3D::CVertexBuffer::getTexCoordPointer(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexFormat(), nlassert, and uint. { nlassert(_Skinned); // Copy VBuffer content into Original vertices normals. if(_VBufferFinal.getVertexFormat() & CVertexBuffer::PositionFlag) { // copy vertices from VBuffer. (NB: unusefull geomorphed vertices are still copied, but doesn't matter). for(uint i=0; i<_VBufferFinal.getNumVertices();i++) { *(CVector*)_VBufferFinal.getVertexCoordPointer(i)= _OriginalSkinVertices[i]; } } if(_VBufferFinal.getVertexFormat() & CVertexBuffer::NormalFlag) { // copy normals from VBuffer. (NB: unusefull geomorphed normals are still copied, but doesn't matter). for(uint i=0; i<_VBufferFinal.getNumVertices();i++) { *(CVector*)_VBufferFinal.getNormalCoordPointer(i)= _OriginalSkinNormals[i]; } } if (_MeshVertexProgram && _MeshVertexProgram->needTangentSpace()) { uint numTexCoords = _VBufferFinal.getNumTexCoordUsed(); nlassert(numTexCoords >= 2); nlassert(_OriginalTGSpace.size() == _VBufferFinal.getNumVertices()); // copy tangent space vectors for(uint i = 0; i < _VBufferFinal.getNumVertices(); ++i) { *(CVector*)_VBufferFinal.getTexCoordPointer(i, numTexCoords - 1)= _OriginalTGSpace[i]; } } }

void NL3D::CMeshMRMGeom::save (  NLMISC::IStream &  f  )  throw (NLMISC::EStream) [private]

save the entire mesh. Definition at line 1792 of file mesh_mrm.cpp. References nlassert, sint, sint32, uint, and uint32. { /* Version 5: - Shadow Skinning Version 4: - serial SkinWeights per MRM, not per Lod Version 3: - Bones names. Version 2: - Mesh Vertex Program. Version 1: - added blend shapes Version 0: - base version. */ sint ver= f.serialVersion(5); uint i; // if >= version 3, serial bones names f.serialCont (_BonesName); // Warning, if you have skinned this shape, you can't write it anymore because skinning id have been changed! nlassert (_BoneIdComputed==false); // Mesh Vertex Program. if (ver >= 2) { IMeshVertexProgram *mvp= NULL; mvp= _MeshVertexProgram; f.serialPolyPtr(mvp); } // blend shapes if (ver >= 1) f.serial (_MeshMorpher); // must have good original Skinned Vertex before writing. if( _Skinned ) { restoreOriginalSkinVertices(); } // serial Basic info. // ================== f.serial(_Skinned); f.serial(_BBox); f.serial(_LevelDetail.MaxFaceUsed); f.serial(_LevelDetail.MinFaceUsed); f.serial(_LevelDetail.DistanceFinest); f.serial(_LevelDetail.DistanceMiddle); f.serial(_LevelDetail.DistanceCoarsest); f.serial(_LevelDetail.OODistanceDelta); f.serial(_LevelDetail.DistancePow); f.serialCont(_LodInfos); // save number of wedges. uint32 nWedges; nWedges= _VBufferFinal.getNumVertices(); f.serial(nWedges); // Save the VBuffer header. _VBufferFinal.serialHeader(f); // If new version, serial SkinWeights in header, not in lods. if(ver >= 4) { f.serialCont(_SkinWeights); } // if >= version 5, serial Shadow Skin Information if(ver>=5) { f.serialCont (_ShadowSkinVertices); f.serialCont (_ShadowSkinTriangles); } // Serial lod offsets. // ================== // This is the reference pos, to load / save relative offsets. sint32 startPos = f.getPos(); // Those are the lodOffsets, relative to startPos. vector<sint32> lodOffsets; lodOffsets.resize(_LodInfos.size(), 0); // write all dummy offset. For now (since we don't know what to set), compute the offset of // the sint32 to come back in serial lod parts below. for(i=0;i<_LodInfos.size(); i++) { lodOffsets[i]= f.getPos(); f.serial(lodOffsets[i]); } // Serial lod subsets. // ================== // Save all the lods. for(i=0;i<_LodInfos.size(); i++) { // get current absolute position. sint32 absCurPos= f.getPos(); // come back to "relative lodOffset" absolute position in the stream. (temp stored in lodOffset[i]). f.seek(lodOffsets[i], IStream::begin); // write the relative position of the lod to the stream. sint32 relCurPos= absCurPos - startPos; f.serial(relCurPos); // come back to absCurPos, to save the lod. f.seek(absCurPos, IStream::begin); // And so now, save the lod. // write the lod face data. f.serial(_Lods[i]); // write the lod vertex data. serialLodVertexData(f, _LodInfos[i].StartAddWedge, _LodInfos[i].EndAddWedges); } }

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

serial this meshGeom. Implements NLMISC::IStreamable. Definition at line 1613 of file mesh_mrm.cpp. { // because of complexity, serial is separated in save / load. if(f.isReading()) load(f); else save(f); }

void NL3D::CMeshMRMGeom::serialLodVertexData (  NLMISC::IStream &  f, uint  startWedge, uint  endWedge )  [private]

serial a subset of the vertices. Definition at line 1918 of file mesh_mrm.cpp. References _SkinWeights, _VBufferFinal, bkupOriginalSkinVerticesSubset(), NLMISC::IStream::isReading(), NLMISC::IStream::serial(), NL3D::CVertexBuffer::serialSubset(), NLMISC::IStream::serialVersion(), sint, and uint. Referenced by loadFirstLod(), and loadNextLod(). { /* Version 1: - serial SkinWeights per MRM, not per Lod */ sint ver= f.serialVersion(1); // VBuffer part. _VBufferFinal.serialSubset(f, startWedge, endWedge); // SkinWeights. if(_Skinned) { // Serialize SkinWeight per lod only for old versions. if(ver<1) { for(uint i= startWedge; i<endWedge; i++) { f.serial(_SkinWeights[i]); } } // if reading, must copy original vertices from VB. if( f.isReading()) { bkupOriginalSkinVerticesSubset(startWedge, endWedge); } } }

void NL3D::CMeshMRMGeom::setShadowMesh (  const std::vector< CShadowVertex > &  shadowVertices, const std::vector< uint32 > &  triangles )

Setup the ShadowMesh. Definition at line 3359 of file mesh_mrm.cpp. References _ShadowSkinTriangles, _ShadowSkinVertices, _SupportShadowSkinGrouping, NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES, and NL3D_SHADOW_MESH_SKIN_MANAGER_VERTEXFORMAT. { _ShadowSkinVertices= shadowVertices; _ShadowSkinTriangles= triangles; // update flag. Support Shadow SkinGrouping if Shadow setuped, and if not too many vertices. _SupportShadowSkinGrouping= !_ShadowSkinVertices.empty() && NL3D_SHADOW_MESH_SKIN_MANAGER_VERTEXFORMAT==CVertexBuffer::PositionFlag && _ShadowSkinVertices.size() <= NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES; }

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

true if the sort criterion must be by material. Else, sort per instance. Implements NL3D::IMeshGeom. Definition at line 2687 of file mesh_mrm.cpp. { // Can't do it per material since 2 lods may not have the same number of RdrPass!! return false; }

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

true if this meshGeom support meshBlock rendering. return false if skinned/meshMorphed. Implements NL3D::IMeshGeom. Definition at line 2673 of file mesh_mrm.cpp. Referenced by profileSceneRender(), and NL3D::CMeshMRM::supportMeshBlockRendering(). { /* Yoyo: Don't Support It for MRM because too Slow!! The problem is that lock() unlock() on each instance, on the same VBHeap IS AS SLOWER AS VB switching. TODO_OPTIMIZE: find a way to optimize MRM. */ return false; //return _SupportMeshBlockRendering; }

bool NL3D::CMeshMRMGeom::supportShadowSkinGrouping (   )  const [inline]

Render the ShadowSkin (SkinGroup like). Definition at line 325 of file mesh_mrm.h. References _SupportShadowSkinGrouping. Referenced by NL3D::CMeshMRMInstance::supportShadowSkinGrouping(). {return _SupportShadowSkinGrouping;}

bool NL3D::CMeshMRMGeom::supportSkinGrouping (   )  const

Definition at line 1312 of file mesh_mrm.cpp. References _SupportSkinGrouping. Referenced by NL3D::CMeshMRMInstance::supportSkinGrouping(). { return _SupportSkinGrouping; }

void NL3D::CMeshMRMGeom::unloadNextLod (  NLMISC::IStream &  f  )

UnLoad Lod getNbLodLoaded()-1 from memory. use getNbLodLoaded()-1 to know what Lod will be unloaded. NB: if getNbLodLoaded() <= 1, no op. Definition at line 2029 of file mesh_mrm.cpp. References _Lods, _NbLodLoaded, and getNbLodLoaded(). { // If just first lod remain (or no lod), quit if(getNbLodLoaded() <= 1) return; // Reset the entire Lod object. (Free Memory). contReset(_Lods[_NbLodLoaded-1]); // Dec LodLoaded count. _NbLodLoaded--; }

void NL3D::CMeshMRMGeom::updateRawSkinNormal (  bool  enabled, CMeshMRMInstance *  mi, sint  curLodId )  [private]

compute RawSkin info in the MRMInstance according to current skin setup. Definition at line 3060 of file mesh_mrm.cpp. References _Lods, _MeshDataId, NL3D::CMeshMRMInstance::_RawSkinCache, _SkinWeights, _VBufferFinal, NL3D::CMeshMorpher::BlendShapes, NL3D::CRawSkinNormalCache::clearArrays(), NL3D::CMeshMRMInstance::clearRawSkinCache(), NL3D::CRawSkinNormalCache::Geomorphs, NL3D::CMeshMRMGeom::CLod::Geomorphs, NL3D::CVertexBuffer::getNumVertices(), NL3D::CVertexBuffer::getTexCoordPointer(), H_AUTO, NL3D::CRawSkinNormalCache::HardVertices, NL3D::CMeshMRMGeom::CLod::InfluencedVertices, NL3D::CRawSkinNormalCache::LodId, NL3D::CRawSkinNormalCache::MeshDataId, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::CRawSkinNormalCache::RdrPass, NLMISC::CObjectVector< CRawSkinVertex *, false >::resize(), NLMISC::CObjectVector< CRawVertexNormalSkin4, false >::resize(), NLMISC::CObjectVector< CRawVertexNormalSkin3, false >::resize(), NLMISC::CObjectVector< CRawVertexNormalSkin2, false >::resize(), NLMISC::CObjectVector< CRawVertexNormalSkin1, false >::resize(), sint, NLMISC::CObjectVector< CRawVertexNormalSkin4, false >::size(), NLMISC::CObjectVector< CRawVertexNormalSkin3, false >::size(), NLMISC::CObjectVector< CRawVertexNormalSkin2, false >::size(), NLMISC::CObjectVector< CRawVertexNormalSkin1, false >::size(), NL3D::CRawSkinNormalCache::SoftVertices, NL3D::CRawSkinNormalCache::TotalHardVertices, NL3D::CRawSkinNormalCache::TotalSoftVertices, uint, uint32, NL3D::CRawSkinNormalCache::VertexRemap, NL3D::CRawSkinNormalCache::Vertices1, NL3D::CRawSkinNormalCache::Vertices2, NL3D::CRawSkinNormalCache::Vertices3, and NL3D::CRawSkinNormalCache::Vertices4. Referenced by renderSkin(), and renderSkinGroupGeom(). { if(!enabled) { // if the instance cache is not cleared, must clear. if(mi->_RawSkinCache) mi->clearRawSkinCache(); } else { // If the instance has no RawSkin, or has a too old RawSkin cache, must delete it, and recreate if( !mi->_RawSkinCache || mi->_RawSkinCache->MeshDataId!=_MeshDataId) { // first delete if too old. if(mi->_RawSkinCache) mi->clearRawSkinCache(); // Then recreate, and use _MeshDataId to verify that the instance works with same data. mi->_RawSkinCache= new CRawSkinNormalCache; mi->_RawSkinCache->MeshDataId= _MeshDataId; mi->_RawSkinCache->LodId= -1; } /* If the instance rawSkin has a different Lod (or if -1), then must recreate it. NB: The lod may change each frame per instance, but suppose not so many change, so we can cache those data. */ if( mi->_RawSkinCache->LodId != curLodId ) { H_AUTO( NL3D_CMeshMRMGeom_updateRawSkinNormal ); CRawSkinNormalCache &skinLod= *mi->_RawSkinCache; CLod &lod= _Lods[curLodId]; uint i; sint rawIdx; // Clear the raw skin mesh. skinLod.clearArrays(); // Cache this lod mi->_RawSkinCache->LodId= curLodId; // For each matrix influence. nlassert(NL3D_MESH_SKINNING_MAX_MATRIX==4); // For each vertex, acknowledge if it is a src for geomorph. static vector<uint8> softVertices; softVertices.clear(); softVertices.resize( _VBufferFinal.getNumVertices(), 0 ); for(i=0;i<lod.Geomorphs.size();i++) { softVertices[lod.Geomorphs[i].Start]= 1; softVertices[lod.Geomorphs[i].End]= 1; } // The remap from old index in _VBufferFinal to RawSkin vertices (without Geomorphs). static vector<uint32> vertexRemap; vertexRemap.resize( _VBufferFinal.getNumVertices() ); sint softSize[4]; sint hardSize[4]; sint softStart[4]; sint hardStart[4]; // count vertices skinLod.TotalSoftVertices= 0; skinLod.TotalHardVertices= 0; for(i=0;i<4;i++) { softSize[i]= 0; hardSize[i]= 0; // Count. for(uint j=0;j<lod.InfluencedVertices[i].size();j++) { uint vid= lod.InfluencedVertices[i][j]; if(softVertices[vid]) softSize[i]++; else hardSize[i]++; } skinLod.TotalSoftVertices+= softSize[i]; skinLod.TotalHardVertices+= hardSize[i]; skinLod.SoftVertices[i]= softSize[i]; skinLod.HardVertices[i]= hardSize[i]; } // compute offsets softStart[0]= 0; hardStart[0]= skinLod.TotalSoftVertices; for(i=1;i<4;i++) { softStart[i]= softStart[i-1]+softSize[i-1]; hardStart[i]= hardStart[i-1]+hardSize[i-1]; } // compute remap for(i=0;i<4;i++) { uint softIdx= softStart[i]; uint hardIdx= hardStart[i]; for(uint j=0;j<lod.InfluencedVertices[i].size();j++) { uint vid= lod.InfluencedVertices[i][j]; if(softVertices[vid]) vertexRemap[vid]= softIdx++; else vertexRemap[vid]= hardIdx++; } } // Resize the dest array. skinLod.Vertices1.resize(lod.InfluencedVertices[0].size()); skinLod.Vertices2.resize(lod.InfluencedVertices[1].size()); skinLod.Vertices3.resize(lod.InfluencedVertices[2].size()); skinLod.Vertices4.resize(lod.InfluencedVertices[3].size()); // Remap for BlendShape. Lasts 2 bits tells what RawSkin Array to seek (1 to 4), // low Bits indicate the number in them. 0xFFFFFFFF is a special value indicating "NotUsed in this lod" static vector<uint32> vertexFinalRemap; vertexFinalRemap.clear(); vertexFinalRemap.resize(vertexRemap.size(), 0xFFFFFFFF); // 1 Matrix skinning. //======== for(i=0;i<skinLod.Vertices1.size();i++) { // get the dest vertex. uint vid= lod.InfluencedVertices[0][i]; // where to store? rawIdx= vertexRemap[vid]; if(softVertices[vid]) rawIdx-= softStart[0]; else rawIdx+= softSize[0]-hardStart[0]; // for BlendShapes remapping vertexFinalRemap[vid]= (0<<30) + rawIdx; // fill raw struct skinLod.Vertices1[rawIdx].MatrixId[0]= _SkinWeights[vid].MatrixId[0]; skinLod.Vertices1[rawIdx].Vertex.Pos= _OriginalSkinVertices[vid]; skinLod.Vertices1[rawIdx].Vertex.Normal= _OriginalSkinNormals[vid]; skinLod.Vertices1[rawIdx].Vertex.UV= *(CUV*)_VBufferFinal.getTexCoordPointer(vid); } // 2 Matrix skinning. //======== for(i=0;i<skinLod.Vertices2.size();i++) { // get the dest vertex. uint vid= lod.InfluencedVertices[1][i]; // where to store? rawIdx= vertexRemap[vid]; if(softVertices[vid]) rawIdx-= softStart[1]; else rawIdx+= softSize[1]-hardStart[1]; // for BlendShapes remapping vertexFinalRemap[vid]= (1<<30) + rawIdx; // fill raw struct skinLod.Vertices2[rawIdx].MatrixId[0]= _SkinWeights[vid].MatrixId[0]; skinLod.Vertices2[rawIdx].MatrixId[1]= _SkinWeights[vid].MatrixId[1]; skinLod.Vertices2[rawIdx].Weights[0]= _SkinWeights[vid].Weights[0]; skinLod.Vertices2[rawIdx].Weights[1]= _SkinWeights[vid].Weights[1]; skinLod.Vertices2[rawIdx].Vertex.Pos= _OriginalSkinVertices[vid]; skinLod.Vertices2[rawIdx].Vertex.Normal= _OriginalSkinNormals[vid]; skinLod.Vertices2[rawIdx].Vertex.UV= *(CUV*)_VBufferFinal.getTexCoordPointer(vid); } // 3 Matrix skinning. //======== for(i=0;i<skinLod.Vertices3.size();i++) { // get the dest vertex. uint vid= lod.InfluencedVertices[2][i]; // where to store? rawIdx= vertexRemap[vid]; if(softVertices[vid]) rawIdx-= softStart[2]; else rawIdx+= softSize[2]-hardStart[2]; // for BlendShapes remapping vertexFinalRemap[vid]= (2<<30) + rawIdx; // fill raw struct skinLod.Vertices3[rawIdx].MatrixId[0]= _SkinWeights[vid].MatrixId[0]; skinLod.Vertices3[rawIdx].MatrixId[1]= _SkinWeights[vid].MatrixId[1]; skinLod.Vertices3[rawIdx].MatrixId[2]= _SkinWeights[vid].MatrixId[2]; skinLod.Vertices3[rawIdx].Weights[0]= _SkinWeights[vid].Weights[0]; skinLod.Vertices3[rawIdx].Weights[1]= _SkinWeights[vid].Weights[1]; skinLod.Vertices3[rawIdx].Weights[2]= _SkinWeights[vid].Weights[2]; skinLod.Vertices3[rawIdx].Vertex.Pos= _OriginalSkinVertices[vid]; skinLod.Vertices3[rawIdx].Vertex.Normal= _OriginalSkinNormals[vid]; skinLod.Vertices3[rawIdx].Vertex.UV= *(CUV*)_VBufferFinal.getTexCoordPointer(vid); } // 4 Matrix skinning. //======== for(i=0;i<skinLod.Vertices4.size();i++) { // get the dest vertex. uint vid= lod.InfluencedVertices[3][i]; // where to store? rawIdx= vertexRemap[vid]; if(softVertices[vid]) rawIdx-= softStart[3]; else rawIdx+= softSize[3]-hardStart[3]; // for BlendShapes remapping vertexFinalRemap[vid]= (3<<30) + rawIdx; // fill raw struct skinLod.Vertices4[rawIdx].MatrixId[0]= _SkinWeights[vid].MatrixId[0]; skinLod.Vertices4[rawIdx].MatrixId[1]= _SkinWeights[vid].MatrixId[1]; skinLod.Vertices4[rawIdx].MatrixId[2]= _SkinWeights[vid].MatrixId[2]; skinLod.Vertices4[rawIdx].MatrixId[3]= _SkinWeights[vid].MatrixId[3]; skinLod.Vertices4[rawIdx].Weights[0]= _SkinWeights[vid].Weights[0]; skinLod.Vertices4[rawIdx].Weights[1]= _SkinWeights[vid].Weights[1]; skinLod.Vertices4[rawIdx].Weights[2]= _SkinWeights[vid].Weights[2]; skinLod.Vertices4[rawIdx].Weights[3]= _SkinWeights[vid].Weights[3]; skinLod.Vertices4[rawIdx].Vertex.Pos= _OriginalSkinVertices[vid]; skinLod.Vertices4[rawIdx].Vertex.Normal= _OriginalSkinNormals[vid]; skinLod.Vertices4[rawIdx].Vertex.UV= *(CUV*)_VBufferFinal.getTexCoordPointer(vid); } // Remap Geomorphs. //======== uint numGeoms= lod.Geomorphs.size(); skinLod.Geomorphs.resize( numGeoms ); for(i=0;i<numGeoms;i++) { // NB: don't add "numGeoms" to the index because RawSkin look in a TempArray in RAM, wich start at 0... skinLod.Geomorphs[i].Start= vertexRemap[lod.Geomorphs[i].Start]; skinLod.Geomorphs[i].End= vertexRemap[lod.Geomorphs[i].End]; } // Remap RdrPass. //======== skinLod.RdrPass.resize(lod.RdrPass.size()); for(i=0;i<skinLod.RdrPass.size();i++) { // NB: since RawSkin is possible only with SkinGrouping, and since SkniGrouping is // possible only with no Quads/Lines, we should have only Tris here. nlassert( lod.RdrPass[i].PBlock.getNumQuad()== 0); nlassert( lod.RdrPass[i].PBlock.getNumLine()== 0); // remap tris. skinLod.RdrPass[i].setNumTri(lod.RdrPass[i].PBlock.getNumTri()); uint32 *srcTriPtr= lod.RdrPass[i].PBlock.getTriPointer(); uint32 *dstTriPtr= skinLod.RdrPass[i].getTriPointer(); uint32 numIndices= lod.RdrPass[i].PBlock.getNumTri()*3; for(uint j=0;j<numIndices;j++, srcTriPtr++, dstTriPtr++) { uint vid= *srcTriPtr; // If this index refers to a Geomorphed vertex, don't modify! if(vid<numGeoms) *dstTriPtr= vid; else *dstTriPtr= vertexRemap[vid] + numGeoms; } } // Case of MeshMorpher //======== if(_MeshMorpher.BlendShapes.size()>0) { skinLod.VertexRemap.resize(vertexFinalRemap.size()); for(i=0;i<vertexFinalRemap.size();i++) { uint vfr= vertexFinalRemap[i]; if(vfr!=0xFFFFFFFF) { uint rsArrayId= vfr >> 30; uint rsIndex= vfr & ((1<<30)-1); switch(rsArrayId) { case 0: skinLod.VertexRemap[i]= &skinLod.Vertices1[rsIndex].Vertex; break; case 1: skinLod.VertexRemap[i]= &skinLod.Vertices2[rsIndex].Vertex; break; case 2: skinLod.VertexRemap[i]= &skinLod.Vertices3[rsIndex].Vertex; break; case 3: skinLod.VertexRemap[i]= &skinLod.Vertices4[rsIndex].Vertex; break; }; } else skinLod.VertexRemap[i]= NULL; } } } } }

void NL3D::CMeshMRMGeom::updateShiftedTriangleCache (  CMeshMRMInstance *  mi, sint  curLodId, uint  baseVertex )  [private]

Definition at line 1529 of file mesh_mrm.cpp. References _Lods, _MeshDataId, NL3D::CMeshMRMInstance::_RawSkinCache, NL3D::CMeshMRMInstance::_ShiftedTriangleCache, NL3D::CShiftedTriangleCache::BaseVertex, NL3D::CMeshMRMInstance::clearShiftedTriangleCache(), NLMISC::CObjectVector< uint32, false >::getPtr(), NL3D::CShiftedTriangleCache::LodId, NL3D::CShiftedTriangleCache::MeshDataId, NL3D::CShiftedTriangleCache::CRdrPass::NumTriangles, NL3D::CShiftedTriangleCache::RawIndices, NL3D::CShiftedTriangleCache::RdrPass, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::CRawSkinNormalCache::RdrPass, NLMISC::CObjectVector< uint32, false >::resize(), NLMISC::CObjectVector< CRdrPass, false >::resize(), sint, NL3D::CShiftedTriangleCache::CRdrPass::Triangles, uint, and uint32. Referenced by renderSkinGroupPrimitives(). { // if the instance has a cache, but not sync to us, delete it. if( mi->_ShiftedTriangleCache && ( mi->_ShiftedTriangleCache->MeshDataId != _MeshDataId || mi->_ShiftedTriangleCache->LodId != curLodId || mi->_ShiftedTriangleCache->BaseVertex != baseVertex) ) { mi->clearShiftedTriangleCache(); } // If the instance has not a valid cache, must create it. if( !mi->_ShiftedTriangleCache ) { mi->_ShiftedTriangleCache= new CShiftedTriangleCache; // Fill the cache Key. mi->_ShiftedTriangleCache->MeshDataId= _MeshDataId; mi->_ShiftedTriangleCache->LodId= curLodId; mi->_ShiftedTriangleCache->BaseVertex= baseVertex; // Build list of PBlock. From Lod, or from RawSkin cache. static vector<CPrimitiveBlock*> pbList; pbList.clear(); if(mi->_RawSkinCache) { pbList.resize(mi->_RawSkinCache->RdrPass.size()); for(uint i=0;i<pbList.size();i++) { pbList[i]= &mi->_RawSkinCache->RdrPass[i]; } } else { CLod &lod= _Lods[curLodId]; pbList.resize(lod.RdrPass.size()); for(uint i=0;i<pbList.size();i++) { pbList[i]= &lod.RdrPass[i].PBlock; } } // Build RdrPass mi->_ShiftedTriangleCache->RdrPass.resize(pbList.size()); // First pass, count number of triangles, and fill header info uint totalTri= 0; uint i; for(i=0;i<pbList.size();i++) { mi->_ShiftedTriangleCache->RdrPass[i].NumTriangles= pbList[i]->getNumTri(); totalTri+= pbList[i]->getNumTri(); } // Allocate triangles indices. mi->_ShiftedTriangleCache->RawIndices.resize(totalTri*3); uint32 *rawPtr= mi->_ShiftedTriangleCache->RawIndices.getPtr(); // Second pass, fill ptrs, and fill Arrays uint indexTri= 0; for(i=0;i<pbList.size();i++) { CShiftedTriangleCache::CRdrPass &dstRdrPass= mi->_ShiftedTriangleCache->RdrPass[i]; dstRdrPass.Triangles= rawPtr + indexTri*3; // Fill the array uint numTris= pbList[i]->getNumTri(); if(numTris) { uint nIds= numTris*3; // index, and fill uint32 *pSrcTri= pbList[i]->getTriPointer(); uint32 *pDstTri= dstRdrPass.Triangles; for(;nIds>0;nIds--,pSrcTri++,pDstTri++) *pDstTri= *pSrcTri + baseVertex; } // Next indexTri+= dstRdrPass.NumTriangles; } } }

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

update Skeleton Usage. increment or decrement. computeBonesId must has been called before. Definition at line 2535 of file mesh_mrm.cpp. References NL3D::CSkeletonModel::Bones, NL3D::CSkeletonModel::decBoneUsage(), NL3D::CSkeletonModel::incBoneUsage(), nlerror, and uint. Referenced by NL3D::CMeshMRM::updateSkeletonUsage(). { // For all Bones used. 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::CMeshMRMGeom::updateVertexBufferHard (  IDriver *  drv, uint32  numVertices )  [private]

Definition at line 2224 of file mesh_mrm.cpp. References _VBufferFinal, 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(), NL3D::IDriver::supportVertexBufferHard(), and uint32. Referenced by beginMesh(), and render(). { if(!drv->supportVertexBufferHard() || numVertices==0) return; bool avoidVBHard; avoidVBHard= _Skinned || ( _MeshMorpher.BlendShapes.size()>0 && drv->slowUnlockVertexBufferHard() ); if( _VertexBufferHardDirty && avoidVBHard ) { // delete possible old VBHard. if(_VBHard!=NULL) { // VertexBufferHard lifetime < Driver lifetime. nlassert(_Driver!=NULL); _Driver->deleteVertexBufferHard(_VBHard); } return; } // If the vbufferhard is not here, or if dirty, or if do not have enough vertices. if(_VBHard==NULL || _VertexBufferHardDirty || _VBHard->getNumVertices() < numVertices) { _VertexBufferHardDirty= false; // delete possible old _VBHard. if(_VBHard!=NULL) { // VertexBufferHard lifetime < Driver lifetime. nlassert(_Driver!=NULL); _Driver->deleteVertexBufferHard(_VBHard); } // 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 _VBHard= _Driver->createVertexBufferHard(_VBufferFinal.getVertexFormat(), _VBufferFinal.getValueTypePointer (), numVertices, IDriver::VBHardAGP, _VBufferFinal.getUVRouting()); // If KO, use normal VertexBuffer, else, Fill it with VertexBuffer. if(_VBHard!=NULL) { void *vertexPtr= _VBHard->lock(); nlassert(_VBufferFinal.getVertexFormat() == _VBHard->getVertexFormat()); nlassert(_VBufferFinal.getNumVertices() >= numVertices); nlassert(_VBufferFinal.getVertexSize() == _VBHard->getVertexSize()); // \todo yoyo: TODO_DX8 and DX8 ??? // Because same internal format, just copy all block. memcpy(vertexPtr, _VBufferFinal.getVertexCoordPointer(), numVertices * _VBufferFinal.getVertexSize() ); _VBHard->unlock(); } } }

---

Friends And Related Function Documentation

friend class CLod [friend]

Definition at line 416 of file mesh_mrm.h.

friend class CMRMBuilder [friend]

Definition at line 333 of file mesh_mrm.h.

---

Field Documentation

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

For clipping. this is the BB of all vertices of all Lods. Definition at line 515 of file mesh_mrm.h.

bool NL3D::CMeshMRMGeom::_BoneIdComputed [private]

This boolean is true if the bones id have been passed in the skeleton. Definition at line 493 of file mesh_mrm.h.

bool NL3D::CMeshMRMGeom::_BoneIdExtended [private]

true if the _BonesIdExt have been computed (for bone Usage). Definition at line 495 of file mesh_mrm.h.

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

This array give the index in the skeleton of the local bones used. computed at first computeBoneId(). Definition at line 506 of file mesh_mrm.h.

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

Same as _BonesId but with parent of bones added. (used for bone usage). Definition at line 508 of file mesh_mrm.h.

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

This array give the name of the local bones. Definition at line 504 of file mesh_mrm.h.

std::vector<NLMISC::CBSphere> NL3D::CMeshMRMGeom::_BonesSphere [private]

see CTransform::getSkinBoneSphere() doc for the meaning of this value Definition at line 510 of file mesh_mrm.h. Referenced by computeBonesId(), and getSkinBoneSphere().

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

Definition at line 534 of file mesh_mrm.h.

uint8 NL3D::CMeshMRMGeom::_LastLodComputed [private]

Last lod rendered. used with renderSkinGroup*() only. Definition at line 501 of file mesh_mrm.h. Referenced by renderSkinGroupGeom(), renderSkinGroupPrimitives(), and renderSkinGroupSpecularRdrPass().

CMRMLevelDetail NL3D::CMeshMRMGeom::_LevelDetail [private]

Definition at line 525 of file mesh_mrm.h. Referenced by activeInstance(), build(), changeMRMDistanceSetup(), getLevelDetail(), getNumTriangles(), profileSceneRender(), and render().

std::vector<CLodInfo> NL3D::CMeshMRMGeom::_LodInfos [private]

Info for pre-loading Lods. Definition at line 519 of file mesh_mrm.h. Referenced by build(), loadFirstLod(), and loadNextLod().

std::vector<CLod> NL3D::CMeshMRMGeom::_Lods [private]

List of Lods. Definition at line 513 of file mesh_mrm.h. Referenced by activeInstance(), applyArrayShadowSkin(), applyMaterialRemap(), beginMesh(), build(), chooseLod(), compileRunTime(), computeBonesId(), computeMeshVBHeap(), endMesh(), getGeomorphs(), getNbLod(), getNbRdrPass(), getNumRdrPassesForInstance(), getRdrPassMaterial(), getRdrPassPrimitiveBlock(), loadFirstLod(), loadNextLod(), profileSceneRender(), render(), renderPass(), renderSkin(), renderSkinGroupGeom(), renderSkinGroupPrimitives(), renderSkinGroupSpecularRdrPass(), unloadNextLod(), updateRawSkinNormal(), and updateShiftedTriangleCache().

bool NL3D::CMeshMRMGeom::_MBRBkupNormalize [private]

BeginMesh setup. Definition at line 562 of file mesh_mrm.h. Referenced by beginMesh(), and endMesh().

sint NL3D::CMeshMRMGeom::_MBRCurrentLodId [private]

global setup at activateInstance() Definition at line 564 of file mesh_mrm.h. Referenced by activeInstance(), CMeshMRMGeom(), getNumRdrPassesForInstance(), and renderPass().

uint NL3D::CMeshMRMGeom::_MeshDataId [private]

Each time the mesh is loaded/built, this increment. Definition at line 639 of file mesh_mrm.h. Referenced by CMeshMRMGeom(), dirtMeshDataId(), updateRawSkinNormal(), and updateShiftedTriangleCache().

CMeshMorpher NL3D::CMeshMRMGeom::_MeshMorpher [private]

Definition at line 552 of file mesh_mrm.h.

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

Definition at line 555 of file mesh_mrm.h.

uint NL3D::CMeshMRMGeom::_NbLodLoaded [private]

Definition at line 520 of file mesh_mrm.h. Referenced by build(), chooseLod(), CMeshMRMGeom(), getNbLodLoaded(), loadFirstLod(), loadNextLod(), and unloadNextLod().

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

Definition at line 481 of file mesh_mrm.h.

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

Skinning: this is the list of vertices (mirror of VBuffer), at the bind Pos. Definition at line 480 of file mesh_mrm.h.

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

Definition at line 482 of file mesh_mrm.h.

bool NL3D::CMeshMRMGeom::_PreciseClipping [private]

NB: HERE FOR PACKING ONLY. For clipping. Estimate if we must do a Precise clipping (ie with bboxes). Definition at line 538 of file mesh_mrm.h.

std::vector<uint32> NL3D::CMeshMRMGeom::_ShadowSkinTriangles [private]

Definition at line 571 of file mesh_mrm.h. Referenced by renderShadowSkinPrimitives(), and setShadowMesh().

std::vector<CShadowVertex> NL3D::CMeshMRMGeom::_ShadowSkinVertices [private]

Definition at line 570 of file mesh_mrm.h. Referenced by compileRunTime(), computeBonesId(), getNumShadowSkinVertices(), renderShadowSkinGeom(), and setShadowMesh().

bool NL3D::CMeshMRMGeom::_Skinned [private]

Skinning: This tells if the mesh is correctly skinned (suuport skinning). Definition at line 478 of file mesh_mrm.h.

std::vector<CMesh::CSkinWeight> NL3D::CMeshMRMGeom::_SkinWeights [private]

This is the array of SkinWeights, same size as the VB. Definition at line 490 of file mesh_mrm.h. Referenced by applySkin(), build(), buildBoneUsageVer2(), computeBonesId(), getSkinWeights(), serialLodVertexData(), and updateRawSkinNormal().

bool NL3D::CMeshMRMGeom::_SupportMeshBlockRendering [private]

setuped at compileRunTime. Definition at line 560 of file mesh_mrm.h. Referenced by CMeshMRMGeom(), compileRunTime(), and getVBHeapInfo().

bool NL3D::CMeshMRMGeom::_SupportShadowSkinGrouping [private]

Definition at line 572 of file mesh_mrm.h. Referenced by CMeshMRMGeom(), compileRunTime(), setShadowMesh(), and supportShadowSkinGrouping().

bool NL3D::CMeshMRMGeom::_SupportSkinGrouping [private]

if true, then maybe use faster render Definition at line 498 of file mesh_mrm.h. Referenced by CMeshMRMGeom(), compileRunTime(), and supportSkinGrouping().

CRefPtr<IVertexBufferHard> NL3D::CMeshMRMGeom::_VBHard [private]

Definition at line 532 of file mesh_mrm.h.

CVertexBuffer NL3D::CMeshMRMGeom::_VBufferFinal [private]

The Final VBuffer. Definition at line 487 of file mesh_mrm.h. Referenced by applyGeomorph(), applyGeomorphWithVBHardPtr(), applySkin(), beginMesh(), bkupOriginalSkinVertices(), bkupOriginalSkinVerticesSubset(), build(), compileRunTime(), computeMeshVBHeap(), getVBHeapInfo(), getVertexBuffer(), profileSceneRender(), render(), renderSkin(), renderSkinGroupGeom(), restoreOriginalSkinPart(), restoreOriginalSkinVertices(), serialLodVertexData(), updateRawSkinNormal(), and updateVertexBufferHard().

CVertexBuffer NL3D::CMeshMRMGeom::_VBufferOriginal [private]

The Original VBuffer. Definition at line 485 of file mesh_mrm.h. Referenced by render(), and renderSkin().

bool NL3D::CMeshMRMGeom::_VertexBufferHardDirty [private]

Definition at line 535 of file mesh_mrm.h.

uint NL3D::CMeshMRMGeom::NumCacheVertexNormal1 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin1) [static]

Definition at line 380 of file mesh_mrm_skin.cpp.

uint NL3D::CMeshMRMGeom::NumCacheVertexNormal2 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin2) [static]

Definition at line 382 of file mesh_mrm_skin.cpp.

uint NL3D::CMeshMRMGeom::NumCacheVertexNormal3 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin3) [static]

Definition at line 384 of file mesh_mrm_skin.cpp.

uint NL3D::CMeshMRMGeom::NumCacheVertexNormal4 = NL_BlockByteL1 / sizeof(CRawVertexNormalSkin4) [static]

Definition at line 386 of file mesh_mrm_skin.cpp.

uint NL3D::CMeshMRMGeom::NumCacheVertexShadow = NL_BlockByteL1 / sizeof(CMeshMRMGeom::CShadowVertex) [static]

Definition at line 389 of file mesh_mrm_skin.cpp. Referenced by applyArrayShadowSkin().

---

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

• mesh_mrm.h
• mesh_mrm.cpp
• mesh_mrm_skin.cpp

---