You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2784 lines
78 KiB
C++
2784 lines
78 KiB
C++
// 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
|
|
|
|
|
|
|