aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-09-22 12:40:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/3d/mesh.cpp

2784 lines
78 KiB
C++
Raw Normal View History

Merged in dfighter1985/ryzomcore/dfighter-tools (pull request #79) More studio changes
2014-09-10 18:19:49 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std3d.h"
#include "nel/3d/mesh.h"
#include "nel/3d/mesh_instance.h"
#include "nel/3d/scene.h"
#include "nel/3d/skeleton_model.h"
#include "nel/3d/mesh_morpher.h"
#include "nel/misc/bsphere.h"
#include "nel/3d/stripifier.h"
#include "nel/misc/fast_floor.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/3d/mesh_blender.h"
#include "nel/3d/matrix_3x4.h"
#include "nel/3d/render_trav.h"
#include "nel/3d/visual_collision_mesh.h"
#include "nel/3d/meshvp_wind_tree.h"
using namespace std;
using namespace NLMISC;
namespace NL3D
{
// ***************************************************************************
// ***************************************************************************
// MeshGeom Tools.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
static NLMISC::CAABBoxExt makeBBox(const std::vector<CVector> &Vertices)
{
NLMISC::CAABBox ret;
nlassert(Vertices.size());
ret.setCenter(Vertices[0]);
for(sint i=0;i<(sint)Vertices.size();i++)
{
ret.extend(Vertices[i]);
}
return ret;
}
// ***************************************************************************
sint CMeshGeom::CCornerTmp::Flags=0;
// ***************************************************************************
bool CMeshGeom::CCornerTmp::operator<(const CCornerTmp &c) const
{
sint i;
// Vert first.
if(Vertex!=c.Vertex)
return Vertex<c.Vertex;
// Order: normal, uvs, color0, color1, skinning.
if((CCornerTmp::Flags & CVertexBuffer::NormalFlag) && Normal!=c.Normal)
return Normal<c.Normal;
for(i=0; i<CVertexBuffer::MaxStage; i++)
{
if((CCornerTmp::Flags & (CVertexBuffer::TexCoord0Flag<<i)) && Uvws[i]!=c.Uvws[i])
return Uvws[i]<c.Uvws[i];
}
if((CCornerTmp::Flags & CVertexBuffer::PrimaryColorFlag) && Color!=c.Color)
return Color<c.Color;
if((CCornerTmp::Flags & CVertexBuffer::SecondaryColorFlag) && Specular!=c.Specular)
return Specular<c.Specular;
if ((CCornerTmp::Flags & CVertexBuffer::PaletteSkinFlag)==CVertexBuffer::PaletteSkinFlag)
{
for(i=0;i<NL3D_MESH_SKINNING_MAX_MATRIX;i++)
{
if(Palette.MatrixId[i] != c.Palette.MatrixId[i])
return Palette.MatrixId[i] < c.Palette.MatrixId[i];
if(Weights[i] != c.Weights[i])
return Weights[i] < c.Weights[i];
}
}
// All are equal!!
return false;
}
// ***************************************************************************
// ***************************************************************************
// CMeshGeom.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CMeshGeom::CMeshGeom()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
_Skinned= false;
_OriginalSkinRestored= true;
_MeshMorpher = new CMeshMorpher;
_BoneIdComputed = false;
_BoneIdExtended= false;
_PreciseClipping= false;
}
// ***************************************************************************
CMeshGeom::~CMeshGeom()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
delete _MeshMorpher;
}
// ***************************************************************************
void CMeshGeom::optimizeTriangleOrder()
{
CStripifier stripifier;
// for all rdrpass of all matrix blocks.
for(uint mb= 0;mb<_MatrixBlocks.size();mb++)
{
for(uint rp=0; rp<_MatrixBlocks[mb].RdrPass.size(); rp++ )
{
// stripify list of triangles of this pass.
CRdrPass &pass= _MatrixBlocks[mb].RdrPass[rp];
stripifier.optimizeTriangles(pass.PBlock, pass.PBlock);
}
}
}
// ***************************************************************************
void CMeshGeom::build (CMesh::CMeshBuild &m, uint numMaxMaterial)
{
sint i;
// Empty geometry?
if(m.Vertices.size()==0 || m.Faces.size()==0)
{
_VBuffer.setNumVertices(0);
_VBuffer.setName("CMeshGeom");
_VBuffer.reserve(0);
_MatrixBlocks.clear();
_BBox.setCenter(CVector::Null);
_BBox.setSize(CVector::Null);
return;
}
nlassert(numMaxMaterial>0);
// Copy the UV routing table
for (i=0; i<CVertexBuffer::MaxStage; i++)
_VBuffer.setUVRouting (i, m.UVRouting[i]);
/// 0. First, make bbox.
//======================
_BBox= makeBBox(m.Vertices);
/// 1. If skinning, group by matrix Block the vertices.
//================================================
// First, copy Face array.
vector<CFaceTmp> tmpFaces;
tmpFaces.resize(m.Faces.size());
for(i=0;i<(sint)tmpFaces.size();i++)
tmpFaces[i]= m.Faces[i];
_Skinned= ((m.VertexFlags & CVertexBuffer::PaletteSkinFlag)==CVertexBuffer::PaletteSkinFlag);
// Skinning is OK only if SkinWeights are of same size as vertices.
_Skinned= _Skinned && (m.Vertices.size()==m.SkinWeights.size());
// If skinning is KO, remove the Skin option.
uint vbFlags= m.VertexFlags;
if(!_Skinned)
vbFlags&= ~CVertexBuffer::PaletteSkinFlag;
// Force presence of vertex.
vbFlags|= CVertexBuffer::PositionFlag;
// If the mesh is not skinned, we have just 1 _MatrixBlocks.
if(!_Skinned)
{
_MatrixBlocks.resize(1);
// For each faces, assign it to the matrix block 0.
for(i=0;i<(sint)tmpFaces.size();i++)
tmpFaces[i].MatrixBlockId= 0;
}
// Else We must group/compute the matrixs blocks.
else
{
// reset matrix blocks.
_MatrixBlocks.clear();
// build matrix blocks, and link faces to good matrix blocks.
buildSkin(m, tmpFaces);
}
/// 2. Then, for all faces, resolve continuities, building VBuffer.
//================================================
// Setup VB.
_VBuffer.setNumVertices(0);
_VBuffer.reserve(0);
bool useFormatExt = false;
/** If all texture coordinates are of dimension 2, we can setup the flags as before.
* If this isn't the case, we must setup a custom format
*/
for (uint k = 0; k < CVertexBuffer::MaxStage; ++k)
{
if (
(vbFlags & (CVertexBuffer::TexCoord0Flag << k))
&& m.NumCoords[k] != 2)
{
useFormatExt = true;
break;
}
}
if (!useFormatExt)
{
// setup standard format
_VBuffer.setVertexFormat(vbFlags);
}
else // setup extended format
{
_VBuffer.clearValueEx();
if (vbFlags & CVertexBuffer::PositionFlag) _VBuffer.addValueEx(CVertexBuffer::Position, CVertexBuffer::Float3);
if (vbFlags & CVertexBuffer::NormalFlag) _VBuffer.addValueEx(CVertexBuffer::Normal, CVertexBuffer::Float3);
if (vbFlags & CVertexBuffer::PrimaryColorFlag) _VBuffer.addValueEx(CVertexBuffer::PrimaryColor, CVertexBuffer::UChar4);
if (vbFlags & CVertexBuffer::SecondaryColorFlag) _VBuffer.addValueEx(CVertexBuffer::SecondaryColor, CVertexBuffer::UChar4);
if (vbFlags & CVertexBuffer::WeightFlag) _VBuffer.addValueEx(CVertexBuffer::Weight, CVertexBuffer::Float4);
if (vbFlags & CVertexBuffer::PaletteSkinFlag) _VBuffer.addValueEx(CVertexBuffer::PaletteSkin, CVertexBuffer::UChar4);
if (vbFlags & CVertexBuffer::FogFlag) _VBuffer.addValueEx(CVertexBuffer::Fog, CVertexBuffer::Float1);
for (uint k = 0; k < CVertexBuffer::MaxStage; ++k)
{
if (vbFlags & (CVertexBuffer::TexCoord0Flag << k))
{
switch(m.NumCoords[k])
{
case 2:
_VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float2);
break;
case 3:
_VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float3);
break;
default:
nlassert(0);
break;
}
}
}
_VBuffer.initEx();
}
// Set local flags for corner comparison.
CCornerTmp::Flags= vbFlags;
// Setup locals.
TCornerSet corners;
const CFaceTmp *pFace= &(*tmpFaces.begin());
uint32 nFaceMB = 0;
sint N= (sint)tmpFaces.size();
sint currentVBIndex=0;
m.VertLink.clear ();
// process each face, building up the VB.
for(;N>0;N--, pFace++)
{
sint v0= pFace->Corner[0].Vertex;
sint v1= pFace->Corner[1].Vertex;
sint v2= pFace->Corner[2].Vertex;
findVBId(corners, &pFace->Corner[0], currentVBIndex, m.Vertices[v0], m);
findVBId(corners, &pFace->Corner[1], currentVBIndex, m.Vertices[v1], m);
findVBId(corners, &pFace->Corner[2], currentVBIndex, m.Vertices[v2], m);
CMesh::CVertLink vl1(nFaceMB, 0, pFace->Corner[0].VBId);
CMesh::CVertLink vl2(nFaceMB, 1, pFace->Corner[1].VBId);
CMesh::CVertLink vl3(nFaceMB, 2, pFace->Corner[2].VBId);
m.VertLink.push_back(vl1);
m.VertLink.push_back(vl2);
m.VertLink.push_back(vl3);
++nFaceMB;
}
/// 3. build the RdrPass material.
//================================
uint mb;
// For each _MatrixBlocks, point on those materials.
for(mb= 0;mb<_MatrixBlocks.size();mb++)
{
// Build RdrPass ids.
_MatrixBlocks[mb].RdrPass.resize (numMaxMaterial);
for(i=0;i<(sint)_MatrixBlocks[mb].RdrPass.size(); i++)
{
_MatrixBlocks[mb].RdrPass[i].MaterialId= i;
// for build, force 32 bit indices
_MatrixBlocks[mb].RdrPass[i].PBlock.setFormat(CIndexBuffer::Indices32);
}
}
/// 4. Then, for all faces, build the RdrPass PBlock.
//===================================================
pFace= &(*tmpFaces.begin());
N= (sint)tmpFaces.size();
for(;N>0;N--, pFace++)
{
sint mbId= pFace->MatrixBlockId;
nlassert(mbId>=0 && mbId<(sint)_MatrixBlocks.size());
// Insert the face in good MatrixBlock/RdrPass.
CIndexBuffer &ib = _MatrixBlocks[mbId].RdrPass[pFace->MaterialId].PBlock;
uint index = ib.getNumIndexes();
ib.setNumIndexes (index+3);
CIndexBufferReadWrite iba;
ib.lock (iba);
iba.setTri(index, pFace->Corner[0].VBId, pFace->Corner[1].VBId, pFace->Corner[2].VBId);
}
/// 5. Remove empty RdrPasses.
//============================
for(mb= 0;mb<_MatrixBlocks.size();mb++)
{
// NB: slow process (erase from a vector). Doens't matter since made at build.
vector<CRdrPass>::iterator itPass;
for( itPass=_MatrixBlocks[mb].RdrPass.begin(); itPass!=_MatrixBlocks[mb].RdrPass.end(); )
{
// If this pass is empty, remove it.
if( itPass->PBlock.getNumIndexes()==0 )
itPass= _MatrixBlocks[mb].RdrPass.erase(itPass);
else
itPass++;
}
}
/// 6. Misc.
//============================
// BShapes
this->_MeshMorpher->BlendShapes = m.BlendShapes;
// sort triangles for better cache use.
optimizeTriangleOrder();
// SmartPtr Copy VertexProgram effect.
this->_MeshVertexProgram= m.MeshVertexProgram;
/// 7. Compact bones id and build bones name array.
//=================================================
// If skinned
if(_Skinned)
{
// Reserve some space
_BonesName.reserve (m.BonesNames.size ());
// Current local bone
uint currentBone = 0;
// For each matrix block
uint matrixBlock;
for (matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++)
{
// Ref on the matrix block
CMatrixBlock &mb = _MatrixBlocks[matrixBlock];
// Remap the skeleton index in model index
std::map<uint, uint> remap;
// For each matrix
uint matrix;
for (matrix=0; matrix<mb.NumMatrix; matrix++)
{
// Get bone id in the skeleton
std::map<uint, uint>::iterator ite = remap.find (mb.MatrixId[matrix]);
// Not found
if (ite == remap.end())
{
// Insert it
remap.insert (std::map<uint, uint>::value_type (mb.MatrixId[matrix], currentBone));
// Check the matrix id
nlassert (mb.MatrixId[matrix] < m.BonesNames.size());
// Set the bone name
_BonesName.push_back (m.BonesNames[mb.MatrixId[matrix]]);
// Set the id in local
mb.MatrixId[matrix] = currentBone++;
}
else
{
// Set the id in local
mb.MatrixId[matrix] = ite->second;
}
}
}
// Bone id in local
_BoneIdComputed = false;
_BoneIdExtended = false;
}
// Set the vertex buffer preferred memory
bool avoidVBHard= _Skinned || ( _MeshMorpher && _MeshMorpher->BlendShapes.size()>0 );
_VBuffer.setPreferredMemory (avoidVBHard?CVertexBuffer::RAMPreferred:CVertexBuffer::StaticPreferred, false);
// End!!
// Some runtime not serialized compilation
compileRunTime();
}
// ***************************************************************************
void CMeshGeom::setBlendShapes(std::vector<CBlendShape>&bs)
{
_MeshMorpher->BlendShapes = bs;
// must update some RunTime parameters
compileRunTime();
}
// ***************************************************************************
void CMeshGeom::applyMaterialRemap(const std::vector<sint> &remap)
{
for(uint mb=0;mb<getNbMatrixBlock();mb++)
{
for(uint rp=0;rp<getNbRdrPass(mb);rp++)
{
// remap
uint32 &matId= _MatrixBlocks[mb].RdrPass[rp].MaterialId;
nlassert(remap[matId]>=0);
matId= remap[matId];
}
}
}
// ***************************************************************************
void CMeshGeom::initInstance(CMeshBaseInstance *mbi)
{
// init the instance with _MeshVertexProgram infos
if(_MeshVertexProgram)
_MeshVertexProgram->initInstance(mbi);
}
// ***************************************************************************
bool CMeshGeom::clip(const std::vector<CPlane> &pyramid, const CMatrix &worldMatrix)
{
// 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 CMeshGeom::render(IDriver *drv, CTransformShape *trans, float polygonCount, uint32 rdrFlags, float globalAlpha)
{
nlassert(drv);
// get the mesh instance.
CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans);
// get a ptr on scene
CScene *ownerScene= mi->getOwnerScene();
// get a ptr on renderTrav
CRenderTrav *renderTrav= &ownerScene->getRenderTrav();
// Soft vb if not supported by the driver
if (drv->slowUnlockVertexBufferHard())
_VBuffer.setPreferredMemory (CVertexBuffer::RAMPreferred, false);
// get the skeleton model to which I am binded (else NULL).
CSkeletonModel *skeleton;
skeleton= mi->getSkeletonModel();
// The mesh must not be skinned for render()
nlassert(!(_Skinned && mi->isSkinned() && skeleton));
bool bMorphApplied = _MeshMorpher->BlendShapes.size() > 0;
bool useTangentSpace = _MeshVertexProgram && _MeshVertexProgram->needTangentSpace();
// Profiling
//===========
H_AUTO( NL3D_MeshGeom_RenderNormal );
// Morphing
// ========
if (bMorphApplied)
{
// If _Skinned (NB: the skin is not applied) and if lod.OriginalSkinRestored, then restoreOriginalSkinPart is
// not called but mush morpher write changed vertices into VBHard so its ok. The unchanged vertices
// are written in the preceding call to restoreOriginalSkinPart.
if (_Skinned)
{
_MeshMorpher->initSkinned(&_VBufferOri,
&_VBuffer,
useTangentSpace,
&_OriginalSkinVertices,
&_OriginalSkinNormals,
useTangentSpace ? &_OriginalTGSpace : NULL,
false );
_MeshMorpher->updateSkinned (mi->getBlendShapeFactors());
}
else // Not even skinned so we have to do all the stuff
{
_MeshMorpher->init(&_VBufferOri,
&_VBuffer,
useTangentSpace);
_MeshMorpher->update (mi->getBlendShapeFactors());
}
}
// Skinning
// ========
// else setup instance matrix
drv->setupModelMatrix(trans->getWorldMatrix());
// since instance skin is invalid but mesh is skinned , we must copy vertices/normals from original vertices.
if (_Skinned)
{
// do it for this Lod only, and if cache say it is necessary.
if (!_OriginalSkinRestored)
restoreOriginalSkinVertices();
}
// Setup meshVertexProgram
//===========
// use MeshVertexProgram effect?
bool useMeshVP= _MeshVertexProgram != NULL;
if( useMeshVP )
{
CMatrix invertedObjectMatrix;
invertedObjectMatrix = trans->getWorldMatrix().inverted();
// really ok if success to begin VP
useMeshVP= _MeshVertexProgram->begin(drv, ownerScene, mi, invertedObjectMatrix, renderTrav->CamPos);
if (!useMeshVP && !mi->_VPWindTreeFixed)
{
if (dynamic_cast<CMeshVPWindTree *>(&(*_MeshVertexProgram)))
{
// fix for mesh tree v.p : all material should be lighted
for(uint mb=0;mb<_MatrixBlocks.size();mb++)
{
CMatrixBlock &mBlock= _MatrixBlocks[mb];
for(uint i=0;i<mBlock.RdrPass.size();i++)
{
CMaterial &mat=mi->Materials[mBlock.RdrPass[i].MaterialId];
mat.setLighting(true, mat.getEmissive(), mat.getAmbient(), mat.getDiffuse(), mat.getSpecular());
}
}
}
mi->_VPWindTreeFixed = true;
}
}
// Render the mesh.
//===========
// active VB.
drv->activeVertexBuffer(_VBuffer);
// Global alpha used ?
uint32 globalAlphaUsed= rdrFlags & IMeshGeom::RenderGlobalAlpha;
uint8 globalAlphaInt=(uint8)NLMISC::OptFastFloor(globalAlpha*255);
// For all _MatrixBlocks
for(uint mb=0;mb<_MatrixBlocks.size();mb++)
{
CMatrixBlock &mBlock= _MatrixBlocks[mb];
if(mBlock.RdrPass.size()==0)
continue;
// Global alpha ?
if (globalAlphaUsed)
{
bool gaDisableZWrite= (rdrFlags & IMeshGeom::RenderGADisableZWrite)?true:false;
// Render all pass.
for (uint i=0;i<mBlock.RdrPass.size();i++)
{
CRdrPass &rdrPass= mBlock.RdrPass[i];
// Render with the Materials of the MeshInstance.
if ( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) ||
( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) )
{
// CMaterial Ref
CMaterial &material=mi->Materials[rdrPass.MaterialId];
// Use a MeshBlender to modify material and driver.
CMeshBlender blender;
blender.prepareRenderForGlobalAlpha(material, drv, globalAlpha, globalAlphaInt, gaDisableZWrite);
// Setup VP material
if (useMeshVP)
{
_MeshVertexProgram->setupForMaterial(material, drv, ownerScene, &_VBuffer);
}
// Render
drv->activeIndexBuffer(rdrPass.PBlock);
drv->renderTriangles(material, 0, rdrPass.PBlock.getNumIndexes()/3);
// Resetup material/driver
blender.restoreRender(material, drv, gaDisableZWrite);
}
}
}
else
{
// Render all pass.
for(uint i=0;i<mBlock.RdrPass.size();i++)
{
CRdrPass &rdrPass= mBlock.RdrPass[i];
// Render with the Materials of the MeshInstance.
if( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) ||
( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) )
{
// CMaterial Ref
CMaterial &material=mi->Materials[rdrPass.MaterialId];
// Setup VP material
if (useMeshVP)
{
_MeshVertexProgram->setupForMaterial(material, drv, ownerScene, &_VBuffer);
}
// render primitives
drv->activeIndexBuffer(rdrPass.PBlock);
drv->renderTriangles(material, 0, rdrPass.PBlock.getNumIndexes()/3);
}
}
}
}
// End VertexProgram effect
if(useMeshVP)
{
// Apply it.
_MeshVertexProgram->end(drv);
}
}
// ***************************************************************************
void CMeshGeom::renderSkin(CTransformShape *trans, float alphaMRM)
{
// get the mesh instance.
CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans);
// get a ptr on scene
CScene *ownerScene= mi->getOwnerScene();
// get a ptr on renderTrav
CRenderTrav *renderTrav= &ownerScene->getRenderTrav();
// get a ptr on the driver
IDriver *drv= renderTrav->getDriver();
nlassert(drv);
// get the skeleton model to which I am binded (else NULL).
CSkeletonModel *skeleton;
skeleton= mi->getSkeletonModel();
// must be skinned for renderSkin()
nlassert(_Skinned && mi->isSkinned() && skeleton);
bool bMorphApplied = _MeshMorpher->BlendShapes.size() > 0;
bool useTangentSpace = _MeshVertexProgram && _MeshVertexProgram->needTangentSpace();
// Profiling
//===========
H_AUTO( NL3D_MeshGeom_RenderSkinned );
// Morphing
// ========
if (bMorphApplied)
{
// Since Skinned we must update original skin vertices and normals because skinning use it
_MeshMorpher->initSkinned(&_VBufferOri,
&_VBuffer,
useTangentSpace,
&_OriginalSkinVertices,
&_OriginalSkinNormals,
useTangentSpace ? &_OriginalTGSpace : NULL,
true );
_MeshMorpher->updateSkinned (mi->getBlendShapeFactors());
}
// Skinning
// ========
// NB: the skeleton matrix has already been setuped by CSkeletonModel
// NB: the normalize flag has already been setuped by CSkeletonModel
// apply the skinning: _VBuffer is modified.
applySkin(skeleton);
// Setup meshVertexProgram
//===========
// use MeshVertexProgram effect?
bool useMeshVP= _MeshVertexProgram != NULL;
if( useMeshVP )
{
CMatrix invertedObjectMatrix;
invertedObjectMatrix = skeleton->getWorldMatrix().inverted();
// really ok if success to begin VP
useMeshVP= _MeshVertexProgram->begin(drv, ownerScene, mi, invertedObjectMatrix, renderTrav->CamPos);
}
// Render the mesh.
//===========
// active VB.
drv->activeVertexBuffer(_VBuffer);
// For all _MatrixBlocks
for(uint mb=0;mb<_MatrixBlocks.size();mb++)
{
CMatrixBlock &mBlock= _MatrixBlocks[mb];
if(mBlock.RdrPass.size()==0)
continue;
// Render all pass.
for(uint i=0;i<mBlock.RdrPass.size();i++)
{
CRdrPass &rdrPass= mBlock.RdrPass[i];
// CMaterial Ref
CMaterial &material=mi->Materials[rdrPass.MaterialId];
// Setup VP material
if (useMeshVP)
{
_MeshVertexProgram->setupForMaterial(material, drv, ownerScene, &_VBuffer);
}
// render primitives
drv->activeIndexBuffer(rdrPass.PBlock);
drv->renderTriangles(material, 0, rdrPass.PBlock.getNumIndexes()/3);
}
}
// End VertexProgram effect
if(useMeshVP)
{
// Apply it.
_MeshVertexProgram->end(drv);
}
}
// ***************************************************************************
void CMeshGeom::renderSimpleWithMaterial(IDriver *drv, const CMatrix &worldMatrix, CMaterial &mat)
{
H_AUTO( NL3D_MeshGeom_RenderSimpleWithMaterial );
nlassert(drv);
// setup matrix
drv->setupModelMatrix(worldMatrix);
// Active simple VB.
drv->activeVertexBuffer(_VBuffer);
// For all _MatrixBlocks
for(uint mb=0;mb<_MatrixBlocks.size();mb++)
{
CMatrixBlock &mBlock= _MatrixBlocks[mb];
if(mBlock.RdrPass.size()==0)
continue;
// Render all pass.
for(uint i=0;i<mBlock.RdrPass.size();i++)
{
CRdrPass &rdrPass= mBlock.RdrPass[i];
// render primitives
drv->activeIndexBuffer(rdrPass.PBlock);
drv->renderTriangles(mat, 0, rdrPass.PBlock.getNumIndexes()/3);
}
}
}
// ***************************************************************************
void CMeshGeom::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
/*
Version 5:
- Preferred memory.
Version 4:
- BonesName.
Version 3:
- MeshVertexProgram.
Version 2:
- precompute of triangle order. (nothing more to load).
Version 1:
- added blend shapes
Version 0:
- separate serialisation CMesh / CMeshGeom.
*/
sint ver = f.serialVersion (4);
// must have good original Skinned Vertex before writing.
if( !f.isReading() && _Skinned && !_OriginalSkinRestored )
{
restoreOriginalSkinVertices();
}
// Version 4+: Array of bone name
if (ver >= 4)
{
f.serialCont (_BonesName);
}
if (f.isReading())
{
// Version3-: Bones index are in skeleton model id list
_BoneIdComputed = (ver < 4);
// In all case, must recompute usage of parents.
_BoneIdExtended= false;
}
else
{
// Warning, if you have skinned this shape, you can't write it anymore because skinning id have been changed!
nlassert (_BoneIdComputed==false);
}
// Version3+: MeshVertexProgram.
if (ver >= 3)
{
IMeshVertexProgram *mvp= NULL;
if(f.isReading())
{
f.serialPolyPtr(mvp);
_MeshVertexProgram= mvp;
}
else
{
mvp= _MeshVertexProgram;
f.serialPolyPtr(mvp);
}
}
else if(f.isReading())
{
// release vp
_MeshVertexProgram= NULL;
}
// TestYoyo
//_MeshVertexProgram= NULL;
// Version1+: _MeshMorpher.
if (ver >= 1)
f.serial (*_MeshMorpher);
// serial geometry.
f.serial (_VBuffer);
f.serialCont (_MatrixBlocks);
f.serial (_BBox);
f.serial (_Skinned);
// If _VertexBuffer changed, flag the VertexBufferHard.
if(f.isReading())
{
// if >= version 2, reorder of triangles is precomputed, else compute it now.
if(ver < 2 )
{
optimizeTriangleOrder();
}
}
// Skinning: If Version < 4, _BonesName are not present, must compute _BonesId from localId
// Else it is computed at first computeBonesId().
if(ver < 4)
buildBoneUsageVer3();
// TestYoyo
//_MeshVertexProgram= NULL;
/*{
uint numTris= 0;
for(uint i=0;i<_MatrixBlocks.size();i++)
{
for(uint j=0;j<_MatrixBlocks[i].RdrPass.size();j++)
numTris+= _MatrixBlocks[i].RdrPass[j].PBlock.getNumTri();
}
nlinfo("YOYO: %d Vertices. %d Triangles.", _VBuffer.getNumVertices(), numTris);
}*/
// Some runtime not serialized compilation
if(f.isReading())
compileRunTime();
}
// ***************************************************************************
void CMeshGeom::compileRunTime()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
// if skinned, prepare skinning
if(_Skinned)
{
// bkup vertices
bkupOriginalSkinVertices();
// build the shadow skin
buildShadowSkin();
}
// Do precise clipping for big object??
_PreciseClipping= _BBox.getRadius() >= NL3D_MESH_PRECISE_CLIP_THRESHOLD;
// Support MeshBlockRendering only if not skinned/meshMorphed.
bool supportMeshBlockRendering= !_Skinned && _MeshMorpher->BlendShapes.size()==0;
// true only if one matrix block, and at least one rdrPass.
supportMeshBlockRendering= supportMeshBlockRendering && _MatrixBlocks.size()==1 && _MatrixBlocks[0].RdrPass.size()>0;
if (supportMeshBlockRendering && _MeshVertexProgram)
{
supportMeshBlockRendering = supportMeshBlockRendering && _MeshVertexProgram->supportMeshBlockRendering();
}
// TestYoyo
//supportMeshBlockRendering= false;
// support MeshVertexProgram, but no material sorting...
bool supportMBRPerMaterial= supportMeshBlockRendering && _MeshVertexProgram==NULL;
// setup flags
_SupportMBRFlags= 0;
if(supportMeshBlockRendering)
_SupportMBRFlags|= MBROk;
if(supportMBRPerMaterial)
_SupportMBRFlags|= MBRSortPerMaterial;
bool avoidVBHard= _Skinned || ( _MeshMorpher && _MeshMorpher->BlendShapes.size()>0 );
_VBuffer.setPreferredMemory (avoidVBHard?CVertexBuffer::RAMPreferred:CVertexBuffer::StaticPreferred, false);
}
// ***************************************************************************
bool CMeshGeom::retrieveVertices(std::vector<NLMISC::CVector> &vertices) const
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
uint i;
// if resident, fails!!! cannot read!
const CVertexBuffer &vb= getVertexBuffer();
if(vb.isResident())
return false;
vertices.clear();
vertices.resize(vb.getNumVertices());
{
CVertexBufferRead vba;
vb.lock (vba);
const uint8 *pVert= (const uint8*)vba.getVertexCoordPointer(0);
uint vSize= vb.getVertexSize();
for(i=0;i<vertices.size();i++)
{
vertices[i]= *(const CVector*)pVert;
pVert+= vSize;
}
}
return true;
}
// ***************************************************************************
bool CMeshGeom::retrieveTriangles(std::vector<uint32> &indices) const
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
uint i;
indices.clear();
// count numTris
uint numTris= 0;
for(i=0;i<getNbMatrixBlock();i++)
{
for(uint rp=0;rp<getNbRdrPass(i);rp++)
{
// if resident, fails!!! cannot read!
const CIndexBuffer &pb= getRdrPassPrimitiveBlock(i, rp);
if(pb.isResident())
return false;
numTris+= getRdrPassPrimitiveBlock(i, rp).getNumIndexes()/3;
}
}
indices.resize(numTris*3);
// build indices
uint triIdx= 0;
for(i=0;i<getNbMatrixBlock();i++)
{
for(uint rp=0;rp<getNbRdrPass(i);rp++)
{
const CIndexBuffer &pb= getRdrPassPrimitiveBlock(i, rp);
CIndexBufferRead iba;
pb.lock (iba);
// copy
if (pb.getFormat() == CIndexBuffer::Indices32)
{
memcpy(&indices[triIdx*3], iba.getPtr(), pb.getNumIndexes()*sizeof(uint32));
}
else
{
// std::copy will convert from 16 bits index to 32 bit index
std::copy((uint16 *) iba.getPtr(), ((uint16 *) iba.getPtr()) + pb.getNumIndexes(), &indices[triIdx*3]);
}
// next
triIdx+= pb.getNumIndexes()/3;
}
}
return true;
}
// ***************************************************************************
// ***************************************************************************
// Skinning.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CMeshGeom::buildSkin(CMesh::CMeshBuild &m, std::vector<CFaceTmp> &tmpFaces)
{
sint i,j,k;
TBoneMap remainingBones;
list<uint> remainingFaces;
// 0. normalize SkinWeights: for all weights at 0, copy the matrixId from 0th matrix => no random/bad use of matrix.
//================================
for(i=0;i<(sint)m.SkinWeights.size();i++)
{
CMesh::CSkinWeight &sw= m.SkinWeights[i];
// 0th weight must not be 0.
nlassert(sw.Weights[0]!=0);
// Begin at 1, tests all other weights.
for(j=1;j<NL3D_MESH_SKINNING_MAX_MATRIX;j++)
{
// We don't use this entry??
if(sw.Weights[j]==0)
{
// Setup MatrixId so that this vertex do no use more matrix than it really wants.
sw.MatrixId[j]= sw.MatrixId[0];
}
}
}
// 1. build the list of used/remaining bones, in ascending order. (so we use the depth-first topolgy of hierarchy).
//================================
for(i=0;i<(sint)tmpFaces.size();i++)
{
CFaceTmp &face= tmpFaces[i];
for(j=0;j<3;j++)
{
CMesh::CSkinWeight &sw= m.SkinWeights[face.Corner[j].Vertex];
for(k=0;k<NL3D_MESH_SKINNING_MAX_MATRIX;k++)
{
// insert (if not already here) the used bone in the set.
// and insert his refcount. (NB: ctor() init it to 0 :) ).
remainingBones[sw.MatrixId[k]].RefCount++;
}
}
}
// 2. Create the list of un-inserted faces.
//================================
for(i=0;i<(sint)tmpFaces.size();i++)
{
remainingFaces.push_back(i);
}
// 3. Create as many Blocks as necessary.
//================================
// Which bones a face use (up to 12).
vector<uint> boneUse;
boneUse.reserve(NL3D_MESH_SKINNING_MAX_MATRIX*3);
// While still exist faces.
while(!remainingFaces.empty())
{
// create a new matrix block.
_MatrixBlocks.push_back(CMatrixBlock());
CMatrixBlock &matrixBlock= _MatrixBlocks[_MatrixBlocks.size()-1];
matrixBlock.NumMatrix=0;
// a. reset remainingBones as not inserted in the current matrixBlock.
//============================
ItBoneMap itBone;
for(itBone= remainingBones.begin();itBone!=remainingBones.end();itBone++)
{
itBone->second.Inserted= false;
}
// b. while still exist bones, try to insert faces which use them in matrixBlock.
//============================
while(!remainingBones.empty())
{
// get the first bone from the map. (remind: depth-first order).
uint currentBoneId= remainingBones.begin()->first;
// If no more faces in the remainingFace list use this bone, remove it, and continue.
if(remainingBones.begin()->second.RefCount==0)
{
remainingBones.erase(remainingBones.begin());
continue;
}
// this is a marker, to know if a face insertion will occurs.
bool faceAdded= false;
// traverse all faces, trying to insert them in current MatrixBlock processed.
list<uint>::iterator itFace;
for(itFace= remainingFaces.begin(); itFace!=remainingFaces.end();)
{
bool useCurrentBoneId;
uint newBoneAdded;
// i/ Get info on current face.
//-----------------------------
// build which bones this face use.
tmpFaces[*itFace].buildBoneUse(boneUse, m.SkinWeights);
// test if this face use the currentBoneId.
useCurrentBoneId= false;
for(i=0;i<(sint)boneUse.size();i++)
{
// if this face use the currentBoneId
if(boneUse[i]==currentBoneId)
{
useCurrentBoneId= true;
break;
}
}
// compute how many bones that are not in the current matrixblock this face use.
newBoneAdded=0;
for(i=0;i<(sint)boneUse.size();i++)
{
// if this bone is not inserted in the current matrix block, inform it.
if(!remainingBones[boneUse[i]].Inserted)
newBoneAdded++;
}
// ii/ insert/reject face.
//------------------------
// If this face do not add any more bone, we can insert it into the current matrixblock.
// If it use the currentBoneId, and do not explode max count, we allow insert it too in the current matrixblock.
if( newBoneAdded==0 ||
(useCurrentBoneId && newBoneAdded+matrixBlock.NumMatrix < IDriver::MaxModelMatrix) )
{
// Insert this face in the current matrix block
CFaceTmp &face= tmpFaces[*itFace];
// for all vertices of this face.
for(j=0;j<3;j++)
{
CMesh::CSkinWeight &sw= m.SkinWeights[face.Corner[j].Vertex];
// for each corner weight (4)
for(k=0;k<NL3D_MESH_SKINNING_MAX_MATRIX;k++)
{
// get the global boneId this corner weight use.
uint boneId= sw.MatrixId[k];
// get the CBoneTmp this corner weight use.
CBoneTmp &bone= remainingBones[boneId];
// decRef the bone .
bone.RefCount--;
// Is this bone already inserted in the MatrixBlock ?
if( !bone.Inserted )
{
// No, insert it.
bone.Inserted= true;
// link it to the MatrixId in the current matrixBlock.
bone.MatrixIdInMB= matrixBlock.NumMatrix;
// modify the matrixBlock
matrixBlock.MatrixId[matrixBlock.NumMatrix]= boneId;
// increment the number of matrix in the matrixBlock.
matrixBlock.NumMatrix++;
}
// Copy Weight info for this Corner.
// Set what matrix in the current matrix block this corner use.
face.Corner[j].Palette.MatrixId[k]= bone.MatrixIdInMB;
// Set weight.
face.Corner[j].Weights[k]= sw.Weights[k];
}
}
// to Which matrixblock this face is inserted.
face.MatrixBlockId= (sint)_MatrixBlocks.size()-1;
// remove the face from remain face list.
itFace= remainingFaces.erase(itFace);
// inform the algorithm that a face has been added.
faceAdded= true;
}
else
{
// do not append this face to the current matrix block, skip to the next
itFace++;
}
}
// If no faces have been added during this pass, we are blocked, and either the MatrixBlock may be full,
// or there is no more face. So quit this block and process a new one.
if(!faceAdded)
break;
}
}
// NB: at the end of this loop, remainingBones may not be empty(), but all remainingBones should have RefCount==0.
// 4. Re-order matrix use in MatrixBlocks, for minimum matrix change between MatrixBlocks.
//================================
vector<CMatrixBlockRemap> blockRemaps;
blockRemaps.resize(_MatrixBlocks.size());
// For all MatrixBlocks > first, try to "mirror" bones from previous.
for(i=1;i<(sint)_MatrixBlocks.size();i++)
{
CMatrixBlock &mBlock= _MatrixBlocks[i];
CMatrixBlock &mPrevBlock= _MatrixBlocks[i-1];
CMatrixBlockRemap &remap= blockRemaps[i];
// First bkup the bone ids in remap table.
for(j=0;j<(sint)mBlock.NumMatrix;j++)
{
remap.Remap[j]= mBlock.MatrixId[j];
}
// For all ids of this blocks, try to mirror them.
for(j=0;j<(sint)mBlock.NumMatrix;j++)
{
// get the location of this bone in the prev bone.
sint idLoc= mPrevBlock.getMatrixIdLocation(mBlock.MatrixId[j]);
// If not found, or if bigger than current array, fails (cant be mirrored).
// Or if already mirrored.
if(idLoc==-1 || idLoc>=(sint)mBlock.NumMatrix || idLoc==j)
{
// next id.
j++;
}
else
{
// puts me on my mirrored location. and swap with the current one at this mirrored location.
swap(mBlock.MatrixId[j], mBlock.MatrixId[idLoc]);
// mBlock.MatrixId[j] is now a candidate for mirror.
}
}
// Then build the Remap table, to re-order faces matrixId which use this matrix block.
for(j=0;j<(sint)mBlock.NumMatrix;j++)
{
// get the boneid which was at this position j before.
uint boneId= remap.Remap[j];
// search his new position, and store the result in the remap table.
remap.Remap[j]= mBlock.getMatrixIdLocation(boneId);
}
// NB: this matrixBlock is re-ordered. next matrixBlock use this state.
}
// For all faces/corners/weights, remap MatrixIds.
for(i=0;i<(sint)tmpFaces.size();i++)
{
CFaceTmp &face= tmpFaces[i];
// do it but for matrixblock0.
if(face.MatrixBlockId!=0)
{
CMatrixBlockRemap &remap= blockRemaps[face.MatrixBlockId];
// For all corners.
for(j=0;j<3;j++)
{
for(k=0;k<NL3D_MESH_SKINNING_MAX_MATRIX;k++)
{
uint oldId= face.Corner[j].Palette.MatrixId[k];
face.Corner[j].Palette.MatrixId[k]= (uint8)remap.Remap[oldId];
}
}
}
}
}
// ***************************************************************************
void CMeshGeom::CFaceTmp::buildBoneUse(vector<uint> &boneUse, vector<CMesh::CSkinWeight> &skinWeights)
{
boneUse.clear();
// For the 3 corners of the face.
for(sint i=0;i<3;i++)
{
// get the CSkinWeight of this vertex.
CMesh::CSkinWeight &sw= skinWeights[Corner[i].Vertex];
// For all skin weights of this vertex,
for(sint j=0;j<NL3D_MESH_SKINNING_MAX_MATRIX;j++)
{
uint boneId= sw.MatrixId[j];
// insert (if not in the array) this bone.
if( find(boneUse.begin(), boneUse.end(), boneId)==boneUse.end() )
boneUse.push_back(boneId);
}
}
}
// ***************************************************************************
sint CMeshGeom::CMatrixBlock::getMatrixIdLocation(uint32 boneId) const
{
for(uint i=0;i<NumMatrix;i++)
{
if(MatrixId[i]==boneId)
return i;
}
// not found.
return -1;
}
// ***************************************************************************
float CMeshGeom::getNumTriangles (float distance)
{
// Sum of triangles
uint32 triCount=0;
// For each matrix block
uint mbCount=(uint)_MatrixBlocks.size();
for (uint mb=0; mb<mbCount; mb++)
{
CMatrixBlock &block=_MatrixBlocks[mb];
// Count of primitive block
uint pCount=(uint)block.RdrPass.size();
for (uint pb=0; pb<pCount; pb++)
{
// Ref on the primitive block
CRdrPass &pass=block.RdrPass[pb];
// Sum tri
triCount+=pass.PBlock.getNumIndexes ()/3;
}
}
return (float)triCount;
}
// ***************************************************************************
void CMeshGeom::computeBonesId (CSkeletonModel *skeleton)
{
// Already computed ?
if (!_BoneIdComputed)
{
// Get a pointer on the skeleton
nlassert (skeleton);
if (skeleton)
{
// **** For each bones, compute remap
std::vector<uint> remap;
skeleton->remapSkinBones(_BonesName, _BonesId, remap);
// **** Remap matrix blocks
for (uint matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++)
{
// Ref on the matrix block
CMatrixBlock &mb = _MatrixBlocks[matrixBlock];
// For each matrix
uint matrix;
for (matrix=0; matrix<mb.NumMatrix; matrix++)
{
// Get bone id in the skeleton
nlassert (mb.MatrixId[matrix]<remap.size());
mb.MatrixId[matrix] = remap[mb.MatrixId[matrix]];
}
}
// **** Remap ShadowSkin, and compute Bone Sphere
// Prepare Sphere compute
static std::vector<CAABBox> boneBBoxes;
static std::vector<bool> boneBBEmpty;
boneBBoxes.clear();
boneBBEmpty.clear();
boneBBoxes.resize(_BonesId.size());
boneBBEmpty.resize(_BonesId.size(), true);
// For simplicity, use the shadow skin info only, to compute bone sphere
for(uint vert=0;vert<_ShadowSkin.Vertices.size();vert++)
{
CShadowVertex &v= _ShadowSkin.Vertices[vert];
// Check id
uint srcId= v.MatrixId;
nlassert ( srcId < remap.size());
// remap
v.MatrixId= 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 * v.Vertex;
// extend the bone bbox.
if(boneBBEmpty[srcId])
{
boneBBoxes[srcId].setCenter(p);
boneBBEmpty[srcId]= false;
}
else
{
boneBBoxes[srcId].extend(p);
}
}
}
// Compile spheres
_BonesSphere.resize(_BonesId.size());
for(uint 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();
}
}
// 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 CMeshGeom::buildBoneUsageVer3 ()
{
if(_Skinned)
{
// parse all matrixBlocks, couting MaxBoneId used.
uint32 maxBoneId= 0;
// For each matrix block
uint matrixBlock;
for (matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++)
{
CMatrixBlock &mb = _MatrixBlocks[matrixBlock];
// For each matrix
for (uint matrix=0; matrix<mb.NumMatrix; matrix++)
{
maxBoneId= max(mb.MatrixId[matrix], maxBoneId);
}
}
// alloc an array of maxBoneId+1, reset to 0.
std::vector<uint8> boneUsage;
boneUsage.resize(maxBoneId+1, 0);
// reparse all matrixBlocks, counting usage for each bone.
for (matrixBlock=0; matrixBlock<_MatrixBlocks.size(); matrixBlock++)
{
CMatrixBlock &mb = _MatrixBlocks[matrixBlock];
// For each matrix
for (uint matrix=0; matrix<mb.NumMatrix; matrix++)
{
// mark this bone as used.
boneUsage[mb.MatrixId[matrix]]= 1;
}
}
// For each bone used
_BonesId.clear();
for(uint i=0; i<boneUsage.size();i++)
{
// if the bone is used by the mesh, add it to BoneId.
if(boneUsage[i])
_BonesId.push_back(i);
}
// Must also compute _BonesSphere
// Cannot do it easily, deprecated data format => suppose radius 0 sphere
CBSphere sphere(CVector::Null, 0.f);
_BonesSphere.clear();
_BonesSphere.resize(_BonesId.size(), sphere);
}
}
// ***************************************************************************
void CMeshGeom::updateSkeletonUsage(CSkeletonModel *sm, bool increment)
{
// For all Bones used by this mesh.
for(uint i=0; i<_BonesIdExt.size();i++)
{
uint boneId= _BonesIdExt[i];
// Some explicit Error.
if(boneId>=sm->Bones.size())
nlerror(" Skin is incompatible with Skeleton: tries to use bone %d", boneId);
// increment or decrement not Forced, because CMeshGeom use getActiveBoneSkinMatrix().
if(increment)
sm->incBoneUsage(boneId, CSkeletonModel::UsageNormal);
else
sm->decBoneUsage(boneId, CSkeletonModel::UsageNormal);
}
}
// ***************************************************************************
void CMeshGeom::bkupOriginalSkinVertices()
{
nlassert(_Skinned);
// reset
contReset(_OriginalSkinVertices);
contReset(_OriginalSkinNormals);
contReset(_OriginalTGSpace);
// get num of vertices
uint numVertices= _VBuffer.getNumVertices();
CVertexBufferRead vba;
_VBuffer.lock (vba);
// Copy VBuffer content into Original vertices normals.
if(_VBuffer.getVertexFormat() & CVertexBuffer::PositionFlag)
{
// copy vertices from VBuffer. (NB: useless geomorphed vertices are still copied, but doesn't matter).
_OriginalSkinVertices.resize(numVertices);
for(uint i=0; i<numVertices;i++)
{
_OriginalSkinVertices[i]= *vba.getVertexCoordPointer(i);
}
}
if(_VBuffer.getVertexFormat() & CVertexBuffer::NormalFlag)
{
// copy normals from VBuffer. (NB: useless geomorphed normals are still copied, but doesn't matter).
_OriginalSkinNormals.resize(numVertices);
for(uint i=0; i<numVertices;i++)
{
_OriginalSkinNormals[i]= *vba.getNormalCoordPointer(i);
}
}
// is there tangent space added ?
if (_MeshVertexProgram && _MeshVertexProgram->needTangentSpace())
{
// yes, backup it
nlassert(_VBuffer.getNumTexCoordUsed() > 0);
uint tgSpaceStage = _VBuffer.getNumTexCoordUsed() - 1;
_OriginalTGSpace.resize(numVertices);
for(uint i=0; i<numVertices;i++)
{
_OriginalTGSpace[i]= *(CVector*)vba.getTexCoordPointer(i, tgSpaceStage);
}
}
}
// ***************************************************************************
void CMeshGeom::restoreOriginalSkinVertices()
{
nlassert(_Skinned);
// get num of vertices
uint numVertices= _VBuffer.getNumVertices();
CVertexBufferReadWrite vba;
_VBuffer.lock (vba);
// Copy VBuffer content into Original vertices normals.
if(_VBuffer.getVertexFormat() & CVertexBuffer::PositionFlag)
{
// copy vertices from VBuffer. (NB: useless geomorphed vertices are still copied, but doesn't matter).
for(uint i=0; i<numVertices;i++)
{
*vba.getVertexCoordPointer(i)= _OriginalSkinVertices[i];
}
}
if(_VBuffer.getVertexFormat() & CVertexBuffer::NormalFlag)
{
// copy normals from VBuffer. (NB: useless geomorphed normals are still copied, but doesn't matter).
for(uint i=0; i<numVertices;i++)
{
*vba.getNormalCoordPointer(i)= _OriginalSkinNormals[i];
}
}
if (_MeshVertexProgram && _MeshVertexProgram->needTangentSpace())
{
uint numTexCoords = _VBuffer.getNumTexCoordUsed();
nlassert(numTexCoords >= 2);
nlassert(_OriginalTGSpace.size() == numVertices);
// copy tangent space vectors
for(uint i = 0; i < numVertices; ++i)
{
*(CVector*)vba.getTexCoordPointer(i, numTexCoords - 1)= _OriginalTGSpace[i];
}
}
// cleared
_OriginalSkinRestored= true;
}
// ***************************************************************************
// Flags for software vertex skinning.
#define NL3D_SOFTSKIN_VNEEDCOMPUTE 3
#define NL3D_SOFTSKIN_VMUSTCOMPUTE 1
#define NL3D_SOFTSKIN_VCOMPUTED 0
// 3 means "vertex may need compute".
// 1 means "Primitive say vertex must be computed".
// 0 means "vertex is computed".
// ***************************************************************************
void CMeshGeom::applySkin(CSkeletonModel *skeleton)
{
// init.
//===================
if(_OriginalSkinVertices.empty())
return;
// Use correct skinning
TSkinType skinType;
if( _OriginalSkinNormals.empty() )
skinType= SkinPosOnly;
else if( _OriginalTGSpace.empty() )
skinType= SkinWithNormal;
else
skinType= SkinWithTgSpace;
// Get VB src/dst info/ptrs.
uint numVertices= (uint)_OriginalSkinVertices.size();
uint dstStride= _VBuffer.getVertexSize();
// Get dst TgSpace.
uint tgSpaceStage = 0;
if( skinType>= SkinWithTgSpace)
{
nlassert(_VBuffer.getNumTexCoordUsed() > 0);
tgSpaceStage= _VBuffer.getNumTexCoordUsed() - 1;
}
// Mark all vertices flag to not computed.
static vector<uint8> skinFlags;
skinFlags.resize(numVertices);
// reset all flags
memset(&skinFlags[0], NL3D_SOFTSKIN_VNEEDCOMPUTE, numVertices );
CVertexBufferRead vba;
_VBuffer.lock (vba);
// For all MatrixBlocks
//===================
for(uint mb= 0; mb<_MatrixBlocks.size();mb++)
{
// compute matrixes for this block.
static CMatrix3x4 matrixes[IDriver::MaxModelMatrix];
computeSkinMatrixes(skeleton, matrixes, mb==0?NULL:&_MatrixBlocks[mb-1], _MatrixBlocks[mb]);
// check what vertex to skin for this PB.
flagSkinVerticesForMatrixBlock(&skinFlags[0], _MatrixBlocks[mb]);
// Get VB src/dst ptrs.
uint8 *pFlag= &skinFlags[0];
CVector *srcVector= &_OriginalSkinVertices[0];
uint8 *srcPal= (uint8*)vba.getPaletteSkinPointer(0);
uint8 *srcWgt= (uint8*)vba.getWeightPointer(0);
uint8 *dstVector= (uint8*)vba.getVertexCoordPointer(0);
// Normal.
CVector *srcNormal= NULL;
uint8 *dstNormal= NULL;
if(skinType>=SkinWithNormal)
{
srcNormal= &_OriginalSkinNormals[0];
dstNormal= (uint8*)vba.getNormalCoordPointer(0);
}
// TgSpace.
CVector *srcTgSpace= NULL;
uint8 *dstTgSpace= NULL;
if(skinType>=SkinWithTgSpace)
{
srcTgSpace= &_OriginalTGSpace[0];
dstTgSpace= (uint8*)vba.getTexCoordPointer(0, tgSpaceStage);
}
// For all vertices that need to be computed.
uint size= numVertices;
for(;size>0;size--)
{
// If we must compute this vertex.
if(*pFlag==NL3D_SOFTSKIN_VMUSTCOMPUTE)
{
// Flag this vertex as computed.
*pFlag=NL3D_SOFTSKIN_VCOMPUTED;
CPaletteSkin *psPal= (CPaletteSkin*)srcPal;
// checks indices.
nlassert(psPal->MatrixId[0]<IDriver::MaxModelMatrix);
nlassert(psPal->MatrixId[1]<IDriver::MaxModelMatrix);
nlassert(psPal->MatrixId[2]<IDriver::MaxModelMatrix);
nlassert(psPal->MatrixId[3]<IDriver::MaxModelMatrix);
// compute vertex part.
computeSoftwarePointSkinning(matrixes, srcVector, psPal, (float*)srcWgt, (CVector*)dstVector);
// compute normal part.
if(skinType>=SkinWithNormal)
computeSoftwareVectorSkinning(matrixes, srcNormal, psPal, (float*)srcWgt, (CVector*)dstNormal);
// compute tg part.
if(skinType>=SkinWithTgSpace)
computeSoftwareVectorSkinning(matrixes, srcTgSpace, psPal, (float*)srcWgt, (CVector*)dstTgSpace);
}
// inc flags.
pFlag++;
// inc src (all whatever skin type used...)
srcVector++;
srcNormal++;
srcTgSpace++;
// inc paletteSkin and dst (all whatever skin type used...)
srcPal+= dstStride;
srcWgt+= dstStride;
dstVector+= dstStride;
dstNormal+= dstStride;
dstTgSpace+= dstStride;
}
}
// dirt
_OriginalSkinRestored= false;
}
// ***************************************************************************
void CMeshGeom::flagSkinVerticesForMatrixBlock(uint8 *skinFlags, CMatrixBlock &mb)
{
for(uint i=0; i<mb.RdrPass.size(); i++)
{
CIndexBuffer &PB= mb.RdrPass[i].PBlock;
uint nIndex;
// This may be better to flags in 2 pass (first traverse primitives, then test vertices).
// Better sol for BTB..., because number of tests are divided by 6 (for triangles).
// for all prims, indicate which vertex we must compute.
// nothing if not already computed (ie 0), because 0&1==0.
// Lines.
// Tris.
CIndexBufferRead iba;
PB.lock (iba);
nIndex= PB.getNumIndexes();
if (iba.getFormat() == CIndexBuffer::Indices32)
{
uint32 *pIndex= (uint32*)iba.getPtr();
for(;nIndex>0;nIndex--, pIndex++)
skinFlags[*pIndex]&= NL3D_SOFTSKIN_VMUSTCOMPUTE;
}
else
{
uint16 *pIndex= (uint16*)iba.getPtr();
for(;nIndex>0;nIndex--, pIndex++)
skinFlags[*pIndex]&= NL3D_SOFTSKIN_VMUSTCOMPUTE;
}
}
}
// ***************************************************************************
void CMeshGeom::computeSoftwarePointSkinning(CMatrix3x4 *matrixes, CVector *srcVec, CPaletteSkin *srcPal, float *srcWgt, CVector *pDst)
{
CMatrix3x4 *pMat;
// 0th matrix influence.
pMat= matrixes + srcPal->MatrixId[0];
pMat->mulSetPoint(*srcVec, srcWgt[0], *pDst);
// 1th matrix influence.
pMat= matrixes + srcPal->MatrixId[1];
pMat->mulAddPoint(*srcVec, srcWgt[1], *pDst);
// 2th matrix influence.
pMat= matrixes + srcPal->MatrixId[2];
pMat->mulAddPoint(*srcVec, srcWgt[2], *pDst);
// 3th matrix influence.
pMat= matrixes + srcPal->MatrixId[3];
pMat->mulAddPoint(*srcVec, srcWgt[3], *pDst);
}
// ***************************************************************************
void CMeshGeom::computeSoftwareVectorSkinning(CMatrix3x4 *matrixes, CVector *srcVec, CPaletteSkin *srcPal, float *srcWgt, CVector *pDst)
{
CMatrix3x4 *pMat;
// 0th matrix influence.
pMat= matrixes + srcPal->MatrixId[0];
pMat->mulSetVector(*srcVec, srcWgt[0], *pDst);
// 1th matrix influence.
pMat= matrixes + srcPal->MatrixId[1];
pMat->mulAddVector(*srcVec, srcWgt[1], *pDst);
// 2th matrix influence.
pMat= matrixes + srcPal->MatrixId[2];
pMat->mulAddVector(*srcVec, srcWgt[2], *pDst);
// 3th matrix influence.
pMat= matrixes + srcPal->MatrixId[3];
pMat->mulAddVector(*srcVec, srcWgt[3], *pDst);
}
// ***************************************************************************
void CMeshGeom::computeSkinMatrixes(CSkeletonModel *skeleton, CMatrix3x4 *matrixes, CMatrixBlock *prevBlock, CMatrixBlock &mBlock)
{
// For all matrix of this mBlock.
for(uint idMat=0;idMat<mBlock.NumMatrix;idMat++)
{
uint curBoneId= mBlock.MatrixId[idMat];
// If same matrix binded as previous block, no need to bind!!
if(prevBlock && idMat<prevBlock->NumMatrix && prevBlock->MatrixId[idMat]== curBoneId)
continue;
// Else, we must setup the matrix
matrixes[idMat].set(skeleton->getActiveBoneSkinMatrix(curBoneId));
}
}
// ***************************************************************************
void CMeshGeom::profileSceneRender(CRenderTrav *rdrTrav, CTransformShape *trans, float polygonCount, uint32 rdrFlags)
{
// get the mesh instance.
CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans);
// For all _MatrixBlocks
uint triCount= 0;
for(uint mb=0;mb<_MatrixBlocks.size();mb++)
{
CMatrixBlock &mBlock= _MatrixBlocks[mb];
// Profile all pass.
for (uint i=0;i<mBlock.RdrPass.size();i++)
{
CRdrPass &rdrPass= mBlock.RdrPass[i];
// Profile with the Materials of the MeshInstance.
if ( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) ||
( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) )
{
triCount+= rdrPass.PBlock.getNumIndexes()/3;
}
}
}
// Profile
if(triCount)
{
// tri per VBFormat
rdrTrav->Scene->incrementProfileTriVBFormat(rdrTrav->Scene->BenchRes.MeshProfileTriVBFormat,
_VBuffer.getVertexFormat(), triCount);
// VBHard
if(_VBuffer.getPreferredMemory()!=CVertexBuffer::RAMPreferred)
rdrTrav->Scene->BenchRes.NumMeshVBufferHard++;
else
rdrTrav->Scene->BenchRes.NumMeshVBufferStd++;
// rendered in BlockRendering, only if not transparent pass (known it if RenderTransparentMaterial is set)
if(supportMeshBlockRendering() && (rdrFlags & IMeshGeom::RenderTransparentMaterial)==0 )
{
if(isMeshInVBHeap())
{
rdrTrav->Scene->BenchRes.NumMeshRdrBlockWithVBHeap++;
rdrTrav->Scene->BenchRes.NumMeshTriRdrBlockWithVBHeap+= triCount;
}
else
{
rdrTrav->Scene->BenchRes.NumMeshRdrBlock++;
rdrTrav->Scene->BenchRes.NumMeshTriRdrBlock+= triCount;
}
}
else
{
rdrTrav->Scene->BenchRes.NumMeshRdrNormal++;
rdrTrav->Scene->BenchRes.NumMeshTriRdrNormal+= triCount;
}
}
}
// ***************************************************************************
bool CMeshGeom::intersectSkin(CTransformShape *mi, const CMatrix &toRaySpace, float &dist2D, float &distZ, bool computeDist2D)
{
// for Mesh, Use the Shadow Skinning (simple version).
// get skeleton
if(!mi || _OriginalSkinVertices.empty())
return false;
CSkeletonModel *skeleton= mi->getSkeletonModel();
if(!skeleton)
return false;
// Compute skinning with all matrix this Mesh use. (the shadow geometry cannot use other Matrix than the mesh use).
static std::vector<uint32> matInfs;
matInfs.resize(_BonesId.size());
for(uint i=0;i<matInfs.size();i++)
{
// treat any "missing bone" as the root one.
matInfs[i]= max(_BonesId[i], (sint32)0);
}
return _ShadowSkin.getRayIntersection(toRaySpace, *skeleton, matInfs, dist2D, distZ, computeDist2D);
}
// ***************************************************************************
void CMeshGeom::buildShadowSkin()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
// reset
contReset(_ShadowSkin.Vertices);
contReset(_ShadowSkin.Triangles);
nlassert(_Skinned && (_VBuffer.getVertexFormat() & CVertexBuffer::PaletteSkinFlag)
&& (_VBuffer.getVertexFormat() & CVertexBuffer::PositionFlag) );
// *** Copy VBuffer content
{
// get num of vertices
uint numVertices= _VBuffer.getNumVertices();
// lock VB
CVertexBufferRead vba;
_VBuffer.lock (vba);
uint8 *srcPal= (uint8*)vba.getPaletteSkinPointer(0);
uint8 *srcVert= (uint8*)vba.getVertexCoordPointer(0);
uint32 srcVertSize= _VBuffer.getVertexSize();
// copy vertices from VBuffer
_ShadowSkin.Vertices.resize(numVertices);
for(uint i=0; i<numVertices;i++)
{
// Copy Vertex
_ShadowSkin.Vertices[i].Vertex= *((CVector*)srcVert);
// Suppose the 0 matrix inf is the highest (we are at least sure it is not 0)
// And SkinWeight Export show the 0th is the highest one...
_ShadowSkin.Vertices[i].MatrixId= ((CPaletteSkin*)srcPal)->MatrixId[0];
// Next
srcVert+= srcVertSize;
srcPal+= srcVertSize;
}
}
// But _ShadowSkin.Vertices[i].MatrixId is incorrect, since < IDriver::MaxModelMatrix
// *** Count number of triangles, and get start index of each matrix block in the final Tri list
uint numIndices= 0;
uint mb;
// can't be static cause of ThreadSafe
vector<pair<uint32,uint32> > mbIndexRange;
mbIndexRange.resize(_MatrixBlocks.size());
for(mb=0;mb<_MatrixBlocks.size();mb++)
{
// this matrix block start here
mbIndexRange[mb].first= numIndices;
// count tris rendered for this matrix block
const CMatrixBlock &mBlock= _MatrixBlocks[mb];
for(uint rp=0;rp<mBlock.RdrPass.size();rp++)
{
const CRdrPass &rPass= mBlock.RdrPass[rp];
numIndices+= rPass.PBlock.getNumIndexes();
}
// this matrix block end here
mbIndexRange[mb].second= numIndices;
}
// *** Fill Triangles
nlverify(retrieveTriangles(_ShadowSkin.Triangles));
nlassert(numIndices==_ShadowSkin.Triangles.size());
// *** Reindex correctly MatrixId, (ie unpack matrix blocks)
// can't be static cause of ThreadSafe
vector<bool> vertReIndexed;
vertReIndexed.resize(_ShadowSkin.Vertices.size(), false);
// for all matrix blocks
for(mb=0;mb<mbIndexRange.size();mb++)
{
const CMatrixBlock &mBlock= _MatrixBlocks[mb];
uint iStart= mbIndexRange[mb].first;
uint iEnd= mbIndexRange[mb].second;
nlassert(iStart <= iEnd && iEnd<=_ShadowSkin.Triangles.size());
// For all indices in this range
uint32 *pIndex= &_ShadowSkin.Triangles[iStart];
uint nbIndex= iEnd - iStart;
for(;nbIndex>0;--nbIndex, pIndex++)
{
uint index= *pIndex;
// if not already reindexed
if(!vertReIndexed[index])
{
vertReIndexed[index]= true;
// reindex
uint matId= _ShadowSkin.Vertices[index].MatrixId;
nlassert(matId<mBlock.NumMatrix);
_ShadowSkin.Vertices[index].MatrixId= mBlock.MatrixId[matId];
}
}
}
}
// ***************************************************************************
// ***************************************************************************
// Mesh Block Render Interface
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
bool CMeshGeom::supportMeshBlockRendering () const
{
return _SupportMBRFlags!=0;
}
// ***************************************************************************
bool CMeshGeom::sortPerMaterial() const
{
return (_SupportMBRFlags & MBRSortPerMaterial)!=0;
}
// ***************************************************************************
uint CMeshGeom::getNumRdrPassesForMesh() const
{
return (uint)_MatrixBlocks[0].RdrPass.size();
}
// ***************************************************************************
uint CMeshGeom::getNumRdrPassesForInstance(CMeshBaseInstance *inst) const
{
return (uint)_MatrixBlocks[0].RdrPass.size();
}
// ***************************************************************************
void CMeshGeom::beginMesh(CMeshGeomRenderContext &rdrCtx)
{
if(rdrCtx.RenderThroughVBHeap)
{
// Don't setup VB in this case, since use the VBHeap setuped one.
// NB: no VertexProgram test since VBHeap not possible with it...
nlassert( (_SupportMBRFlags & MBRCurrentUseVP)==0 );
}
else
{
// use MeshVertexProgram effect?
if( _MeshVertexProgram != NULL && _MeshVertexProgram->isMBRVpOk(rdrCtx.Driver) )
{
// Ok will use it.
_SupportMBRFlags|= MBRCurrentUseVP;
// Before VB activation
_MeshVertexProgram->beginMBRMesh(rdrCtx.Driver, rdrCtx.Scene );
}
// active VB. SoftwareSkinning: reset flags for skinning.
rdrCtx.Driver->activeVertexBuffer(_VBuffer);
}
}
// ***************************************************************************
void CMeshGeom::activeInstance(CMeshGeomRenderContext &rdrCtx, CMeshBaseInstance *inst, float polygonCount, void *vbDst)
{
// setup instance matrix
rdrCtx.Driver->setupModelMatrix(inst->getWorldMatrix());
// setupLighting.
inst->changeLightSetup(rdrCtx.RenderTrav);
// MeshVertexProgram ?
if( _SupportMBRFlags & MBRCurrentUseVP )
{
CMatrix invertedObjectMatrix;
invertedObjectMatrix = inst->getWorldMatrix().inverted();
_MeshVertexProgram->beginMBRInstance(rdrCtx.Driver, rdrCtx.Scene, inst, invertedObjectMatrix);
}
}
// ***************************************************************************
void CMeshGeom::renderPass(CMeshGeomRenderContext &rdrCtx, CMeshBaseInstance *mi, float polygonCount, uint rdrPassId)
{
CMatrixBlock &mBlock= _MatrixBlocks[0];
CRdrPass &rdrPass= mBlock.RdrPass[rdrPassId];
// Render with the Materials of the MeshInstance, only if not blended.
if( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) ) )
{
CMaterial &material= mi->Materials[rdrPass.MaterialId];
// MeshVertexProgram ?
if( _SupportMBRFlags & MBRCurrentUseVP )
{
rdrCtx.RenderTrav->changeVPLightSetupMaterial(material, false);
}
if(rdrCtx.RenderThroughVBHeap)
{
// render shifted primitives
rdrCtx.Driver->activeIndexBuffer(rdrPass.VBHeapPBlock);
rdrCtx.Driver->renderTriangles(material, 0, rdrPass.VBHeapPBlock.getNumIndexes()/3);
}
else
{
// render primitives
rdrCtx.Driver->activeIndexBuffer(rdrPass.PBlock);
rdrCtx.Driver->renderTriangles(material, 0, rdrPass.PBlock.getNumIndexes()/3);
}
}
}
// ***************************************************************************
void CMeshGeom::endMesh(CMeshGeomRenderContext &rdrCtx)
{
// MeshVertexProgram ?
if( _SupportMBRFlags & MBRCurrentUseVP )
{
// End Mesh
_MeshVertexProgram->endMBRMesh( rdrCtx.Driver );
// and remove Current Flag.
_SupportMBRFlags&= ~MBRCurrentUseVP;
}
}
// ***************************************************************************
bool CMeshGeom::getVBHeapInfo(uint &vertexFormat, uint &numVertices)
{
// CMeshGeom support VBHeap rendering, assuming supportMeshBlockRendering is true.
if( _SupportMBRFlags )
/* Yoyo: If VertexProgram, DON'T SUPPORT!! because VB need to be activated AFTER meshVP activation
NB: still possible with complex code to do it (sort per VP type (with or not)...), but tests in Ryzom
shows that VBHeap is not really important (not so much different shapes...)
*/
if( _MeshVertexProgram==NULL )
{
vertexFormat= _VBuffer.getVertexFormat();
numVertices= _VBuffer.getNumVertices();
return true;
}
return false;
}
// ***************************************************************************
void CMeshGeom::computeMeshVBHeap(void *dst, uint indexStart)
{
// Fill dst with Buffer content.
CVertexBufferRead vba;
_VBuffer.lock (vba);
memcpy(dst, vba.getVertexCoordPointer(), _VBuffer.getNumVertices()*_VBuffer.getVertexSize() );
// NB: only 1 MB is possible ...
nlassert(_MatrixBlocks.size()==1);
CMatrixBlock &mBlock= _MatrixBlocks[0];
// For all rdrPass.
for(uint i=0;i<mBlock.RdrPass.size();i++)
{
// shift the PB
CIndexBuffer &srcPb= mBlock.RdrPass[i].PBlock;
CIndexBuffer &dstPb= mBlock.RdrPass[i].VBHeapPBlock;
uint j;
// Tris.
dstPb.setNumIndexes(srcPb.getNumIndexes());
CIndexBufferRead ibaRead;
srcPb.lock (ibaRead);
CIndexBufferReadWrite ibaWrite;
dstPb.lock (ibaWrite);
// nico : apparently not used, so don't manage 16 bits index here
nlassert(ibaRead.getFormat() == CIndexBuffer::Indices32);
nlassert(ibaWrite.getFormat() == CIndexBuffer::Indices32);
const uint32 *srcTriPtr= (const uint32 *) ibaRead.getPtr();
uint32 *dstTriPtr= (uint32 *) ibaWrite.getPtr();
for(j=0; j<dstPb.getNumIndexes();j++)
{
dstTriPtr[j]= srcTriPtr[j]+indexStart;
}
}
}
// ***************************************************************************
// ***************************************************************************
// CMeshBuild components.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CMesh::CCorner::CCorner()
{
sint i;
Vertex= 0;
Normal= CVector::Null;
for(i=0;i<CVertexBuffer::MaxStage;i++)
{
Uvws[i]= CUVW(0, 0, 0);
}
Color.set(255,255,255,255);
Specular.set(0,0,0,0);
}
// ***************************************************************************
void CMesh::CCorner::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
nlassert(0); // not used
f.serial(Vertex);
f.serial(Normal);
for(int i=0;i<CVertexBuffer::MaxStage;++i) f.serial(Uvws[i]);
f.serial(Color);
f.serial(Specular);
}
// ***************************************************************************
void CMesh::CFace::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
for(int i=0;i<3;++i)
f.serial(Corner[i]);
f.serial(MaterialId);
f.serial(SmoothGroup);
}
// ***************************************************************************
void CMesh::CSkinWeight::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
for(int i=0;i<NL3D_MESH_SKINNING_MAX_MATRIX;++i)
{
f.serial(MatrixId[i]);
f.serial(Weights[i]);
}
}
// ***************************************************************************
/* Serialization is not used.
void CMesh::CMeshBuild::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
sint ver= f.serialVersion(0);
// Serial mesh base (material info).
CMeshBaseBuild::serial(f);
// Serial Geometry.
f.serial( VertexFlags );
f.serialCont( Vertices );
f.serialCont( SkinWeights );
f.serialCont( Faces );
}*/
// ************************************
CMesh::CMeshBuild::CMeshBuild()
{
for (uint k = 0; k < CVertexBuffer::MaxStage; ++k)
{
NumCoords[k] = 2;
UVRouting[k] = k;
}
}
// ***************************************************************************
// ***************************************************************************
// CMesh.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CMesh::CMesh()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
// create the MeshGeom
_MeshGeom= new CMeshGeom;
}
// ***************************************************************************
CMesh::~CMesh()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
// delete the MeshGeom
delete _MeshGeom;
}
// ***************************************************************************
CMesh::CMesh(const CMesh &mesh) : CMeshBase()
{
// create the MeshGeom
_MeshGeom= new CMeshGeom(*mesh._MeshGeom);
}
// ***************************************************************************
CMesh &CMesh::operator=(const CMesh &mesh)
{
// Copy CMeshBase part
(CMeshBase&)*this= (CMeshBase&)mesh;
// copy content of meshGeom.
*_MeshGeom= *mesh._MeshGeom;
return *this;
}
// ***************************************************************************
void CMesh::build (CMeshBase::CMeshBaseBuild &mbase, CMeshBuild &m)
{
/// copy MeshBase info: materials ....
CMeshBase::buildMeshBase (mbase);
// build the geometry.
_MeshGeom->build (m, (uint)mbase.Materials.size());
// compile some stuff
compileRunTime();
}
// ***************************************************************************
void CMesh::optimizeMaterialUsage(std::vector<sint> &remap)
{
// For each material, count usage.
vector<bool> materialUsed;
materialUsed.resize(CMeshBase::_Materials.size(), false);
for(uint mb=0;mb<getNbMatrixBlock();mb++)
{
for(uint rp=0;rp<getNbRdrPass(mb);rp++)
{
uint matId= getRdrPassMaterial(mb, rp);
// flag as used.
materialUsed[matId]= true;
}
}
// Apply it to meshBase
CMeshBase::applyMaterialUsageOptim(materialUsed, remap);
// Apply lut to meshGeom.
_MeshGeom->applyMaterialRemap(remap);
}
// ***************************************************************************
void CMesh::setBlendShapes(std::vector<CBlendShape>&bs)
{
_MeshGeom->setBlendShapes (bs);
}
// ***************************************************************************
void CMesh::build(CMeshBase::CMeshBaseBuild &mbuild, CMeshGeom &meshGeom)
{
/// copy MeshBase info: materials ....
CMeshBase::buildMeshBase(mbuild);
// build the geometry.
*_MeshGeom= meshGeom;
// compile some stuff
compileRunTime();
}
// ***************************************************************************
CTransformShape *CMesh::createInstance(CScene &scene)
{
// Create a CMeshInstance, an instance of a mesh.
//===============================================
CMeshInstance *mi= (CMeshInstance*)scene.createModel(NL3D::MeshInstanceId);
mi->Shape= this;
// instanciate the material part of the Mesh, ie the CMeshBase.
CMeshBase::instanciateMeshBase(mi, &scene);
// do some instance init for MeshGeom
_MeshGeom->initInstance(mi);
// init render Filter
mi->initRenderFilterType();
return mi;
}
// ***************************************************************************
bool CMesh::clip(const std::vector<CPlane> &pyramid, const CMatrix &worldMatrix)
{
return _MeshGeom->clip(pyramid, worldMatrix);
}
// ***************************************************************************
void CMesh::render(IDriver *drv, CTransformShape *trans, bool passOpaque)
{
// 0 or 0xFFFFFFFF
uint32 mask= (0-(uint32)passOpaque);
uint32 rdrFlags;
// select rdrFlags, without ifs.
rdrFlags= mask & (IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderPassOpaque);
rdrFlags|= ~mask & (IMeshGeom::RenderTransparentMaterial);
// render the mesh
_MeshGeom->render(drv, trans, 0, rdrFlags, 1);
}
// ***************************************************************************
void CMesh::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
/*
Version 6:
- cut in serialisation, because of:
- bad ITexture serialisation (with no version....) => must cut. (see CMeshBase serial).
- because of this and to simplify, make a cut too in CMesh serialisation.
NB : all old version code is dropped.
*/
sint ver= f.serialVersion(6);
if(ver<6)
throw NLMISC::EStream(f, "Mesh in Stream is too old (Mesh version < 6)");
// serial Materials infos contained in CMeshBase.
CMeshBase::serialMeshBase(f);
// serial geometry.
_MeshGeom->serial(f);
// if reading, compile some stuff
if(f.isReading())
compileRunTime();
}
// ***************************************************************************
const NLMISC::CAABBoxExt& CMesh::getBoundingBox() const
{
return _MeshGeom->getBoundingBox();
}
// ***************************************************************************
const CVertexBuffer &CMesh::getVertexBuffer() const
{
return _MeshGeom->getVertexBuffer() ;
}
// ***************************************************************************
uint CMesh::getNbMatrixBlock() const
{
return _MeshGeom->getNbMatrixBlock();
}
// ***************************************************************************
uint CMesh::getNbRdrPass(uint matrixBlockIndex) const
{
return _MeshGeom->getNbRdrPass(matrixBlockIndex) ;
}
// ***************************************************************************
const CIndexBuffer &CMesh::getRdrPassPrimitiveBlock(uint matrixBlockIndex, uint renderingPassIndex) const
{
return _MeshGeom->getRdrPassPrimitiveBlock(matrixBlockIndex, renderingPassIndex) ;
}
// ***************************************************************************
uint32 CMesh::getRdrPassMaterial(uint matrixBlockIndex, uint renderingPassIndex) const
{
return _MeshGeom->getRdrPassMaterial(matrixBlockIndex, renderingPassIndex) ;
}
// ***************************************************************************
float CMesh::getNumTriangles (float distance)
{
// A CMesh do not degrad himself, so return 0, to not be taken into account.
return 0;
}
// ***************************************************************************
const CMeshGeom& CMesh::getMeshGeom () const
{
return *_MeshGeom;
}
// ***************************************************************************
void CMesh::computeBonesId (CSkeletonModel *skeleton)
{
nlassert (_MeshGeom);
_MeshGeom->computeBonesId (skeleton);
}
// ***************************************************************************
void CMesh::updateSkeletonUsage(CSkeletonModel *sm, bool increment)
{
nlassert (_MeshGeom);
_MeshGeom->updateSkeletonUsage(sm, increment);
}
// ***************************************************************************
IMeshGeom *CMesh::supportMeshBlockRendering (CTransformShape *trans, float &polygonCount ) const
{
// Ok if meshGeom is ok.
if(_MeshGeom->supportMeshBlockRendering())
{
polygonCount= 0;
return _MeshGeom;
}
else
return NULL;
}
// ***************************************************************************
void CMesh::profileSceneRender(CRenderTrav *rdrTrav, CTransformShape *trans, bool passOpaque)
{
// 0 or 0xFFFFFFFF
uint32 mask= (0-(uint32)passOpaque);
uint32 rdrFlags;
// select rdrFlags, without ifs.
rdrFlags= mask & (IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderPassOpaque);
rdrFlags|= ~mask & (IMeshGeom::RenderTransparentMaterial);
// render the mesh
_MeshGeom->profileSceneRender(rdrTrav, trans, 0, rdrFlags);
}
// ***************************************************************************
void CMesh::compileRunTime()
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
// **** try to build a Visual Collision Mesh
// clear first
if(_VisualCollisionMesh)
{
delete _VisualCollisionMesh;
_VisualCollisionMesh= NULL;
}
// build only if wanted
if( (_CollisionMeshGeneration==AutoCameraCol && !_LightInfos.empty()) ||
_CollisionMeshGeneration==ForceCameraCol )
{
vector<CVector> vertices;
vector<uint32> indices;
if(_MeshGeom->retrieveVertices(vertices) && _MeshGeom->retrieveTriangles(indices))
{
// ok, can build!
_VisualCollisionMesh= new CVisualCollisionMesh;
// if fails to build cause of too many vertices/indices for instance
if( !_VisualCollisionMesh->build(vertices, indices,const_cast<CVertexBuffer&>(_MeshGeom->getVertexBuffer())) )
{
// delete
delete _VisualCollisionMesh;
_VisualCollisionMesh= NULL;
}
}
}
}
// ***************************************************************************
void CMesh::buildSystemGeometry()
{
// clear any
_SystemGeometry.clear();
// don't build a system copy if skinned. In this case, ray intersection is done through CSkeletonModel
// and intersectSkin() scheme
if(_MeshGeom->isSkinned())
return;
// retrieve geometry (if VB/IB not resident)
if( !_MeshGeom->retrieveVertices(_SystemGeometry.Vertices) ||
!_MeshGeom->retrieveTriangles(_SystemGeometry.Triangles))
{
_SystemGeometry.clear();
}
// TestYoyo
/*static uint32 totalMem= 0;
totalMem+= _SystemGeometry.Vertices.size()*sizeof(CVector);
totalMem+= _SystemGeometry.Triangles.size()*sizeof(uint32);
nlinfo("CMesh: TotalMem: %d", totalMem);*/
}
} // NL3D
Reference in a new issue Copy permalink