Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/nel/src/3d/mesh_mrm_skinned.cpp

2421 lines
69 KiB
C++
Raw Normal View History

Fixed EOL issues and added .hgeol file.
2012-05-29 13:31:11 +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/misc/bsphere.h"
#include "nel/misc/system_info.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/misc/fast_mem.h"
#include "nel/3d/mesh_mrm_skinned.h"
#include "nel/3d/mrm_builder.h"
#include "nel/3d/mrm_parameters.h"
#include "nel/3d/mesh_mrm_skinned_instance.h"
#include "nel/3d/scene.h"
#include "nel/3d/skeleton_model.h"
#include "nel/3d/stripifier.h"
#include "nel/3d/mesh_blender.h"
#include "nel/3d/render_trav.h"
#include "nel/misc/fast_floor.h"
#include "nel/3d/raw_skinned.h"
#include "nel/3d/shifted_triangle_cache.h"
#include "nel/3d/texture_file.h"
#include "nel/3d/matrix_3x4.h"
using namespace NLMISC;
using namespace std;
namespace NL3D
{
H_AUTO_DECL( NL3D_MeshMRMGeom_RenderShadow )
// ***************************************************************************
// ***************************************************************************
// CMeshMRMSkinnedGeom::CLod
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CMeshMRMSkinnedGeom::CLod::serial(NLMISC::IStream &f)
{
/*
Version 0:
- base vdrsion.
*/
f.serialVersion(0);
uint i;
f.serial(NWedges);
f.serialCont(RdrPass);
f.serialCont(Geomorphs);
f.serialCont(MatrixInfluences);
// Serial array of InfluencedVertices. NB: code written so far for NL3D_MESH_SKINNING_MAX_MATRIX==4 only.
nlassert(NL3D_MESH_SKINNING_MAX_MATRIX==4);
for(i= 0; i<NL3D_MESH_SKINNING_MAX_MATRIX; i++)
{
f.serialCont(InfluencedVertices[i]);
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CLod::optimizeTriangleOrder()
{
CStripifier stripifier;
// for all rdrpass
for(uint rp=0; rp<RdrPass.size(); rp++ )
{
// stripify list of triangles of this pass.
CIndexBuffer block;
getRdrPassPrimitiveBlock(rp, block);
stripifier.optimizeTriangles(block, block);
buildPrimitiveBlock(rp, block);
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CLod::getRdrPassPrimitiveBlock (uint renderPass, CIndexBuffer &block) const
{
const CRdrPass &rd = RdrPass[renderPass];
const uint count = rd.getNumTriangle();
block.setFormat(NL_SKINNED_MESH_MRM_INDEX_FORMAT);
block.setNumIndexes (count*3);
CIndexBufferReadWrite ibaWrite;
block.lock (ibaWrite);
uint i;
for (i=0; i<count; i++)
{
ibaWrite.setTri (i*3, rd.PBlock[i*3+0], rd.PBlock[i*3+1], rd.PBlock[i*3+2]);
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CLod::buildPrimitiveBlock(uint renderPass, const CIndexBuffer &block)
{
CRdrPass &rd = RdrPass[renderPass];
const uint count = block.getNumIndexes()/3;
rd.PBlock.resize (3*count);
uint i;
CIndexBufferRead ibaRead;
block.lock (ibaRead);
if (ibaRead.getFormat() == CIndexBuffer::Indices32)
{
const uint32 *triPtr = (const uint32 *) ibaRead.getPtr ();
for (i=0; i<count; i++)
{
rd.PBlock[i*3+0] = (uint16) (triPtr[3*i+0]);
rd.PBlock[i*3+1] = (uint16) (triPtr[3*i+1]);
rd.PBlock[i*3+2] = (uint16) (triPtr[3*i+2]);
}
}
else
{
const uint16 *triPtr = (const uint16 *) ibaRead.getPtr ();
for (i=0; i<count; i++)
{
rd.PBlock[i*3+0] = (triPtr[3*i+0]);
rd.PBlock[i*3+1] = (triPtr[3*i+1]);
rd.PBlock[i*3+2] = (triPtr[3*i+2]);
}
}
}
// ***************************************************************************
// ***************************************************************************
// CMeshMRMSkinnedGeom.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
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;
}
// ***************************************************************************
CMeshMRMSkinnedGeom::CMeshMRMSkinnedGeom()
{
_BoneIdComputed = false;
_BoneIdExtended = false;
_PreciseClipping= false;
_MeshDataId= 0;
_SupportShadowSkinGrouping= false;
}
// ***************************************************************************
CMeshMRMSkinnedGeom::~CMeshMRMSkinnedGeom()
{
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest)
{
// check input.
if(distanceFinest<0) return;
if(distanceMiddle<=distanceFinest) return;
if(distanceCoarsest<=distanceMiddle) return;
// Change.
_LevelDetail.DistanceFinest= distanceFinest;
_LevelDetail.DistanceMiddle= distanceMiddle;
_LevelDetail.DistanceCoarsest= distanceCoarsest;
// compile
_LevelDetail.compileDistanceSetup();
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::build(CMesh::CMeshBuild &m,
uint numMaxMaterial, const CMRMParameters &params)
{
// Empty geometry?
if(m.Vertices.size()==0 || m.Faces.size()==0)
{
_VBufferFinal.clear();
_Lods.clear();
_BBox.setCenter(CVector::Null);
_BBox.setSize(CVector::Null);
return;
}
nlassert(numMaxMaterial>0);
/// 0. First, make bbox.
//======================
// NB: this is equivalent as building BBox from MRM VBuffer, because CMRMBuilder create new vertices
// which are just interpolation of original vertices.
_BBox= makeBBox(m.Vertices);
/// 1. Launch the MRM build process.
//================================================
CMRMBuilder mrmBuilder;
CMeshBuildMRM meshBuildMRM;
std::vector<CMesh::CMeshBuild*> bsList;
mrmBuilder.compileMRM(m, bsList, params, meshBuildMRM, numMaxMaterial);
nlassert (meshBuildMRM.Skinned);
// Then build the packed vertex buffer
//================================================
_VBufferFinal.build (meshBuildMRM.VBuffer, meshBuildMRM.SkinWeights);
_Lods= meshBuildMRM.Lods;
// Compute degradation control.
//================================================
_LevelDetail.DistanceFinest= meshBuildMRM.DistanceFinest;
_LevelDetail.DistanceMiddle= meshBuildMRM.DistanceMiddle;
_LevelDetail.DistanceCoarsest= meshBuildMRM.DistanceCoarsest;
nlassert(_LevelDetail.DistanceFinest>=0);
nlassert(_LevelDetail.DistanceMiddle > _LevelDetail.DistanceFinest);
nlassert(_LevelDetail.DistanceCoarsest > _LevelDetail.DistanceMiddle);
// Compute OODistDelta and DistancePow
_LevelDetail.compileDistanceSetup();
// For load balancing.
//================================================
// compute Max Face Used
_LevelDetail.MaxFaceUsed= 0;
_LevelDetail.MinFaceUsed= 0;
// Count of primitive block
if(_Lods.size()>0)
{
uint pb;
// Compute MinFaces.
CLod &firstLod= _Lods[0];
for (pb=0; pb<firstLod.RdrPass.size(); pb++)
{
CRdrPass &pass= firstLod.RdrPass[pb];
// Sum tri
_LevelDetail.MinFaceUsed+= pass.getNumTriangle ();
}
// Compute MaxFaces.
CLod &lastLod= _Lods[_Lods.size()-1];
for (pb=0; pb<lastLod.RdrPass.size(); pb++)
{
CRdrPass &pass= lastLod.RdrPass[pb];
// Sum tri
_LevelDetail.MaxFaceUsed+= pass.getNumTriangle ();
}
}
// For skinning.
//================================================
// Inform that the mesh data has changed
dirtMeshDataId();
// For AGP SKinning optim, and for Render optim
//================================================
uint i;
for(i=0;i<_Lods.size();i++)
{
// sort triangles for better cache use.
_Lods[i].optimizeTriangleOrder();
}
// No Blend Shapes
//================================================
nlassert (meshBuildMRM.BlendShapes.size() == 0);
// Compact bone id and build a bone id names
//================================================
// Remap
std::map<uint, uint> remap;
// Current bone
uint currentBone = 0;
// Reserve memory
_BonesName.reserve (m.BonesNames.size());
// For each vertices
uint vert;
CPackedVertexBuffer::CPackedVertex *vertices = _VBufferFinal.getPackedVertices();
for (vert=0; vert<_VBufferFinal.getNumVertices(); vert++)
{
// Found one ?
bool found=false;
// For each weight
uint weight;
for (weight=0; weight<NL3D_MESH_MRM_SKINNED_MAX_MATRIX; weight++)
{
// Active ?
if ((vertices[vert].Weights[weight]>0)||(weight==0))
{
// Look for it
std::map<uint, uint>::iterator ite = remap.find (vertices[vert].Matrices[weight]);
// Find ?
if (ite == remap.end())
{
// Insert it
remap.insert (std::map<uint, uint>::value_type (vertices[vert].Matrices[weight], currentBone));
// Check the id
nlassert (vertices[vert].Matrices[weight]<m.BonesNames.size());
// Set the bone name
_BonesName.push_back (m.BonesNames[vertices[vert].Matrices[weight]]);
// Set the local bone id
vertices[vert].Matrices[weight] = currentBone++;
}
else
{
// Set the local bone id
vertices[vert].Matrices[weight] = ite->second;
}
// Found one
found = true;
}
}
// Found one ?
nlassert (found);
}
// Remap the vertex influence by lods
uint lod;
for (lod=0; lod<_Lods.size(); lod++)
{
// For each matrix used
uint matrix;
for (matrix=0; matrix<_Lods[lod].MatrixInfluences.size(); matrix++)
{
// Remap
std::map<uint, uint>::iterator ite = remap.find (_Lods[lod].MatrixInfluences[matrix]);
// Not find ?
if (ite == remap.end())
{
// Remove it
_Lods[lod].MatrixInfluences.erase (_Lods[lod].MatrixInfluences.begin()+matrix);
matrix--;
continue;
}
// Remap
_Lods[lod].MatrixInfluences[matrix] = ite->second;
}
}
// Misc.
//===================
// Some runtime not serialized compilation
compileRunTime();
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::applyMaterialRemap(const std::vector<sint> &remap)
{
for(uint lod=0;lod<getNbLod();lod++)
{
for(uint rp=0;rp<getNbRdrPass(lod);rp++)
{
// remap
uint32 &matId= _Lods[lod].RdrPass[rp].MaterialId;
nlassert(remap[matId]>=0);
matId= remap[matId];
}
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::applyGeomorph(std::vector<CMRMWedgeGeom> &geoms, float alphaLod)
{
applyGeomorphWithVBHardPtr(geoms, alphaLod);
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::applyGeomorphWithVBHardPtr(std::vector<CMRMWedgeGeom> &geoms, float alphaLod)
{
// no geomorphs? quit.
if(geoms.size()==0)
return;
clamp(alphaLod, 0.f, 1.f);
sint a= (uint)floor((256.f*alphaLod)+0.5f);
sint a1= 256 - a;
// info from VBuffer.
uint8 *vertexPtr= (uint8*)_VBufferFinal.getPackedVertices();
sint32 vertexSize= sizeof(CPackedVertexBuffer::CPackedVertex);
// use a faster method
applyGeomorphPosNormalUV0Int(geoms, vertexPtr, vertexPtr, vertexSize, a, a1);
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::applyGeomorphPosNormalUV0(std::vector<CMRMWedgeGeom> &geoms, uint8 *vertexPtr, uint8 *vertexDestPtr, sint32 vertexSize, float a, float a1)
{
nlassert(vertexSize==32);
// For all geomorphs.
uint nGeoms= (uint)geoms.size();
CMRMWedgeGeom *ptrGeom= &(geoms[0]);
uint8 *destPtr= vertexDestPtr;
for(; nGeoms>0; nGeoms--, ptrGeom++, destPtr+= vertexSize )
{
// Consider the Pos/Normal/UV as an array of 8 float to interpolate.
float *start= (float*)(vertexPtr + (ptrGeom->Start<<5));
float *end= (float*)(vertexPtr + (ptrGeom->End<<5));
float *dst= (float*)(destPtr);
// unrolled
dst[0]= start[0] * a + end[0]* a1;
dst[1]= start[1] * a + end[1]* a1;
dst[2]= start[2] * a + end[2]* a1;
dst[3]= start[3] * a + end[3]* a1;
dst[4]= start[4] * a + end[4]* a1;
dst[5]= start[5] * a + end[5]* a1;
dst[6]= start[6] * a + end[6]* a1;
dst[7]= start[7] * a + end[7]* a1;
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::applyGeomorphPosNormalUV0Int(std::vector<CMRMWedgeGeom> &geoms, uint8 *vertexPtr, uint8 *vertexDestPtr, sint32 vertexSize, sint a, sint a1)
{
// For all geomorphs.
uint nGeoms= (uint)geoms.size();
CMRMWedgeGeom *ptrGeom= &(geoms[0]);
uint8 *destPtr= vertexDestPtr;
for(; nGeoms>0; nGeoms--, ptrGeom++, destPtr+= vertexSize )
{
// Consider the Pos/Normal/UV as an array of 8 float to interpolate.
sint16 *start= (sint16*)(vertexPtr + (ptrGeom->Start*vertexSize));
sint16 *end= (sint16*)(vertexPtr + (ptrGeom->End*vertexSize));
sint16 *dst= (sint16*)(destPtr);
/* Hulud
* This is slow but, we don't care because this method is called for debug purpose only (watch skin without skinning)
*/
// unrolled
dst[0]= (sint16)(((sint)(start[0]) * a + (sint)(end[0]) * a1)>>8);
dst[1]= (sint16)(((sint)(start[1]) * a + (sint)(end[1]) * a1)>>8);
dst[2]= (sint16)(((sint)(start[2]) * a + (sint)(end[2]) * a1)>>8);
dst[3]= (sint16)(((sint)(start[3]) * a + (sint)(end[3]) * a1)>>8);
dst[4]= (sint16)(((sint)(start[4]) * a + (sint)(end[4]) * a1)>>8);
dst[5]= (sint16)(((sint)(start[5]) * a + (sint)(end[5]) * a1)>>8);
dst[6]= (sint16)(((sint)(start[6]) * a + (sint)(end[6]) * a1)>>8);
dst[7]= (sint16)(((sint)(start[7]) * a + (sint)(end[7]) * a1)>>8);
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::initInstance(CMeshBaseInstance *mbi)
{
}
// ***************************************************************************
bool CMeshMRMSkinnedGeom::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;
}
// ***************************************************************************
inline sint CMeshMRMSkinnedGeom::chooseLod(float alphaMRM, float &alphaLod)
{
// Choose what Lod to draw.
alphaMRM*= _Lods.size()-1;
sint numLod= (sint)ceil(alphaMRM);
if(numLod==0)
{
numLod= 0;
alphaLod= 0;
}
else
{
// Lerp beetween lod i-1 and lod i.
alphaLod= alphaMRM-(numLod-1);
}
/// Ensure numLod is correct
if(numLod>=(sint)_Lods.size())
{
numLod= (sint)_Lods.size()-1;
alphaLod= 1;
}
return numLod;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::render(IDriver *drv, CTransformShape *trans, float polygonCount, uint32 rdrFlags, float globalAlpha)
{
nlassert(drv);
if(_Lods.size()==0)
return;
// get the meshMRM instance.
CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans);
// get the result of the Load Balancing.
float alphaMRM= _LevelDetail.getLevelDetailFromPolyCount(polygonCount);
// choose the lod.
float alphaLod;
sint numLod= chooseLod(alphaMRM, alphaLod);
// Render the choosen Lod.
CLod &lod= _Lods[numLod];
if(lod.RdrPass.size()==0)
return;
// 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(!(mi->isSkinned() && skeleton));
// Profiling
//===========
H_AUTO( NL3D_MeshMRMGeom_RenderNormal );
// Skinning.
//===========
// set the instance worldmatrix.
drv->setupModelMatrix(trans->getWorldMatrix());
// Geomorph.
//===========
// Geomorph the choosen Lod (if not the coarser mesh).
if(numLod>0)
{
applyGeomorph(lod.Geomorphs, alphaLod);
}
// force normalisation of normals..
bool bkupNorm= drv->isForceNormalize();
drv->forceNormalize(true);
// Setup meshVertexProgram
//===========
// Render the lod.
//===========
// active VB.
/* Hulud
* This is slow but, we don't care because this method is called for debug purpose only (watch skin without skinning)
*/
CVertexBuffer tmp;
getVertexBuffer (tmp);
drv->activeVertexBuffer(tmp);
// Global alpha used ?
uint32 globalAlphaUsed= rdrFlags & IMeshGeom::RenderGlobalAlpha;
uint8 globalAlphaInt=(uint8)NLMISC::OptFastFloor(globalAlpha*255);
// Render all pass.
if (globalAlphaUsed)
{
bool gaDisableZWrite= (rdrFlags & IMeshGeom::RenderGADisableZWrite)?true:false;
// for all passes
for(uint i=0;i<lod.RdrPass.size();i++)
{
CRdrPass &rdrPass= lod.RdrPass[i];
if ( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) ||
( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) )
{
// CMaterial Ref
CMaterial &material=mi->Materials[rdrPass.MaterialId];
// Use a MeshBlender to modify material and driver.
CMeshBlender blender;
blender.prepareRenderForGlobalAlpha(material, drv, globalAlpha, globalAlphaInt, gaDisableZWrite);
/* Hulud
* This is slow but, we don't care because this method is called for debug purpose only (watch skin without skinning)
*/
CIndexBuffer block;
lod.getRdrPassPrimitiveBlock (i, block);
// Render
drv->activeIndexBuffer(block);
drv->renderTriangles(material, 0, block.getNumIndexes()/3);
// Resetup material/driver
blender.restoreRender(material, drv, gaDisableZWrite);
}
}
}
else
{
for(uint i=0;i<lod.RdrPass.size();i++)
{
CRdrPass &rdrPass= lod.RdrPass[i];
if ( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) ||
( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) )
{
// CMaterial Ref
CMaterial &material=mi->Materials[rdrPass.MaterialId];
/* Hulud
* This is slow but, we don't care because this method is called for debug purpose only (watch skin without skinning)
*/
CIndexBuffer block;
lod.getRdrPassPrimitiveBlock (i, block);
// Render with the Materials of the MeshInstance.
drv->activeIndexBuffer(block);
drv->renderTriangles(material, 0, block.getNumIndexes()/3);
}
}
}
// bkup force normalisation.
drv->forceNormalize(bkupNorm);
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::renderSkin(CTransformShape *trans, float alphaMRM)
{
}
// ***************************************************************************
bool CMeshMRMSkinnedGeom::supportSkinGrouping() const
{
return true;
}
// ***************************************************************************
sint CMeshMRMSkinnedGeom::renderSkinGroupGeom(CMeshMRMSkinnedInstance *mi, float alphaMRM, uint remainingVertices, uint8 *vbDest)
{
H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpGeom )
// since not tested in supportSkinGrouping(), must test _Lods.empty(): no lod, no draw
if(_Lods.empty())
return 0;
// get a ptr on scene
CScene *ownerScene= mi->getOwnerScene();
// get a ptr on renderTrav
CRenderTrav *renderTrav= &ownerScene->getRenderTrav();
// get a ptr on the driver
IDriver *drv= renderTrav->getDriver();
nlassert(drv);
// choose the lod.
float alphaLod;
sint numLod= chooseLod(alphaMRM, alphaLod);
_LastLodComputed= numLod;
// Render the choosen Lod.
CLod &lod= _Lods[numLod];
if(lod.RdrPass.size()==0)
// return no vertices added
return 0;
// If the Lod is too big to render in the VBufferHard
if(lod.NWedges>remainingVertices)
// return Failure
return -1;
// get the skeleton model to which I am skinned
CSkeletonModel *skeleton;
skeleton = mi->getSkeletonModel();
// must be skinned for renderSkin()
nlassert(mi->isSkinned() && skeleton);
// Profiling
//===========
H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpGeom_go );
// Skinning.
//===========
// Use RawSkin if possible: only if no morph, and only Vertex/Normal
updateRawSkinNormal(true, mi, numLod);
// NB: the skeleton matrix has already been setuped by CSkeletonModel
// NB: the normalize flag has already been setuped by CSkeletonModel
// applySkin with RawSkin.
//--------
nlassert(mi->_RawSkinCache);
H_AUTO( NL3D_RawSkinning );
// RawSkin do all the job in optimized way: Skinning, copy to VBHard and Geomorph.
// skinning with normal, but no tangent space
applyRawSkinWithNormal (lod, *(mi->_RawSkinCache), skeleton, vbDest, alphaLod);
// Vertices are packed in RawSkin mode (ie no holes due to MRM!)
return (sint)mi->_RawSkinCache->Geomorphs.size() +
mi->_RawSkinCache->TotalSoftVertices +
mi->_RawSkinCache->TotalHardVertices;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::renderSkinGroupPrimitives(CMeshMRMSkinnedInstance *mi, uint baseVertex, std::vector<CSkinSpecularRdrPass> &specularRdrPasses, uint skinIndex)
{
H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpPrimitives );
// get a ptr on scene
CScene *ownerScene= mi->getOwnerScene();
// get a ptr on renderTrav
CRenderTrav *renderTrav= &ownerScene->getRenderTrav();
// get a ptr on the driver
IDriver *drv= renderTrav->getDriver();
nlassert(drv);
// Get the lod choosen in renderSkinGroupGeom()
CLod &lod= _Lods[_LastLodComputed];
// must update primitive cache
updateShiftedTriangleCache(mi, _LastLodComputed, baseVertex);
nlassert(mi->_ShiftedTriangleCache);
// Render Triangles with cache
//===========
for(uint i=0;i<lod.RdrPass.size();i++)
{
CRdrPass &rdrPass= lod.RdrPass[i];
// CMaterial Ref
CMaterial &material=mi->Materials[rdrPass.MaterialId];
// TestYoyo. Material Speed Test
/*if( material.getDiffuse()!=CRGBA(250, 251, 252) )
{
material.setDiffuse(CRGBA(250, 251, 252));
// Set all texture the same.
static CSmartPtr<ITexture> pTexFile= new CTextureFile("fy_hom_visage_c1_fy_e1.tga");
material.setTexture(0, pTexFile );
// Remove Specular.
if(material.getShader()==CMaterial::Specular)
{
CSmartPtr<ITexture> tex= material.getTexture(0);
material.setShader(CMaterial::Normal);
material.setTexture(0, tex );
}
// Remove MakeUp
material.setTexture(1, NULL);
}*/
// If the material is a specular material, don't render it now!
if(material.getShader()==CMaterial::Specular)
{
// Add it to the rdrPass to sort!
CSkinSpecularRdrPass specRdrPass;
specRdrPass.SkinIndex= skinIndex;
specRdrPass.RdrPassIndex= i;
// Get the handle of the specular Map as the sort Key
ITexture *specTex= material.getTexture(1);
if(!specTex)
specRdrPass.SpecId= 0;
else
specRdrPass.SpecId= drv->getTextureHandle( *specTex );
// Append it to the list
specularRdrPasses.push_back(specRdrPass);
}
else
{
// Get the shifted triangles.
CShiftedTriangleCache::CRdrPass &shiftedRdrPass= mi->_ShiftedTriangleCache->RdrPass[i];
// Render with the Materials of the MeshInstance.
drv->activeIndexBuffer(mi->_ShiftedTriangleCache->RawIndices);
drv->renderTriangles(material, shiftedRdrPass.Triangles, shiftedRdrPass.NumTriangles);
}
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::renderSkinGroupSpecularRdrPass(CMeshMRMSkinnedInstance *mi, uint rdrPassId)
{
H_AUTO( NL3D_MeshMRMGeom_rdrSkinGrpSpecularRdrPass );
// get a ptr on scene
CScene *ownerScene= mi->getOwnerScene();
// get a ptr on renderTrav
CRenderTrav *renderTrav= &ownerScene->getRenderTrav();
// get a ptr on the driver
IDriver *drv= renderTrav->getDriver();
nlassert(drv);
// Get the lod choosen in renderSkinGroupGeom()
CLod &lod= _Lods[_LastLodComputed];
// _ShiftedTriangleCache must have been computed in renderSkinGroupPrimitives
nlassert(mi->_ShiftedTriangleCache);
// Render Triangles with cache
//===========
CRdrPass &rdrPass= lod.RdrPass[rdrPassId];
// CMaterial Ref
CMaterial &material=mi->Materials[rdrPass.MaterialId];
// Get the shifted triangles.
CShiftedTriangleCache::CRdrPass &shiftedRdrPass= mi->_ShiftedTriangleCache->RdrPass[rdrPassId];
// Render with the Materials of the MeshInstance.
drv->activeIndexBuffer(mi->_ShiftedTriangleCache->RawIndices);
drv->renderTriangles(material, shiftedRdrPass.Triangles, shiftedRdrPass.NumTriangles);
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::updateShiftedTriangleCache(CMeshMRMSkinnedInstance *mi, sint curLodId, uint baseVertex)
{
// if the instance has a cache, but not sync to us, delete it.
if( mi->_ShiftedTriangleCache && (
mi->_ShiftedTriangleCache->MeshDataId != _MeshDataId ||
mi->_ShiftedTriangleCache->LodId != curLodId ||
mi->_ShiftedTriangleCache->BaseVertex != baseVertex) )
{
mi->clearShiftedTriangleCache();
}
// If the instance has not a valid cache, must create it.
if( !mi->_ShiftedTriangleCache )
{
mi->_ShiftedTriangleCache= new CShiftedTriangleCache;
// Fill the cache Key.
mi->_ShiftedTriangleCache->MeshDataId= _MeshDataId;
mi->_ShiftedTriangleCache->LodId= curLodId;
mi->_ShiftedTriangleCache->BaseVertex= baseVertex;
// Build list of PBlock. From Lod, or from RawSkin cache.
static vector<CIndexBuffer*> pbList;
pbList.clear();
nlassert(mi->_RawSkinCache);
pbList.resize(mi->_RawSkinCache->RdrPass.size());
for(uint i=0;i<pbList.size();i++)
{
pbList[i]= &mi->_RawSkinCache->RdrPass[i];
}
// Build RdrPass
mi->_ShiftedTriangleCache->RdrPass.resize((uint32)pbList.size());
// First pass, count number of triangles, and fill header info
uint totalTri= 0;
uint i;
for(i=0;i<pbList.size();i++)
{
mi->_ShiftedTriangleCache->RdrPass[i].NumTriangles= pbList[i]->getNumIndexes()/3;
totalTri+= pbList[i]->getNumIndexes()/3;
}
// Allocate triangles indices.
mi->_ShiftedTriangleCache->RawIndices.setFormat(NL_SKINNED_MESH_MRM_INDEX_FORMAT);
mi->_ShiftedTriangleCache->RawIndices.setNumIndexes(totalTri*3);
CIndexBufferReadWrite iba;
mi->_ShiftedTriangleCache->RawIndices.lock(iba);
// Second pass, fill ptrs, and fill Arrays
uint indexTri= 0;
for(i=0;i<pbList.size();i++)
{
CShiftedTriangleCache::CRdrPass &dstRdrPass= mi->_ShiftedTriangleCache->RdrPass[i];
dstRdrPass.Triangles= indexTri*3;
// Fill the array
uint numTris= pbList[i]->getNumIndexes()/3;
if(numTris)
{
uint nIds= numTris*3;
// index, and fill
CIndexBufferRead ibaRead;
pbList[i]->lock (ibaRead);
#ifndef NL_SKINNED_MESH_MRM_INDEX16
nlassert(iba.getFormat() == CIndexBuffer::Indices32);
const uint32 *pSrcTri= (const uint32 *) ibaRead.getPtr();
uint32 *pDstTri= (uint32 *) iba.getPtr() + dstRdrPass.Triangles;
for(;nIds>0;nIds--,pSrcTri++,pDstTri++)
*pDstTri= *pSrcTri + baseVertex;
#else
nlassert(iba.getFormat() == CIndexBuffer::Indices16);
const uint16 *pSrcTri= (const uint16 *) ibaRead.getPtr();
uint16 *pDstTri= (uint16 *) iba.getPtr() + dstRdrPass.Triangles;
for(;nIds>0;nIds--,pSrcTri++,pDstTri++)
*pDstTri= *pSrcTri + baseVertex;
#endif
}
// Next
indexTri+= dstRdrPass.NumTriangles;
}
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::serial(NLMISC::IStream &f)
{
// because of complexity, serial is separated in save / load.
/*
Version 0:
- base version.
*/
f.serialVersion(0);
// serial bones names
f.serialCont (_BonesName);
if (f.isReading())
{
// Bones index are in skeleton model id list
_BoneIdComputed = false;
// Must always recompute usage of parents of bones used.
_BoneIdExtended = false;
}
// serial Basic info.
// ==================
f.serial(_BBox);
f.serial(_LevelDetail.MaxFaceUsed);
f.serial(_LevelDetail.MinFaceUsed);
f.serial(_LevelDetail.DistanceFinest);
f.serial(_LevelDetail.DistanceMiddle);
f.serial(_LevelDetail.DistanceCoarsest);
f.serial(_LevelDetail.OODistanceDelta);
f.serial(_LevelDetail.DistancePow);
// Prepare the VBuffer.
if (f.isReading())
_VBufferFinal.contReset();
_VBufferFinal.serial(f);
// serial Shadow Skin Information
f.serialCont (_ShadowSkin.Vertices);
f.serialCont (_ShadowSkin.Triangles);
// resest the Lod arrays. NB: each Lod is empty, and ready to receive Lod data.
// ==================
if (f.isReading())
{
contReset(_Lods);
}
f.serialCont (_Lods);
if (f.isReading())
{
// Inform that the mesh data has changed
dirtMeshDataId();
// Some runtime not serialized compilation
compileRunTime();
}
}
// ***************************************************************************
float CMeshMRMSkinnedGeom::getNumTriangles (float distance)
{
// NB: this is an approximation, but this is continious.
return _LevelDetail.getNumTriangles(distance);
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::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 the vertices, and compute Bone Spheres.
// Find the Geomorph space: to process only real vertices, not geomorphed ones.
uint nGeomSpace= 0;
uint lod;
for (lod=0; lod<_Lods.size(); lod++)
{
nGeomSpace= max(nGeomSpace, (uint)_Lods[lod].Geomorphs.size());
}
// Prepare Sphere compute
static std::vector<CAABBox> boneBBoxes;
static std::vector<bool> boneBBEmpty;
boneBBoxes.clear();
boneBBEmpty.clear();
boneBBoxes.resize(_BonesId.size());
boneBBEmpty.resize(_BonesId.size(), true);
// Remap the vertex, and compute the bone spheres. see CTransform::getSkinBoneSphere() doc.
// for true vertices
uint vert;
const uint vertexCount = _VBufferFinal.getNumVertices();
CPackedVertexBuffer::CPackedVertex *vertices = _VBufferFinal.getPackedVertices();
for (vert=nGeomSpace; vert<vertexCount; vert++)
{
// get the vertex position.
CVector vertex;
_VBufferFinal.getPos (vertex, vertices[vert]);
// For each weight
uint weight;
for (weight=0; weight<NL3D_MESH_SKINNING_MAX_MATRIX; weight++)
{
// Active ?
if ((vertices[vert].Weights[weight]>0)||(weight==0))
{
// Check id
uint srcId= vertices[vert].Matrices[weight];
nlassert (srcId < remap.size());
// remap
vertices[vert].Matrices[weight] = remap[srcId];
// if the boneId is valid (ie found)
if(_BonesId[srcId]>=0)
{
// transform the vertex pos in BoneSpace
CVector p= skeleton->Bones[_BonesId[srcId]].getBoneBase().InvBindPos * vertex;
// extend the bone bbox.
if(boneBBEmpty[srcId])
{
boneBBoxes[srcId].setCenter(p);
boneBBEmpty[srcId]= false;
}
else
{
boneBBoxes[srcId].extend(p);
}
}
}
else
break;
}
}
// Compile spheres
_BonesSphere.resize(_BonesId.size());
for(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();
}
}
// **** Remap the vertex influence by lods
for (lod=0; lod<_Lods.size(); lod++)
{
// For each matrix used
uint matrix;
for (matrix=0; matrix<_Lods[lod].MatrixInfluences.size(); matrix++)
{
// Check
nlassert (_Lods[lod].MatrixInfluences[matrix]<remap.size());
// Remap
_Lods[lod].MatrixInfluences[matrix] = remap[_Lods[lod].MatrixInfluences[matrix]];
}
}
// **** Remap Shadow Vertices.
for(vert=0;vert<_ShadowSkin.Vertices.size();vert++)
{
CShadowVertex &v= _ShadowSkin.Vertices[vert];
// Check id
nlassert (v.MatrixId < remap.size());
v.MatrixId= remap[v.MatrixId];
}
// Computed
_BoneIdComputed = true;
}
}
// Already extended ?
if (!_BoneIdExtended)
{
nlassert (skeleton);
if (skeleton)
{
// the total bone Usage of the mesh.
vector<bool> boneUsage;
boneUsage.resize(skeleton->Bones.size(), false);
// for all Bones marked as valid.
uint i;
for(i=0; i<_BonesId.size(); i++)
{
// if not a valid boneId, skip it.
if(_BonesId[i]<0)
continue;
// mark him and his father in boneUsage.
skeleton->flagBoneAndParents(_BonesId[i], boneUsage);
}
// fill _BonesIdExt with bones of _BonesId and their parents.
_BonesIdExt.clear();
for(i=0; i<boneUsage.size();i++)
{
// if the bone is used by the mesh, add it to BoneIdExt.
if(boneUsage[i])
_BonesIdExt.push_back(i);
}
}
// Extended
_BoneIdExtended= true;
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::updateSkeletonUsage(CSkeletonModel *sm, bool increment)
{
// For all Bones used.
for(uint i=0; i<_BonesIdExt.size();i++)
{
uint boneId= _BonesIdExt[i];
// Some explicit Error.
if(boneId>=sm->Bones.size())
nlerror(" Skin is incompatible with Skeleton: tries to use bone %d", boneId);
// increment or decrement not Forced, because CMeshGeom use getActiveBoneSkinMatrix().
if(increment)
sm->incBoneUsage(boneId, CSkeletonModel::UsageNormal);
else
sm->decBoneUsage(boneId, CSkeletonModel::UsageNormal);
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::compileRunTime()
{
_PreciseClipping= _BBox.getRadius() >= NL3D_MESH_PRECISE_CLIP_THRESHOLD;
// The Mesh must follow those restrictions, to support group skinning
nlassert (_VBufferFinal.getNumVertices() < NL3D_MESH_SKIN_MANAGER_MAXVERTICES);
// Support Shadow SkinGrouping if Shadow setuped, and if not too many vertices.
_SupportShadowSkinGrouping= !_ShadowSkin.Vertices.empty() &&
NL3D_SHADOW_MESH_SKIN_MANAGER_VERTEXFORMAT==CVertexBuffer::PositionFlag &&
_ShadowSkin.Vertices.size() <= NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::profileSceneRender(CRenderTrav *rdrTrav, CTransformShape *trans, float polygonCount, uint32 rdrFlags)
{
// if no _Lods, no draw
if(_Lods.empty())
return;
// get the result of the Load Balancing.
float alphaMRM= _LevelDetail.getLevelDetailFromPolyCount(polygonCount);
// choose the lod.
float alphaLod;
sint numLod= chooseLod(alphaMRM, alphaLod);
// Render the choosen Lod.
CLod &lod= _Lods[numLod];
// get the mesh instance.
CMeshBaseInstance *mi= safe_cast<CMeshBaseInstance*>(trans);
// Profile all pass.
uint triCount= 0;
for (uint i=0;i<lod.RdrPass.size();i++)
{
CRdrPass &rdrPass= lod.RdrPass[i];
// Profile with the Materials of the MeshInstance.
if ( ( (mi->Materials[rdrPass.MaterialId].getBlend() == false) && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) ) ||
( (mi->Materials[rdrPass.MaterialId].getBlend() == true) && (rdrFlags & IMeshGeom::RenderTransparentMaterial) ) )
{
triCount+= rdrPass.getNumTriangle();
}
}
// Profile
if(triCount)
{
// tri per VBFormat
rdrTrav->Scene->incrementProfileTriVBFormat(rdrTrav->Scene->BenchRes.MeshMRMProfileTriVBFormat,
NL3D_MESH_SKIN_MANAGER_VERTEXFORMAT, triCount);
rdrTrav->Scene->BenchRes.NumMeshMRMVBufferStd++;
rdrTrav->Scene->BenchRes.NumMeshMRMRdrNormal++;
rdrTrav->Scene->BenchRes.NumMeshMRMTriRdrNormal+= triCount;
}
}
// ***************************************************************************
bool CMeshMRMSkinnedGeom::getSkinBoneBBox(CSkeletonModel *skeleton, NLMISC::CAABBox &bbox, uint boneId) const
{
bbox.setCenter(CVector::Null);
bbox.setHalfSize(CVector::Null);
if(!skeleton)
return false;
// get the bindpos of the wanted bone
nlassert(boneId<skeleton->Bones.size());
const CMatrix &invBindPos= skeleton->Bones[boneId].getBoneBase().InvBindPos;
// Find the Geomorph space: to process only real vertices, not geomorphed ones.
uint nGeomSpace= 0;
uint lod;
for (lod=0; lod<_Lods.size(); lod++)
{
nGeomSpace= max(nGeomSpace, (uint)_Lods[lod].Geomorphs.size());
}
// Prepare BBox compute
bool bbEmpty= true;
// Remap the vertex, and compute the wanted bone bbox
// for true vertices
const uint vertexCount = _VBufferFinal.getNumVertices();
const CPackedVertexBuffer::CPackedVertex *vertices = _VBufferFinal.getPackedVertices();
for (uint vert=nGeomSpace; vert<vertexCount; vert++)
{
// get the vertex position.
CVector vertex;
_VBufferFinal.getPos (vertex, vertices[vert]);
// For each weight
uint weight;
for (weight=0; weight<NL3D_MESH_SKINNING_MAX_MATRIX; weight++)
{
// Active ?
if ((vertices[vert].Weights[weight]>0)||(weight==0))
{
// Check id is the wanted one
if(vertices[vert].Matrices[weight]==boneId)
{
// transform the vertex pos in BoneSpace
CVector p= invBindPos * vertex;
// extend the bone bbox.
if(bbEmpty)
{
bbox.setCenter(p);
bbEmpty= false;
}
else
{
bbox.extend(p);
}
}
}
else
break;
}
}
// return true if some influence found
return !bbEmpty;
}
// ***************************************************************************
// ***************************************************************************
// Mesh Block Render Interface
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
bool CMeshMRMSkinnedGeom::supportMeshBlockRendering () const
{
/*
Yoyo: Don't Support It for MRM because too Slow!!
The problem is that lock() unlock() on each instance, on the same VBHeap IS AS SLOWER AS
VB switching.
TODO_OPTIMIZE: find a way to optimize MRM.
*/
return false;
}
// ***************************************************************************
// ***************************************************************************
// CMeshMRMSkinned.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CMeshMRMSkinned::CMeshMRMSkinned()
{
}
// ***************************************************************************
bool CMeshMRMSkinned::isCompatible(const CMesh::CMeshBuild &m)
{
/* Optimised shape for skinned object with MRM, 1 UV coordinates, 1 to 4 skinning weight and 256 matrices
Tangeant space, vertex program, mesh block rendering and vertex buffer hard are not available. */
// Vertex format
if (m.VertexFlags != NL3D_MESH_MRM_SKINNED_VERTEX_FORMAT)
return false;
// No W
if (m.NumCoords[0] != 2)
return false;
// No blend shape
if (!m.BlendShapes.empty())
return false;
// Check number of vertices
if (m.Vertices.size() > NL3D_MESH_SKIN_MANAGER_MAXVERTICES)
return false;
// Ok
return true;
}
// ***************************************************************************
void CMeshMRMSkinned::build (CMeshBase::CMeshBaseBuild &mBase, CMesh::CMeshBuild &m,
const CMRMParameters &params)
{
nlassert (isCompatible(m));
/// copy MeshBase info: materials ....
CMeshBase::buildMeshBase (mBase);
// Then build the geom.
_MeshMRMGeom.build (m, (uint)mBase.Materials.size(), params);
}
// ***************************************************************************
void CMeshMRMSkinned::build (CMeshBase::CMeshBaseBuild &m, const CMeshMRMSkinnedGeom &mgeom)
{
/// copy MeshBase info: materials ....
CMeshBase::buildMeshBase(m);
// Then copy the geom.
_MeshMRMGeom= mgeom;
}
// ***************************************************************************
void CMeshMRMSkinned::optimizeMaterialUsage(std::vector<sint> &remap)
{
// For each material, count usage.
vector<bool> materialUsed;
materialUsed.resize(CMeshBase::_Materials.size(), false);
for(uint lod=0;lod<getNbLod();lod++)
{
for(uint rp=0;rp<getNbRdrPass(lod);rp++)
{
uint matId= getRdrPassMaterial(lod, rp);
// flag as used.
materialUsed[matId]= true;
}
}
// Apply it to meshBase
CMeshBase::applyMaterialUsageOptim(materialUsed, remap);
// Apply lut to meshGeom.
_MeshMRMGeom.applyMaterialRemap(remap);
}
// ***************************************************************************
CTransformShape *CMeshMRMSkinned::createInstance(CScene &scene)
{
// Create a CMeshMRMSkinnedInstance, an instance of a mesh.
//===============================================
CMeshMRMSkinnedInstance *mi= (CMeshMRMSkinnedInstance*)scene.createModel(NL3D::MeshMRMSkinnedInstanceId);
mi->Shape= this;
// instanciate the material part of the MeshMRM, ie the CMeshBase.
CMeshBase::instanciateMeshBase(mi, &scene);
// do some instance init for MeshGeom
_MeshMRMGeom.initInstance(mi);
// init the FilterType
mi->initRenderFilterType();
return mi;
}
// ***************************************************************************
bool CMeshMRMSkinned::clip(const std::vector<CPlane> &pyramid, const CMatrix &worldMatrix)
{
return _MeshMRMGeom.clip(pyramid, worldMatrix);
}
// ***************************************************************************
void CMeshMRMSkinned::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
_MeshMRMGeom.render(drv, trans, trans->getNumTrianglesAfterLoadBalancing(), rdrFlags, 1);
}
// ***************************************************************************
void CMeshMRMSkinned::serial(NLMISC::IStream &f)
{
/*
Version 0:
- base version.
*/
(void)f.serialVersion(0);
// serial Materials infos contained in CMeshBase.
CMeshBase::serialMeshBase(f);
// serial the geometry.
_MeshMRMGeom.serial(f);
}
// ***************************************************************************
float CMeshMRMSkinned::getNumTriangles (float distance)
{
return _MeshMRMGeom.getNumTriangles (distance);
}
// ***************************************************************************
const CMeshMRMSkinnedGeom& CMeshMRMSkinned::getMeshGeom () const
{
return _MeshMRMGeom;
}
// ***************************************************************************
void CMeshMRMSkinned::computeBonesId (CSkeletonModel *skeleton)
{
_MeshMRMGeom.computeBonesId (skeleton);
}
// ***************************************************************************
void CMeshMRMSkinned::updateSkeletonUsage (CSkeletonModel *skeleton, bool increment)
{
_MeshMRMGeom.updateSkeletonUsage(skeleton, increment);
}
// ***************************************************************************
void CMeshMRMSkinned::changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest)
{
_MeshMRMGeom.changeMRMDistanceSetup(distanceFinest, distanceMiddle, distanceCoarsest);
}
// ***************************************************************************
IMeshGeom *CMeshMRMSkinned::supportMeshBlockRendering (CTransformShape *trans, float &polygonCount ) const
{
return NULL;
}
// ***************************************************************************
void CMeshMRMSkinned::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);
// profile the mesh
_MeshMRMGeom.profileSceneRender(rdrTrav, trans, trans->getNumTrianglesAfterLoadBalancing(), rdrFlags);
}
// ***************************************************************************
// ***************************************************************************
// CMeshMRMSkinnedGeom RawSkin optimisation
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CMeshMRMSkinnedGeom::dirtMeshDataId()
{
// see updateRawSkinNormal()
_MeshDataId++;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::updateRawSkinNormal(bool enabled, CMeshMRMSkinnedInstance *mi, sint curLodId)
{
if(!enabled)
{
// if the instance cache is not cleared, must clear.
mi->clearRawSkinCache();
}
else
{
// If the instance has no RawSkin, or has a too old RawSkin cache, must delete it, and recreate
if ((mi->_RawSkinCache == NULL) || (mi->_RawSkinCache->MeshDataId!=_MeshDataId))
{
// first delete if too old.
mi->clearRawSkinCache();
// Then recreate, and use _MeshDataId to verify that the instance works with same data.
mi->_RawSkinCache= new CRawSkinnedNormalCache;
mi->_RawSkinCache->MeshDataId= _MeshDataId;
mi->_RawSkinCache->LodId= -1;
}
/* If the instance rawSkin has a different Lod (or if -1), then must recreate it.
NB: The lod may change each frame per instance, but suppose not so many change, so we can cache those data.
*/
if( mi->_RawSkinCache->LodId != curLodId )
{
H_AUTO( NL3D_CMeshMRMGeom_updateRawSkinNormal );
CRawSkinnedNormalCache &skinLod= *mi->_RawSkinCache;
CLod &lod= _Lods[curLodId];
uint i;
sint rawIdx;
// Clear the raw skin mesh.
skinLod.clearArrays();
// Cache this lod
mi->_RawSkinCache->LodId= curLodId;
// For each matrix influence.
nlassert(NL3D_MESH_SKINNING_MAX_MATRIX==4);
// For each vertex, acknowledge if it is a src for geomorph.
static vector<uint8> softVertices;
softVertices.clear();
softVertices.resize( _VBufferFinal.getNumVertices(), 0 );
for(i=0;i<lod.Geomorphs.size();i++)
{
softVertices[lod.Geomorphs[i].Start]= 1;
softVertices[lod.Geomorphs[i].End]= 1;
}
// The remap from old index in _VBufferFinal to RawSkin vertices (without Geomorphs).
static vector<uint32> vertexRemap;
vertexRemap.resize( _VBufferFinal.getNumVertices() );
sint softSize[4];
sint hardSize[4];
sint softStart[4];
sint hardStart[4];
// count vertices
skinLod.TotalSoftVertices= 0;
skinLod.TotalHardVertices= 0;
for(i=0;i<4;i++)
{
softSize[i]= 0;
hardSize[i]= 0;
// Count.
for(uint j=0;j<lod.InfluencedVertices[i].size();j++)
{
uint vid= lod.InfluencedVertices[i][j];
if(softVertices[vid])
softSize[i]++;
else
hardSize[i]++;
}
skinLod.TotalSoftVertices+= softSize[i];
skinLod.TotalHardVertices+= hardSize[i];
skinLod.SoftVertices[i]= softSize[i];
skinLod.HardVertices[i]= hardSize[i];
}
// compute offsets
softStart[0]= 0;
hardStart[0]= skinLod.TotalSoftVertices;
for(i=1;i<4;i++)
{
softStart[i]= softStart[i-1]+softSize[i-1];
hardStart[i]= hardStart[i-1]+hardSize[i-1];
}
// compute remap
for(i=0;i<4;i++)
{
uint softIdx= softStart[i];
uint hardIdx= hardStart[i];
for(uint j=0;j<lod.InfluencedVertices[i].size();j++)
{
uint vid= lod.InfluencedVertices[i][j];
if(softVertices[vid])
vertexRemap[vid]= softIdx++;
else
vertexRemap[vid]= hardIdx++;
}
}
// Resize the dest array.
skinLod.Vertices1.resize((uint32)lod.InfluencedVertices[0].size());
skinLod.Vertices2.resize((uint32)lod.InfluencedVertices[1].size());
skinLod.Vertices3.resize((uint32)lod.InfluencedVertices[2].size());
skinLod.Vertices4.resize((uint32)lod.InfluencedVertices[3].size());
// Vertex buffer pointers
const CPackedVertexBuffer::CPackedVertex *vertices = _VBufferFinal.getPackedVertices();
// 1 Matrix skinning.
//========
for(i=0;i<skinLod.Vertices1.size();i++)
{
// get the dest vertex.
uint vid= lod.InfluencedVertices[0][i];
// where to store?
rawIdx= vertexRemap[vid];
if(softVertices[vid])
rawIdx-= softStart[0];
else
rawIdx+= softSize[0]-hardStart[0];
// fill raw struct
const CPackedVertexBuffer::CPackedVertex &vertex = vertices[vid];
skinLod.Vertices1[rawIdx].MatrixId[0]= vertex.Matrices[0];
_VBufferFinal.getPos (skinLod.Vertices1[rawIdx].Vertex, vertex);
vertex.getNormal (skinLod.Vertices1[rawIdx].Normal);
vertex.getU (skinLod.Vertices1[rawIdx].UV.U);
vertex.getV (skinLod.Vertices1[rawIdx].UV.V);
}
// 2 Matrix skinning.
//========
for(i=0;i<skinLod.Vertices2.size();i++)
{
// get the dest vertex.
uint vid= lod.InfluencedVertices[1][i];
// where to store?
rawIdx= vertexRemap[vid];
if(softVertices[vid])
rawIdx-= softStart[1];
else
rawIdx+= softSize[1]-hardStart[1];
// fill raw struct
const CPackedVertexBuffer::CPackedVertex &vertex = vertices[vid];
skinLod.Vertices2[rawIdx].MatrixId[0]= vertex.Matrices[0];
skinLod.Vertices2[rawIdx].MatrixId[1]= vertex.Matrices[1];
_VBufferFinal.getPos (skinLod.Vertices2[rawIdx].Vertex, vertex);
vertex.getWeight (skinLod.Vertices2[rawIdx].Weights[0], 0);
vertex.getWeight (skinLod.Vertices2[rawIdx].Weights[1], 1);
vertex.getNormal (skinLod.Vertices2[rawIdx].Normal);
vertex.getU (skinLod.Vertices2[rawIdx].UV.U);
vertex.getV (skinLod.Vertices2[rawIdx].UV.V);
}
// 3 Matrix skinning.
//========
for(i=0;i<skinLod.Vertices3.size();i++)
{
// get the dest vertex.
uint vid= lod.InfluencedVertices[2][i];
// where to store?
rawIdx= vertexRemap[vid];
if(softVertices[vid])
rawIdx-= softStart[2];
else
rawIdx+= softSize[2]-hardStart[2];
// fill raw struct
const CPackedVertexBuffer::CPackedVertex &vertex = vertices[vid];
skinLod.Vertices3[rawIdx].MatrixId[0]= vertex.Matrices[0];
skinLod.Vertices3[rawIdx].MatrixId[1]= vertex.Matrices[1];
skinLod.Vertices3[rawIdx].MatrixId[2]= vertex.Matrices[2];
_VBufferFinal.getPos (skinLod.Vertices3[rawIdx].Vertex, vertex);
vertex.getWeight (skinLod.Vertices3[rawIdx].Weights[0], 0);
vertex.getWeight (skinLod.Vertices3[rawIdx].Weights[1], 1);
vertex.getWeight (skinLod.Vertices3[rawIdx].Weights[2], 2);
vertex.getNormal (skinLod.Vertices3[rawIdx].Normal);
vertex.getU (skinLod.Vertices3[rawIdx].UV.U);
vertex.getV (skinLod.Vertices3[rawIdx].UV.V);
}
// 4 Matrix skinning.
//========
for(i=0;i<skinLod.Vertices4.size();i++)
{
// get the dest vertex.
uint vid= lod.InfluencedVertices[3][i];
// where to store?
rawIdx= vertexRemap[vid];
if(softVertices[vid])
rawIdx-= softStart[3];
else
rawIdx+= softSize[3]-hardStart[3];
// fill raw struct
const CPackedVertexBuffer::CPackedVertex &vertex = vertices[vid];
skinLod.Vertices4[rawIdx].MatrixId[0]= vertex.Matrices[0];
skinLod.Vertices4[rawIdx].MatrixId[1]= vertex.Matrices[1];
skinLod.Vertices4[rawIdx].MatrixId[2]= vertex.Matrices[2];
skinLod.Vertices4[rawIdx].MatrixId[3]= vertex.Matrices[3];
_VBufferFinal.getPos (skinLod.Vertices4[rawIdx].Vertex, vertex);
vertex.getWeight (skinLod.Vertices4[rawIdx].Weights[0], 0);
vertex.getWeight (skinLod.Vertices4[rawIdx].Weights[1], 1);
vertex.getWeight (skinLod.Vertices4[rawIdx].Weights[2], 2);
vertex.getWeight (skinLod.Vertices4[rawIdx].Weights[3], 3);
vertex.getNormal (skinLod.Vertices4[rawIdx].Normal);
vertex.getU (skinLod.Vertices4[rawIdx].UV.U);
vertex.getV (skinLod.Vertices4[rawIdx].UV.V);
}
// Remap Geomorphs.
//========
uint numGeoms= (uint)lod.Geomorphs.size();
skinLod.Geomorphs.resize( numGeoms );
for(i=0;i<numGeoms;i++)
{
// NB: don't add "numGeoms" to the index because RawSkin look in a TempArray in RAM, which start at 0...
skinLod.Geomorphs[i].Start= vertexRemap[lod.Geomorphs[i].Start];
skinLod.Geomorphs[i].End= vertexRemap[lod.Geomorphs[i].End];
}
// Remap RdrPass.
//========
skinLod.RdrPass.resize(lod.RdrPass.size());
for(i=0;i<skinLod.RdrPass.size();i++)
{
// remap tris.
skinLod.RdrPass[i].setFormat(NL_SKINNED_MESH_MRM_INDEX_FORMAT);
skinLod.RdrPass[i].setNumIndexes(lod.RdrPass[i].getNumTriangle()*3);
const uint16 *srcTriPtr= &(lod.RdrPass[i].PBlock[0]);
CIndexBufferReadWrite ibaWrite;
skinLod.RdrPass[i].lock (ibaWrite);
#ifndef NL_SKINNED_MESH_MRM_INDEX16
nlassert(ibaWrite.getFormat() == CIndexBuffer::Indices32);
uint32 *dstTriPtr= (uint32 *) ibaWrite.getPtr();
uint32 numIndices= lod.RdrPass[i].PBlock.size();
for(uint j=0;j<numIndices;j++, srcTriPtr++, dstTriPtr++)
{
uint vid= (uint)*srcTriPtr;
// If this index refers to a Geomorphed vertex, don't modify!
if(vid<numGeoms)
*dstTriPtr= vid;
else
*dstTriPtr= vertexRemap[vid] + numGeoms;
}
#else
nlassert(ibaWrite.getFormat() == CIndexBuffer::Indices16);
uint16 *dstTriPtr= (uint16 *) ibaWrite.getPtr();
uint32 numIndices= (uint32)lod.RdrPass[i].PBlock.size();
for(uint j=0;j<numIndices;j++, srcTriPtr++, dstTriPtr++)
{
uint vid= (uint)*srcTriPtr;
// If this index refers to a Geomorphed vertex, don't modify!
if(vid<numGeoms)
*dstTriPtr= vid;
else
*dstTriPtr= (uint16) (vertexRemap[vid] + numGeoms);
}
#endif
}
}
}
}
// ***************************************************************************
// ***************************************************************************
// CMeshMRMSkinnedGeom Shadow Skin Rendering
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CMeshMRMSkinnedGeom::setShadowMesh(const std::vector<CShadowVertex> &shadowVertices, const std::vector<uint32> &triangles)
{
_ShadowSkin.Vertices= shadowVertices;
_ShadowSkin.Triangles= triangles;
// update flag. Support Shadow SkinGrouping if Shadow setuped, and if not too many vertices.
_SupportShadowSkinGrouping= !_ShadowSkin.Vertices.empty() &&
NL3D_SHADOW_MESH_SKIN_MANAGER_VERTEXFORMAT==CVertexBuffer::PositionFlag &&
_ShadowSkin.Vertices.size() <= NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES;
}
// ***************************************************************************
uint CMeshMRMSkinnedGeom::getNumShadowSkinVertices() const
{
return (uint)_ShadowSkin.Vertices.size();
}
// ***************************************************************************
sint CMeshMRMSkinnedGeom::renderShadowSkinGeom(CMeshMRMSkinnedInstance *mi, uint remainingVertices, uint8 *vbDest)
{
uint numVerts= (uint)_ShadowSkin.Vertices.size();
// if no verts, no draw
if(numVerts==0)
return 0;
// if no lods, there should be no verts, but still ensure no bug in skinning
if(_Lods.empty())
return 0;
// If the Lod is too big to render in the VBufferHard
if(numVerts>remainingVertices)
// return Failure
return -1;
// get the skeleton model to which I am skinned
CSkeletonModel *skeleton;
skeleton = mi->getSkeletonModel();
// must be skinned for renderSkin()
nlassert(skeleton);
// Profiling
//===========
H_AUTO_USE( NL3D_MeshMRMGeom_RenderShadow );
// Skinning.
//===========
// For all matrix this Mesh use. (the shadow geometry cannot use other Matrix than the mesh use).
// NB: take the best lod since the lower lods cannot use other Matrix than the higher one.
static vector<CMatrix3x4> boneMat3x4;
CLod &lod= _Lods[_Lods.size()-1];
computeBoneMatrixes3x4(boneMat3x4, lod.MatrixInfluences, skeleton);
_ShadowSkin.applySkin((CVector*)vbDest, boneMat3x4);
// How many vertices are added to the VBuffer ???
return numVerts;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::renderShadowSkinPrimitives(CMeshMRMSkinnedInstance *mi, CMaterial &castMat, IDriver *drv, uint baseVertex)
{
nlassert(drv);
if(_ShadowSkin.Triangles.empty())
return;
// Profiling
//===========
H_AUTO_USE( NL3D_MeshMRMGeom_RenderShadow );
// NB: the skeleton matrix has already been setuped by CSkeletonModel
// NB: the normalize flag has already been setuped by CSkeletonModel
// TODO_SHADOW: optim: Special triangle cache for shadow!
static CIndexBuffer shiftedTris;
shiftedTris.setPreferredMemory(CIndexBuffer::RAMVolatile, false);
if (shiftedTris.getName().empty()) NL_SET_IB_NAME(shiftedTris, "CMeshMRMSkinnedGeom::renderShadowSkinPrimitives::shiftedTris");
//if(shiftedTris.getNumIndexes()<_ShadowSkin.Triangles.size())
//{
shiftedTris.setFormat(NL_SKINNED_MESH_MRM_INDEX_FORMAT);
shiftedTris.setNumIndexes((uint32)_ShadowSkin.Triangles.size());
//}
{
CIndexBufferReadWrite iba;
shiftedTris.lock(iba);
const uint32 *src= &_ShadowSkin.Triangles[0];
TSkinnedMeshMRMIndexType *dst= (TSkinnedMeshMRMIndexType*) iba.getPtr();
for(uint n= (uint)_ShadowSkin.Triangles.size();n>0;n--, src++, dst++)
{
*dst= (TSkinnedMeshMRMIndexType)(*src + baseVertex);
}
}
// Render Triangles with cache
//===========
uint numTris= (uint)_ShadowSkin.Triangles.size()/3;
// Render with the Materials of the MeshInstance.
drv->activeIndexBuffer(shiftedTris);
drv->renderTriangles(castMat, 0, numTris);
}
// ***************************************************************************
bool CMeshMRMSkinnedGeom::intersectSkin(CMeshMRMSkinnedInstance *mi, const CMatrix &toRaySpace, float &dist2D, float &distZ, bool computeDist2D)
{
// no inst/verts/lod => no intersection
if(!mi || _ShadowSkin.Vertices.empty() || _Lods.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).
// NB: take the best lod (_Lods.back()) since the lower lods cannot use other Matrix than the higher one.
return _ShadowSkin.getRayIntersection(toRaySpace, *skeleton, _Lods.back().MatrixInfluences, dist2D, distZ, computeDist2D);
}
// ***************************************************************************
// ***************************************************************************
// CMeshMRMSkinnedGeom::CPackedVertexBuffer
// ***************************************************************************
// ***************************************************************************
void CMeshMRMSkinnedGeom::CPackedVertexBuffer::serial(NLMISC::IStream &f)
{
// Version
f.serialVersion(0);
f.serialCont (_PackedBuffer);
f.serial (_DecompactScale);
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::serial(NLMISC::IStream &f)
{
// Version
f.serialVersion(0);
f.serial (X);
f.serial (Y);
f.serial (Z);
f.serial (Nx);
f.serial (Ny);
f.serial (Nz);
f.serial (U);
f.serial (V);
uint i;
for (i=0; i<NL3D_MESH_MRM_SKINNED_MAX_MATRIX; i++)
{
f.serial (Matrices[i]);
f.serial (Weights[i]);
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setNormal (const CVector &src)
{
CVector pos = src;
pos *= NL3D_MESH_MRM_SKINNED_NORMAL_FACTOR;
pos.x = (float)floor(pos.x+0.5f);
pos.y = (float)floor(pos.y+0.5f);
pos.z = (float)floor(pos.z+0.5f);
clamp (pos.x, -32768.f, 32767.f);
clamp (pos.y, -32768.f, 32767.f);
clamp (pos.z, -32768.f, 32767.f);
Nx = (sint16)pos.x;
Ny = (sint16)pos.y;
Nz = (sint16)pos.z;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setPos (const NLMISC::CVector &pos, float scaleFactor)
{
CVector _pos = pos;
_pos /= scaleFactor;
_pos.x = (float)floor(_pos.x+0.5f);
_pos.y = (float)floor(_pos.y+0.5f);
_pos.z = (float)floor(_pos.z+0.5f);
clamp (_pos.x, -32768.f, 32767.f);
clamp (_pos.y, -32768.f, 32767.f);
clamp (_pos.z, -32768.f, 32767.f);
X = (sint16)_pos.x;
Y = (sint16)_pos.y;
Z = (sint16)_pos.z;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setUV (float _u, float _v)
{
float u = _u * NL3D_MESH_MRM_SKINNED_UV_FACTOR;
float v = _v * NL3D_MESH_MRM_SKINNED_UV_FACTOR;
u = (float)floor(u+0.5f);
v = (float)floor(v+0.5f);
clamp (u, -32768.f, 32767.f);
clamp (v, -32768.f, 32767.f);
U = (sint16)u;
V = (sint16)v;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setWeight (uint weightId, float weight)
{
weight = weight * NL3D_MESH_MRM_SKINNED_WEIGHT_FACTOR;
weight = (float)floor(weight+0.5f);
clamp (weight, 0.f, 255.f);
Weights[weightId] = (uint8)weight;
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::CPackedVertexBuffer::build (const CVertexBuffer &buffer, const std::vector<CMesh::CSkinWeight> &skinWeight)
{
const uint numVertices = buffer.getNumVertices();
nlassert (numVertices == skinWeight.size());
nlassert ((buffer.getVertexFormat() & (CVertexBuffer::PositionFlag|CVertexBuffer::NormalFlag|CVertexBuffer::TexCoord0Flag)) == (CVertexBuffer::PositionFlag|CVertexBuffer::NormalFlag|CVertexBuffer::TexCoord0Flag));
_PackedBuffer.resize (numVertices);
// default scale
_DecompactScale = NL3D_MESH_MRM_SKINNED_DEFAULT_POS_SCALE;
CVertexBufferRead vba;
buffer.lock (vba);
if (numVertices)
{
// Get the min max of the bbox
CVector _min = *vba.getVertexCoordPointer(0);
CVector _max = _min;
// For each vertex
uint i;
for (i=1; i<numVertices; i++)
{
// Update min max
const CVector &vect = *vba.getVertexCoordPointer(i);
_min.minof(_min, vect);
_max.maxof(_max, vect);
}
// Scale enough ?
float max_width = std::max((float)fabs(_min.x), std::max((float)fabs(_min.y), (float)fabs(_min.z)));
max_width = std::max(max_width, std::max((float)fabs(_max.x), std::max((float)fabs(_max.y), (float)fabs(_max.z))));
_DecompactScale = std::max(_DecompactScale, max_width / 32767.f);
// Pack
for (i=0; i<numVertices; i++)
{
CPackedVertex &vertex = _PackedBuffer[i];
// Position
vertex.setPos (*vba.getVertexCoordPointer(i), _DecompactScale);
// Normal
vertex.setNormal (*vba.getNormalCoordPointer(i));
// UV
const float *uv = (const float*)vba.getTexCoordPointer(i, 0);
vertex.setUV (uv[0], uv[1]);
// Matrices
uint j;
sint weightSum = 0;
for (j=0; j<NL3D_MESH_MRM_SKINNED_MAX_MATRIX; j++)
{
vertex.Matrices[j] = (uint8)skinWeight[i].MatrixId[j];
vertex.setWeight (j, skinWeight[i].Weights[j]);
weightSum += (sint)vertex.Weights[j];
}
// Weight error
weightSum = 255 - weightSum;
// Add error to the first weight
nlassert ((sint)vertex.Weights[0] + weightSum <= 255);
nlassert ((sint)vertex.Weights[0] + weightSum > 0);
vertex.Weights[0] += weightSum;
}
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::getVertexBuffer(CVertexBuffer &output) const
{
output.setVertexFormat (CVertexBuffer::PositionFlag|CVertexBuffer::NormalFlag|CVertexBuffer::TexCoord0Flag);
const uint numVertices = _VBufferFinal.getNumVertices();
output.setNumVertices (numVertices);
// Set all UV routing on 0
uint i;
for (i=0; i<CVertexBuffer::MaxStage; i++)
output.setUVRouting (i, 0);
CVertexBufferReadWrite vba;
output.lock (vba);
const CPackedVertexBuffer::CPackedVertex *vertex = _VBufferFinal.getPackedVertices();
for (i=0; i<numVertices; i++)
{
_VBufferFinal.getPos(*vba.getVertexCoordPointer(i), vertex[i]);
vertex[i].getNormal(*vba.getNormalCoordPointer(i));
float *texCoord = (float*)vba.getTexCoordPointer(i,0);
vertex[i].getU(texCoord[0]);
vertex[i].getV(texCoord[1]);
}
}
// ***************************************************************************
void CMeshMRMSkinnedGeom::getSkinWeights (std::vector<CMesh::CSkinWeight> &skinWeights) const
{
const uint vertexCount = _VBufferFinal.getNumVertices();
skinWeights.resize (vertexCount);
const CPackedVertexBuffer::CPackedVertex *vertices = _VBufferFinal.getPackedVertices();
uint i;
for (i=0; i<vertexCount; i++)
{
const CPackedVertexBuffer::CPackedVertex &vertex = vertices[i];
uint j;
// Matrices
for (j=0; j<NL3D_MESH_MRM_SKINNED_MAX_MATRIX; j++)
{
skinWeights[i].MatrixId[j] = vertex.Matrices[j];
vertex.getWeight (skinWeights[i].Weights[j], j);
}
}
}
// ***************************************************************************
// ***************************************************************************
// CMatrix3x4SSE array correctly aligned
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
#define NL3D_SSE_ALIGNEMENT 16
/**
* A CMatrix3x4SSEArray array correctly aligned
* NB: SSE is no more used (no speed gain, some memory problem), but keep it for possible future usage.
*/
class CMatrix3x4SSEArray
{
private:
void *_AllocData;
void *_Data;
uint _Size;
uint _Capacity;
public:
CMatrix3x4SSEArray()
{
_AllocData= NULL;
_Data= NULL;
_Size= 0;
_Capacity= 0;
}
~CMatrix3x4SSEArray()
{
clear();
}
CMatrix3x4SSEArray(const CMatrix3x4SSEArray &other)
{
_AllocData= NULL;
_Data= NULL;
_Size= 0;
_Capacity= 0;
*this= other;
}
CMatrix3x4SSEArray &operator=(const CMatrix3x4SSEArray &other)
{
if( this == &other)
return *this;
resize(other.size());
// copy data from aligned pointers to aligned pointers.
memcpy(_Data, other._Data, size() * sizeof(CMatrix3x4SSE) );
return *this;
}
CMatrix3x4SSE *getPtr()
{
return (CMatrix3x4SSE*)_Data;
}
void clear()
{
delete [] ((uint8 *) _AllocData);
_AllocData= NULL;
_Data= NULL;
_Size= 0;
_Capacity= 0;
}
void resize(uint n)
{
// reserve ??
if(n>_Capacity)
reserve( max(2*_Capacity, n));
_Size= n;
}
void reserve(uint n)
{
if(n==0)
clear();
else if(n>_Capacity)
{
// Alloc new data.
void *newAllocData;
void *newData;
// Alloc for alignement.
newAllocData= new uint8 [n * sizeof(CMatrix3x4SSE) + NL3D_SSE_ALIGNEMENT-1];
if(newAllocData==NULL)
throw Exception("SSE Allocation Failed");
// Align ptr
newData= (void*) ( ((ptrdiff_t)newAllocData+NL3D_SSE_ALIGNEMENT-1) & (~(NL3D_SSE_ALIGNEMENT-1)) );
// copy valid data from old to new.
memcpy(newData, _Data, size() * sizeof(CMatrix3x4SSE) );
// release old.
if(_AllocData)
delete [] ((uint8*)_AllocData);
// change ptrs and capacity.
_Data= newData;
_AllocData= newAllocData;
_Capacity= n;
// TestYoyo
//nlwarning("YOYO Tst SSE P4: %X, %d", _Data, n);
}
}
uint size() const {return _Size;}
CMatrix3x4SSE &operator[](uint i) {return ((CMatrix3x4SSE*)_Data)[i];}
};
// ***************************************************************************
// ***************************************************************************
// Old school Template skinning: SSE or not.
// ***************************************************************************
// ***************************************************************************
// RawSkin Cache constants
//===============
// The number of byte to process per block
const uint NL_BlockByteL1= 4096;
// Number of vertices per block to process with 1 matrix.
uint CMeshMRMSkinnedGeom::NumCacheVertexNormal1= NL_BlockByteL1 / sizeof(CRawVertexNormalSkinned1);
// Number of vertices per block to process with 2 matrix.
uint CMeshMRMSkinnedGeom::NumCacheVertexNormal2= NL_BlockByteL1 / sizeof(CRawVertexNormalSkinned2);
// Number of vertices per block to process with 3 matrix.
uint CMeshMRMSkinnedGeom::NumCacheVertexNormal3= NL_BlockByteL1 / sizeof(CRawVertexNormalSkinned3);
// Number of vertices per block to process with 4 matrix.
uint CMeshMRMSkinnedGeom::NumCacheVertexNormal4= NL_BlockByteL1 / sizeof(CRawVertexNormalSkinned4);
/* Old School template: include the same file with define switching,
Was used before to reuse same code for and without SSE.
Useless now because SSE removed, but keep it for possible future work on it.
*/
#define ADD_MESH_MRM_SKINNED_TEMPLATE
#include "mesh_mrm_skinned_template.cpp"
} // NL3D
Reference in a new issue Copy permalink