aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-19 05:26:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/nel/src/3d/mesh_multi_lod.cpp

945 lines
28 KiB
C++
Raw Blame History

// 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_multi_lod.h"
#include "nel/3d/mesh_multi_lod_instance.h"
#include "nel/3d/mesh_instance.h"
#include "nel/3d/mesh_mrm.h"
#include "nel/3d/scene.h"
#include "nel/3d/coarse_mesh_manager.h"
#include "nel/3d/skeleton_model.h"
#include "nel/misc/fast_floor.h"
#include "nel/3d/mesh_blender.h"
#include "nel/3d/visual_collision_mesh.h"
#include "nel/misc/debug.h"
#include "nel/misc/hierarchical_timer.h"
using namespace NLMISC;
using namespace std;
namespace NL3D
{
// ***************************************************************************
void CMeshMultiLod::build(CMeshMultiLodBuild &mbuild)
{
// Clear the mesh
clear ();
// Build the base mesh
CMeshBase::buildMeshBase (mbuild.BaseMesh);
// Static flag
_StaticLod=mbuild.StaticLod;
// Resize the array
_MeshVector.resize (mbuild.LodMeshes.size());
// For each slots
for (uint slot=0; slot<mbuild.LodMeshes.size(); slot++)
{
// Dist max
_MeshVector[slot].DistMax=mbuild.LodMeshes[slot].DistMax;
// BlendLength
_MeshVector[slot].BlendLength=mbuild.LodMeshes[slot].BlendLength;
// Flags
_MeshVector[slot].Flags=0;
// Blend in ?
if (mbuild.LodMeshes[slot].Flags & CMeshMultiLodBuild::CBuildSlot::BlendIn)
_MeshVector[slot].Flags|=CMeshSlot::BlendIn;
// Blend out ?
if (mbuild.LodMeshes[slot].Flags & CMeshMultiLodBuild::CBuildSlot::BlendOut)
_MeshVector[slot].Flags|=CMeshSlot::BlendOut;
// Coarse mesh ?
if (mbuild.LodMeshes[slot].Flags & CMeshMultiLodBuild::CBuildSlot::CoarseMesh)
{
// Flag
_MeshVector[slot].Flags|=CMeshSlot::CoarseMesh;
}
// Is opaque
if (mbuild.LodMeshes[slot].Flags & CMeshMultiLodBuild::CBuildSlot::IsOpaque)
_MeshVector[slot].Flags|=CMeshSlot::IsOpaque;
// Is transparent
if (mbuild.LodMeshes[slot].Flags & CMeshMultiLodBuild::CBuildSlot::IsTransparent)
_MeshVector[slot].Flags|=CMeshSlot::IsTransparent;
// MeshGeom
nlassert (mbuild.LodMeshes[slot].MeshGeom);
// Valid pointer ?
if (_MeshVector[slot].Flags&CMeshSlot::CoarseMesh)
{
// If it is a coarse mesh, it must be a CMeshGeom.
if (dynamic_cast<CMeshGeom*>(mbuild.LodMeshes[slot].MeshGeom)==NULL)
{
// If it is a coarse mesh, it must be a CMeshGeom.
_MeshVector[slot].MeshGeom = NULL;
delete mbuild.LodMeshes[slot].MeshGeom;
}
else
// Ok, no prb
_MeshVector[slot].MeshGeom = mbuild.LodMeshes[slot].MeshGeom;
}
else
// Ok, no prb
_MeshVector[slot].MeshGeom = mbuild.LodMeshes[slot].MeshGeom;
}
// Sort the slot by the distance...
for (int i=(uint)mbuild.LodMeshes.size()-1; i>0; i--)
for (int j=0; j<i; j++)
{
// Bad sort ?
if (_MeshVector[j].DistMax>_MeshVector[j+1].DistMax)
{
// Exchange slots
CMeshSlot tmp=_MeshVector[j];
_MeshVector[j]=_MeshVector[j+1];
_MeshVector[j+1]=tmp;
tmp.MeshGeom=NULL;
}
}
// Calc start and end polygon count
for (uint k=0; k<mbuild.LodMeshes.size(); k++)
{
// Get start distance
float startDist;
if (k==0)
startDist=0;
else
startDist=_MeshVector[k-1].DistMax;
// Get start poly count
float startPolyCount;
startPolyCount=_MeshVector[k].MeshGeom->getNumTriangles (startDist);
// Get end distance
float endDist=_MeshVector[k].DistMax;
// Get end poly count
if (k==mbuild.LodMeshes.size()-1)
{
_MeshVector[k].EndPolygonCount=_MeshVector[k].MeshGeom->getNumTriangles (endDist);
if (startPolyCount==_MeshVector[k].EndPolygonCount)
_MeshVector[k].EndPolygonCount=startPolyCount/2;
}
else
_MeshVector[k].EndPolygonCount=_MeshVector[k+1].MeshGeom->getNumTriangles (endDist);
// Calc A
if (endDist==startDist)
_MeshVector[k].A=0;
else
_MeshVector[k].A=(_MeshVector[k].EndPolygonCount-startPolyCount)/(endDist-startDist);
// Calc A
_MeshVector[k].B=_MeshVector[k].EndPolygonCount-_MeshVector[k].A*endDist;
}
// End: compile some stuff
compileRunTime();
}
// ***************************************************************************
CTransformShape *CMeshMultiLod::createInstance(CScene &scene)
{
// Create a CMeshInstance, an instance of a multi lod mesh.
CMeshMultiLodInstance *mi=(CMeshMultiLodInstance*)scene.createModel(NL3D::MeshMultiLodInstanceId);
mi->Shape= this;
mi->_LastLodMatrixDate=0;
// instanciate the material part of the Mesh, ie the CMeshBase.
CMeshBase::instanciateMeshBase(mi, &scene);
// Create the necessary space for Coarse Instanciation
instanciateCoarseMeshSpace(mi);
// For all lods, do some instance init for MeshGeom
for(uint i=0; i<_MeshVector.size(); i++)
{
if(_MeshVector[i].MeshGeom)
_MeshVector[i].MeshGeom->initInstance(mi);
}
// init the Filter type
mi->initRenderFilterType();
return mi;
}
// ***************************************************************************
bool CMeshMultiLod::clip(const std::vector<CPlane> &pyramid, const CMatrix &worldMatrix)
{
// Look for the biggest mesh
uint meshCount=(uint)_MeshVector.size();
for (uint i=0; i<meshCount; i++)
{
// Ref on slot
CMeshSlot &slot=_MeshVector[i];
// Is mesh present ?
if (slot.MeshGeom)
{
// Clip this mesh
return slot.MeshGeom->clip (pyramid, worldMatrix);
}
}
return true;
}
// ***************************************************************************
void CMeshMultiLod::render(IDriver *drv, CTransformShape *trans, bool passOpaque)
{
// Render good meshes
CMeshMultiLodInstance *instance=safe_cast<CMeshMultiLodInstance*>(trans);
// Static or dynamic coarse mesh ?
CCoarseMeshManager *manager;
// Get the coarse mesh manager
manager=instance->getOwnerScene()->getCoarseMeshManager();
// *** Render Lods
// Second lod ?
if ( (instance->Lod1!=0xffffffff) && (passOpaque==false) )
{
// build rdrFlags to rdr both transparent and opaque materials,
// use globalAlphaBlend, and disable ZWrite for Lod1
uint32 rdrFlags= IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderTransparentMaterial |
IMeshGeom::RenderGlobalAlpha | IMeshGeom::RenderGADisableZWrite;
// NB: very important to render Lod1 first, because Lod0 is still rendered with ZWrite enabled.
renderMeshGeom (instance->Lod1, drv, instance, instance->PolygonCountLod1, rdrFlags, 1.f-instance->BlendFactor, manager);
}
// Have an opaque pass ?
if ( (instance->Flags&CMeshMultiLodInstance::Lod0Blend) == 0)
{
// Is this slot a CoarseMesh?
if ( _MeshVector[instance->Lod0].Flags&CMeshSlot::CoarseMesh )
{
// render as a CoarseMesh the lod 0, only in opaque pass
if(passOpaque)
renderCoarseMesh (instance->Lod0, drv, instance, manager);
}
else
{
// build rdrFlags the normal way (as CMesh::render() for example)
uint32 mask= (0-(uint32)passOpaque);
uint32 rdrFlags;
// select rdrFlags, without ifs.
rdrFlags= mask & (IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderPassOpaque);
rdrFlags|= ~mask & (IMeshGeom::RenderTransparentMaterial);
// Only render the normal way the first lod
renderMeshGeom (instance->Lod0, drv, instance, instance->PolygonCountLod0, rdrFlags, 1, manager);
}
}
else
{
// Should not be in opaque
nlassert (passOpaque==false);
// build rdrFlags to rdr both transparent and opaque materials,
// use globalAlphaBlend, BUT Don't disable ZWrite for Lod0
uint32 rdrFlags= IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderTransparentMaterial |
IMeshGeom::RenderGlobalAlpha;
// Render first lod in blend mode. Don't disable ZWrite for Lod0
renderMeshGeom (instance->Lod0, drv, instance, instance->PolygonCountLod0, rdrFlags, instance->BlendFactor, manager);
}
}
// ***************************************************************************
void CMeshMultiLod::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
* ***********************************************/
// Serial a version number
(void)f.serialVersion (0);
// serial Materials infos contained in CMeshBase.
CMeshBase::serialMeshBase(f);
// Static lod flag
f.serial (_StaticLod);
// Serial the values
f.serialCont (_MeshVector);
// if reading, compile some stuff
if (f.isReading())
compileRunTime();
}
// ***************************************************************************
float CMeshMultiLod::getNumTrianglesWithCoarsestDist(float distance, float coarsestMeshDist) const
{
// Look in the table for good distances..
uint meshCount=(uint)_MeshVector.size();
// At least on mesh
if (meshCount>0)
{
if (coarsestMeshDist != -1)
{
if (coarsestMeshDist != 0)
{
// rescale distance to new coarse mesh distance..
distance *= _MeshVector[meshCount - 1].DistMax / coarsestMeshDist;
}
}
uint i=0;
// Look for good i
while ( _MeshVector[i].DistMax < distance)
{
if (i==meshCount-1)
// Abort if last one
break;
i++;
}
// Ref on slot
const CMeshSlot &slot=_MeshVector[i];
// Is mesh present ?
if (slot.MeshGeom)
{
// Get the polygon count with the distance
float polyCount=slot.A * distance + slot.B;
/*// Get the perfect polygon count in this slot for the asked distance
float goodPolyCount=slot.MeshGeom->getNumTriangles (distance);
// Get the next slot perfect polygon count
float realEndPolyCount;
// Last slot ?
if ( (i<meshCount-1) && _MeshVector[i+1].MeshGeom )
// Take end number polygon count in the next slot
realEndPolyCount=_MeshVector[i+1].MeshGeom->getNumTriangles (slot.DistMax);
else
// Take end number polygon count in the this slot
realEndPolyCount=slot.EndPolygonCount;
// Return blended polygon count to have a continous decreasing function
return (goodPolyCount-slot.BeginPolygonCount) * (realEndPolyCount-slot.BeginPolygonCount) /
(slot.EndPolygonCount-slot.BeginPolygonCount) + slot.BeginPolygonCount;*/
return polyCount;
}
}
return 0;
}
// ***************************************************************************
void CMeshMultiLod::getAABBox(NLMISC::CAABBox &bbox) const
{
// Get count
uint count=(uint)_MeshVector.size();
for (uint slot=0; slot<count; slot++)
{
// Shape ?
if (_MeshVector[slot].MeshGeom)
{
// Get the bounding box
bbox=_MeshVector[slot].MeshGeom->getBoundingBox().getAABBox();
// ok
break;
}
}
}
// ***************************************************************************
void CMeshMultiLod::clear ()
{
_MeshVector.clear ();
}
// ***************************************************************************
void CMeshMultiLod::CMeshSlot::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
// Check version
(void)f.serialVersion (0);
f.serialPolyPtr (MeshGeom);
f.serial (A);
f.serial (B);
f.serial (DistMax);
f.serial (EndPolygonCount);
f.serial (BlendLength);
f.serial (Flags);
if (f.isReading())
{
}
}
// ***************************************************************************
CMeshMultiLod::CMeshSlot::CMeshSlot ()
{
MeshGeom=NULL;
CoarseNumTris= 0;
}
// ***************************************************************************
CMeshMultiLod::CMeshSlot::~CMeshSlot ()
{
if (MeshGeom)
delete MeshGeom;
}
// ***************************************************************************
void CMeshMultiLod::renderMeshGeom (uint slot, IDriver *drv, CMeshMultiLodInstance *trans, float numPoylgons, uint32 rdrFlags, float alpha, CCoarseMeshManager *manager)
{
// Ref
CMeshSlot &slotRef=_MeshVector[slot];
// MeshGeom exist?
if (slotRef.MeshGeom)
{
// NB Here, the meshGeom may still be a coarseMesh, but rendered through CMeshGeom
if(slotRef.Flags&CMeshSlot::CoarseMesh)
{
// Render only for opaque material
if(manager && (rdrFlags & IMeshGeom::RenderOpaqueMaterial) )
{
bool gaDisableZWrite= (rdrFlags & IMeshGeom::RenderGADisableZWrite)?true:false;
// Render the CoarseMesh with the manager material
CMaterial &material= manager->getMaterial();
// modulate material for alphaBlend transition
// ----------
// get average sun color for this coarseMesh
CRGBA newCol= trans->getCoarseMeshLighting();
// Use a CMeshBlender to modify material and driver.
CMeshBlender blender;
blender.prepareRenderForGlobalAlphaCoarseMesh(material, drv, newCol, alpha, gaDisableZWrite);
// render simple the coarseMesh
CMeshGeom *meshGeom= safe_cast<CMeshGeom*>(slotRef.MeshGeom);
// Force corse mesh vertex buffer in system memory
const_cast<CVertexBuffer&>(meshGeom->getVertexBuffer ()).setPreferredMemory (CVertexBuffer::RAMPreferred, false);
meshGeom->renderSimpleWithMaterial(drv, trans->getWorldMatrix(), material);
// resetup standard CoarseMeshMaterial material values
// ----------
// blender restore
blender.restoreRenderCoarseMesh(material, drv, gaDisableZWrite);
}
}
else
{
// Render the geom mesh
// Disable ZWrite only if in transition and for rendering Lod1
slotRef.MeshGeom->render (drv, trans, numPoylgons, rdrFlags, alpha);
}
}
}
// ***************************************************************************
void CMeshMultiLod::renderCoarseMesh (uint slot, IDriver *drv, CMeshMultiLodInstance *trans, CCoarseMeshManager *manager)
{
// if the manager is NULL, quit.
if(manager==NULL)
return;
// get the scene
CScene *scene= trans->getOwnerScene();
if(!scene)
return;
// If filtered...
if( (scene->getFilterRenderFlags() & UScene::FilterCoarseMesh)==0 )
return;
// Ref
CMeshSlot &slotRef=_MeshVector[slot];
// the slot must be a Coarse mesh
nlassert(slotRef.Flags&CMeshSlot::CoarseMesh);
// Get a pointer on the geom mesh
CMeshGeom *meshGeom= safe_cast<CMeshGeom*>(slotRef.MeshGeom);
// ** If not the same as Before (or if NULL before...)
if ( trans->_LastCoarseMesh!=meshGeom )
{
uint numVerts= meshGeom->getVertexBuffer().getNumVertices();
uint numTris= slotRef.CoarseNumTris;
// If empty meshGeom, erase cache (each frame, ugly but error mgt here...)
if( numTris==0 || numVerts==0 )
trans->_LastCoarseMesh= NULL;
else
{
// Cache
trans->_LastCoarseMesh= meshGeom;
trans->_LastCoarseMeshNumVertices= numVerts;
// Check setuped size.
nlassert( trans->_CoarseMeshVB.size() >= numVerts*manager->getVertexSize() );
// Fill only UVs here. (Pos updated in Matrix pass. Color in Lighting Pass)
trans->setUVCoarseMesh( *meshGeom, manager->getVertexSize(), manager->getUVOff() );
// Dirt the matrix
trans->_LastLodMatrixDate=0;
// Dirt the lighting. NB: period maximum is 255. Hence the -256, to ensure lighting compute now
trans->_LastLodLightingDate= -0x100;
}
}
// ** If setuped, update and render
if( trans->_LastCoarseMesh )
{
// Matrix has changed ?
if ( trans->ITransformable::compareMatrixDate (trans->_LastLodMatrixDate) )
{
// Get date
trans->_LastLodMatrixDate = trans->ITransformable::getMatrixDate();
// Set matrix
trans->setPosCoarseMesh ( *meshGeom, trans->getMatrix(), manager->getVertexSize() );
}
// Lighting: test if must update lighting, according to date of HrcTrav (num of CScene::render() call).
sint64 currentDate= scene->getHrcTrav().CurrentDate;
if( trans->_LastLodLightingDate < currentDate - scene->getCoarseMeshLightingUpdate() )
{
// reset the date.
trans->_LastLodLightingDate= currentDate;
// get average sun color
CRGBA sunContrib= trans->getCoarseMeshLighting();
// Invert BR if driver is BGRA
if(drv->getVertexColorFormat()==CVertexBuffer::TBGRA)
sunContrib.swapBR();
// Set color
trans->setColorCoarseMesh ( sunContrib, manager->getVertexSize(), manager->getColorOff());
}
// Add dynamic to the manager
if( !manager->addMesh(trans->_LastCoarseMeshNumVertices, &trans->_CoarseMeshVB[0], slotRef.CoarseNumTris, &slotRef.CoarseTriangles[0] ) )
{
// If failure, flush the manager
manager->flushRender(drv);
// then try to re-add. No-op if fails this time..
manager->addMesh(trans->_LastCoarseMeshNumVertices, &trans->_CoarseMeshVB[0], slotRef.CoarseNumTris, &slotRef.CoarseTriangles[0] );
}
}
}
// ***************************************************************************
void CMeshMultiLod::compileDistMax()
{
// Last element
if(_MeshVector.empty())
IShape::_DistMax= -1;
else
IShape::_DistMax= _MeshVector.back().DistMax;
}
// ***************************************************************************
const IMeshGeom& CMeshMultiLod::getMeshGeom (uint slot) const
{
// Checks
nlassert (slot<getNumSlotMesh ());
return *_MeshVector[slot].MeshGeom;
}
// ***************************************************************************
void CMeshMultiLod::changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest)
{
// no-op if empty.
if(getNumSlotMesh ()==0)
return;
// If not NULL
if(_MeshVector[0].MeshGeom==NULL)
return;
// verify it is a CMeshMRMGeom. else no-op.
CMeshMRMGeom *mgeom= dynamic_cast<CMeshMRMGeom*>(_MeshVector[0].MeshGeom);
if(mgeom==NULL)
return;
// ok, setup.
mgeom->changeMRMDistanceSetup(distanceFinest, distanceMiddle, distanceCoarsest);
}
// ***************************************************************************
IMeshGeom *CMeshMultiLod::supportMeshBlockRendering (CTransformShape *trans, float &polygonCount ) const
{
IMeshGeom *ret= NULL;
// get the instance
CMeshMultiLodInstance *instance=safe_cast<CMeshMultiLodInstance*>(trans);
// Must not be in blend transition.
if ( (instance->Flags&CMeshMultiLodInstance::Lod0Blend) == 0)
{
uint slot= instance->Lod0;
// The slot must not be a CoarseMesh
if ( (_MeshVector[slot].Flags&CMeshSlot::CoarseMesh)==0 )
{
// MeshGeom exist?
ret= _MeshVector[slot].MeshGeom;
}
}
// Ok if meshGeom is ok.
if( ret && ret->supportMeshBlockRendering() )
{
polygonCount= instance->PolygonCountLod0;
return ret;
}
else
return NULL;
}
// ***************************************************************************
void CMeshMultiLod::profileMeshGeom (uint slot, CRenderTrav *rdrTrav, CMeshMultiLodInstance *trans, float numPoylgons, uint32 rdrFlags)
{
// Ref
CMeshSlot &slotRef=_MeshVector[slot];
// MeshGeom exist?
if (slotRef.MeshGeom)
{
// NB Here, the meshGeom may still be a coarseMesh, but rendered through CMeshGeom
if(slotRef.Flags&CMeshSlot::CoarseMesh)
{
// Render only for opaque material
if(rdrFlags & IMeshGeom::RenderOpaqueMaterial)
{
slotRef.MeshGeom->profileSceneRender(rdrTrav, trans, numPoylgons, rdrFlags);
}
}
else
{
slotRef.MeshGeom->profileSceneRender(rdrTrav, trans, numPoylgons, rdrFlags);
}
}
}
// ***************************************************************************
void CMeshMultiLod::profileSceneRender(CRenderTrav *rdrTrav, CTransformShape *trans, bool passOpaque)
{
// Render good meshes
CMeshMultiLodInstance *instance=safe_cast<CMeshMultiLodInstance*>(trans);
// Second lod ?
if ( (instance->Lod1!=0xffffffff) && (passOpaque==false) )
{
// build rdrFlags to rdr both transparent and opaque materials,
// use globalAlphaBlend, and disable ZWrite for Lod1
uint32 rdrFlags= IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderTransparentMaterial |
IMeshGeom::RenderGlobalAlpha | IMeshGeom::RenderGADisableZWrite;
// NB: very important to render Lod1 first, because Lod0 is still rendered with ZWrite enabled.
profileMeshGeom (instance->Lod1, rdrTrav, instance, instance->PolygonCountLod1, rdrFlags);
}
// Have an opaque pass ?
if ( (instance->Flags&CMeshMultiLodInstance::Lod0Blend) == 0)
{
// Is this slot a CoarseMesh?
if ( _MeshVector[instance->Lod0].Flags&CMeshSlot::CoarseMesh )
{
}
else
{
// build rdrFlags the normal way (as CMesh::render() for example)
uint32 mask= (0-(uint32)passOpaque);
uint32 rdrFlags;
// select rdrFlags, without ifs.
rdrFlags= mask & (IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderPassOpaque);
rdrFlags|= ~mask & (IMeshGeom::RenderTransparentMaterial);
// Only render the normal way the first lod
profileMeshGeom (instance->Lod0, rdrTrav, instance, instance->PolygonCountLod0, rdrFlags);
}
}
else
{
// Should not be in opaque
nlassert (passOpaque==false);
// build rdrFlags to rdr both transparent and opaque materials,
// use globalAlphaBlend, BUT Don't disable ZWrite for Lod0
uint32 rdrFlags= IMeshGeom::RenderOpaqueMaterial | IMeshGeom::RenderTransparentMaterial |
IMeshGeom::RenderGlobalAlpha;
// Render first lod in blend mode. Don't disable ZWrite for Lod0
profileMeshGeom (instance->Lod0, rdrTrav, instance, instance->PolygonCountLod0, rdrFlags);
}
}
// ***************************************************************************
void CMeshMultiLod::instanciateCoarseMeshSpace(CMeshMultiLodInstance *mi)
{
CCoarseMeshManager *manager= mi->getOwnerScene()->getCoarseMeshManager();
if(manager)
{
// For all MeshSlots that have a CoarseMesh, count max Coarse NumVertices;
uint numVertices= 0;
for(uint i=0;i<_MeshVector.size();i++)
{
CMeshSlot &slotRef= _MeshVector[i];
if( slotRef.Flags & CMeshSlot::CoarseMesh )
{
// Get a pointer on the geom mesh
CMeshGeom *meshGeom= safe_cast<CMeshGeom*>(slotRef.MeshGeom);
numVertices= max(numVertices, (uint)meshGeom->getVertexBuffer().getNumVertices() );
}
}
// Then allocate vertex space for dest manager vertex size.
mi->_CoarseMeshVB.resize( numVertices*manager->getVertexSize() );
}
}
// ***************************************************************************
void CMeshMultiLod::compileCoarseMeshes()
{
// For All Slots that are CoarseMeshes.
for(uint i=0;i<_MeshVector.size();i++)
{
CMeshSlot &slotRef= _MeshVector[i];
if( slotRef.Flags & CMeshSlot::CoarseMesh )
{
// reset
slotRef.CoarseNumTris= 0;
// Get a pointer on the geom mesh
CMeshGeom *meshGeom= safe_cast<CMeshGeom*>(slotRef.MeshGeom);
// For All RdrPass of the 1st matrix block
if( meshGeom->getNbMatrixBlock()>0 )
{
// 1st count
for(uint i=0;i<meshGeom->getNbRdrPass(0);i++)
{
slotRef.CoarseNumTris+= meshGeom->getRdrPassPrimitiveBlock(0, i).getNumIndexes()/3;
}
// 2nd allocate and fill
if( slotRef.CoarseNumTris )
{
slotRef.CoarseTriangles.resize(slotRef.CoarseNumTris * 3);
TCoarseMeshIndexType *dstPtr= &slotRef.CoarseTriangles[0];
for(uint i=0;i<meshGeom->getNbRdrPass(0);i++)
{
const CIndexBuffer &pb= meshGeom->getRdrPassPrimitiveBlock(0, i);
CIndexBufferRead ibaRead;
pb.lock (ibaRead);
uint numTris= pb.getNumIndexes()/3;
if (pb.getFormat() == CIndexBuffer::Indices16)
{
if (sizeof(TCoarseMeshIndexType) == sizeof(uint16))
{
memcpy(dstPtr, (uint16 *) ibaRead.getPtr(), numTris*3*sizeof(uint16));
}
else
{
// 16 -> 32
uint16 *src = (uint16 *) ibaRead.getPtr();
for(uint k = 0; k < numTris; ++k)
{
*dstPtr++ = (TCoarseMeshIndexType) *src++;
*dstPtr++ = (TCoarseMeshIndexType) *src++;
*dstPtr++ = (TCoarseMeshIndexType) *src++;
}
}
}
else
{
if (sizeof(TCoarseMeshIndexType) == sizeof(uint32))
{
memcpy(dstPtr, (uint32 *) ibaRead.getPtr(), numTris*3*sizeof(uint32));
}
else
{
const uint32 *src = (const uint32 *) ibaRead.getPtr();
for(uint k = 0; k < numTris; ++k)
{
// 32 -> 16
nlassert(src[0] <= 0xffff);
nlassert(src[1] <= 0xffff);
nlassert(src[2] <= 0xffff);
*dstPtr++ = (TCoarseMeshIndexType) *src++;
*dstPtr++ = (TCoarseMeshIndexType) *src++;
*dstPtr++ = (TCoarseMeshIndexType) *src++;
}
}
}
dstPtr+= numTris*3;
}
}
}
}
}
}
// ***************************************************************************
void CMeshMultiLod::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
* ***********************************************/
// **** MultiLod basics
compileDistMax();
compileCoarseMeshes();
// **** 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 )
{
// try to retrieve the info from a CMeshGeom only
if(getNumSlotMesh())
{
const CMeshGeom *meshGeom= dynamic_cast<const CMeshGeom*>(&getMeshGeom(0));
if(meshGeom)
{
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 CMeshMultiLod::buildSystemGeometry()
{
// clear any
_SystemGeometry.clear();
// Use the first lod, for system geometry copy
if(getNumSlotMesh())
{
// the first is a meshGeom?
const CMeshGeom *meshGeom= dynamic_cast<const CMeshGeom*>(&getMeshGeom(0));
if(meshGeom)
{
// retrieve geometry (if VB/IB not resident)
if( !meshGeom->retrieveVertices(_SystemGeometry.Vertices) ||
!meshGeom->retrieveTriangles(_SystemGeometry.Triangles))
{
_SystemGeometry.clear();
}
}
// else it is a mrm geom?
else
{
const CMeshMRMGeom *meshMRMGeom= dynamic_cast<const CMeshMRMGeom*>(&getMeshGeom(0));
if(meshMRMGeom)
{
// Choose the best Lod available for system geometry
if(meshMRMGeom->getNbLodLoaded()==0)
return;
uint lodId= meshMRMGeom->getNbLodLoaded()-1;
// retrieve geometry (if VB/IB not resident)
if( !meshMRMGeom->buildGeometryForLod(lodId, _SystemGeometry.Vertices, _SystemGeometry.Triangles) )
{
_SystemGeometry.clear();
}
}
}
}
// TestYoyo
/*static uint32 totalMem= 0;
totalMem+= _SystemGeometry.Vertices.size()*sizeof(CVector);
totalMem+= _SystemGeometry.Triangles.size()*sizeof(uint32);
nlinfo("CMeshMultiLod: TotalMem: %d", totalMem);*/
}
} // NL3D
Reference in a new issue View git blame Copy permalink