mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-24 16:16:14 +00:00
564 lines
17 KiB
C++
564 lines
17 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "std3d.h"
|
|
|
|
#include "nel/3d/mesh_base_instance.h"
|
|
#include "nel/3d/mesh_base.h"
|
|
#include "nel/3d/scene.h"
|
|
#include "nel/3d/animation.h"
|
|
#include "nel/misc/debug.h"
|
|
#include "nel/3d/anim_detail_trav.h"
|
|
#include "nel/3d/texture_file.h"
|
|
#include "nel/3d/async_texture_manager.h"
|
|
|
|
#include <limits>
|
|
|
|
using namespace NLMISC;
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
|
|
// ***************************************************************************
|
|
CMeshBaseInstance::CMeshBaseInstance()
|
|
{
|
|
IAnimatable::resize(AnimValueLast);
|
|
_AsyncTextureToLoadRefCount= 0;
|
|
_AsyncTextureMode= false;
|
|
_AsyncTextureReady= true;
|
|
_AsyncTextureDirty= false;
|
|
_AsyncTextureDistance= 0;
|
|
_VPWindTreeFixed = false;
|
|
|
|
// I am a CMeshBaseInstance!!
|
|
CTransform::setIsMeshBaseInstance(true);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
CMeshBaseInstance::~CMeshBaseInstance()
|
|
{
|
|
// If AsyncTextureMode, must disable. This ensure that async loading stop, and that no ref still exist
|
|
// in the AsyncTextureManager
|
|
if(_AsyncTextureMode)
|
|
enableAsyncTextureMode(false);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::registerBasic()
|
|
{
|
|
CScene::registerModel(MeshBaseInstanceId, TransformShapeId, CMeshBaseInstance::creator);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix)
|
|
{
|
|
uint32 i;
|
|
CTransformShape::registerToChannelMixer(chanMixer, prefix);
|
|
|
|
// Add any materials.
|
|
for (i = 0; i < _AnimatedMaterials.size(); i++)
|
|
{
|
|
// append material matname.*
|
|
_AnimatedMaterials[i].registerToChannelMixer(chanMixer, prefix + _AnimatedMaterials[i].getMaterialName() + ".");
|
|
}
|
|
|
|
// Add any morph
|
|
for (i = 0; i < _AnimatedMorphFactor.size(); i++)
|
|
{
|
|
_AnimatedMorphFactor[i].registerToChannelMixer(chanMixer, prefix + _AnimatedMorphFactor[i].getName());
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
ITrack* CMeshBaseInstance::getDefaultTrack (uint valueId)
|
|
{
|
|
// Pointer on the CMeshBase
|
|
CMeshBase* pMesh=(CMeshBase*)(IShape*)Shape;
|
|
|
|
// Switch the value
|
|
switch (valueId)
|
|
{
|
|
case CTransform::PosValue:
|
|
return pMesh->getDefaultPos();
|
|
case CTransform::RotEulerValue:
|
|
return pMesh->getDefaultRotEuler();
|
|
case CTransform::RotQuatValue:
|
|
return pMesh->getDefaultRotQuat();
|
|
case CTransform::ScaleValue:
|
|
return pMesh->getDefaultScale();
|
|
case CTransform::PivotValue:
|
|
return pMesh->getDefaultPivot();
|
|
default:
|
|
// Problem, new values ?
|
|
nlstop;
|
|
};
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
uint32 CMeshBaseInstance::getNbLightMap()
|
|
{
|
|
CMeshBase* pMesh=(CMeshBase*)(IShape*)Shape;
|
|
return (uint32)pMesh->_LightInfos.size();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::getLightMapName( uint32 nLightMapNb, std::string &LightMapName )
|
|
{
|
|
CMeshBase* pMesh=(CMeshBase*)(IShape*)Shape;
|
|
if( nLightMapNb >= pMesh->_LightInfos.size() )
|
|
return;
|
|
LightMapName = pMesh->_LightInfos[nLightMapNb].AnimatedLight;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
uint32 CMeshBaseInstance::getNbBlendShape()
|
|
{
|
|
return (uint32)_AnimatedMorphFactor.size();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::getBlendShapeName (uint32 nBlendShapeNb, std::string &BlendShapeName )
|
|
{
|
|
if (nBlendShapeNb >= _AnimatedMorphFactor.size())
|
|
return;
|
|
BlendShapeName = _AnimatedMorphFactor[nBlendShapeNb].getName();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::setBlendShapeFactor (const std::string &BlendShapeName, float rFactor)
|
|
{
|
|
for (uint32 i = 0; i < _AnimatedMorphFactor.size(); ++i)
|
|
if (BlendShapeName == _AnimatedMorphFactor[i].getName())
|
|
{
|
|
_AnimatedMorphFactor[i].setFactor (rFactor);
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::traverseHrc()
|
|
{
|
|
CMeshBase *mb = NLMISC::safe_cast<CMeshBase *>((IShape *) Shape);
|
|
|
|
// if the base instance uses automatic animations, we must also setup the date of the channel mixer controlling this object
|
|
if (mb->getAutoAnim())
|
|
{
|
|
// Unfreeze HRC for those models
|
|
CTransform *node = this;
|
|
while (node)
|
|
{
|
|
node->unfreezeHRC();
|
|
node = node->hrcGetParent();
|
|
}
|
|
|
|
// setup the channel mixer date
|
|
CChannelMixer *chanMix = getChannelMixer();
|
|
if (chanMix)
|
|
{
|
|
const CAnimation *anim = chanMix->getSlotAnimation(0);
|
|
/** We perform wrapping ourselves.
|
|
* We avoid using a playlist, to not create one more obj.
|
|
*/
|
|
if (anim)
|
|
{
|
|
// Animation offset are setuped before clipping, they will be used for detail too.
|
|
float animLength = anim->getEndTime() - anim->getBeginTime();
|
|
if (animLength > 0)
|
|
{
|
|
float currTime = (TAnimationTime) getOwnerScene()->getCurrentTime();
|
|
float startTime = (uint) (currTime / animLength) * animLength;
|
|
// Set the channel mixer date using the global date of the scene
|
|
chanMix->setSlotTime(0, anim->getBeginTime() + currTime - startTime);
|
|
}
|
|
else
|
|
{
|
|
chanMix->setSlotTime(0, anim->getBeginTime());
|
|
}
|
|
|
|
/** Eval non detail animation
|
|
*/
|
|
chanMix->eval(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
CTransformShape::traverseHrc();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::traverseAnimDetail()
|
|
{
|
|
CMeshBase *mb = NLMISC::safe_cast<CMeshBase *>((IShape *) Shape);
|
|
|
|
CTransformShape::traverseAnimDetail();
|
|
|
|
|
|
// update animated materials.
|
|
// test if animated materials must be updated.
|
|
if(IAnimatable::isTouched(CMeshBaseInstance::OwnerBit))
|
|
{
|
|
// must test / update all AnimatedMaterials.
|
|
for(uint i=0;i<_AnimatedMaterials.size();i++)
|
|
{
|
|
// This test and update the pointed material.
|
|
_AnimatedMaterials[i].update();
|
|
}
|
|
|
|
IAnimatable::clearFlag(CMeshBaseInstance::OwnerBit);
|
|
}
|
|
|
|
// Lightmap automatic animation
|
|
|
|
// Animated lightmap must have the same size than shape info lightmap.
|
|
const uint count0 = (uint)_AnimatedLightmap.size();
|
|
const uint count1 = (uint)mb->_LightInfos.size ();
|
|
nlassert (count0 == count1);
|
|
if (count0 == count1)
|
|
{
|
|
for ( uint i = 0; i < count0; ++i )
|
|
{
|
|
CMeshBase::CLightMapInfoList &groupInfo = mb->_LightInfos[i];
|
|
std::list<CMeshBase::CLightMapInfoList::CMatStage>::iterator ite = groupInfo.StageList.begin ();
|
|
while (ite != groupInfo.StageList.end ())
|
|
{
|
|
sint animatedLightmap = _AnimatedLightmap[i];
|
|
if (animatedLightmap != -1)
|
|
{
|
|
CRGBA factor = getOwnerScene ()->getAnimatedLightFactor (animatedLightmap, groupInfo.LightGroup);
|
|
Materials[ite->MatId].setLightMapFactor ( ite->StageId, factor );
|
|
}
|
|
else
|
|
{
|
|
CRGBA factor = getOwnerScene ()->getLightmapGroupColor (groupInfo.LightGroup);
|
|
Materials[ite->MatId].setLightMapFactor ( ite->StageId, factor );
|
|
}
|
|
ite++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::selectTextureSet(uint id)
|
|
{
|
|
nlassert(Shape);
|
|
CMeshBase *mb = NLMISC::safe_cast<CMeshBase *>((IShape *) Shape);
|
|
const uint numMat = mb->getNbMaterial();
|
|
nlassert(numMat == Materials.size());
|
|
// see which material are selectable
|
|
for(uint k = 0; k < numMat; ++k)
|
|
{
|
|
CMaterial &mat = mb->getMaterial(k);
|
|
for(uint l = 0; l < IDRV_MAT_MAXTEXTURES; ++l)
|
|
{
|
|
if (mat.getTexture(uint8(l)) && mat.getTexture(uint8(l))->isSelectable())
|
|
{
|
|
// use a smartPtr so the textFile will be released if just used to set the name for AsyncTextures.
|
|
CSmartPtr<ITexture> texNSV= mat.getTexture(uint8(l))->buildNonSelectableVersion(id);
|
|
|
|
// std case: just replace the texture.
|
|
if(!_AsyncTextureMode)
|
|
{
|
|
Materials[k].setTexture(uint8(l), texNSV);
|
|
}
|
|
// Async case
|
|
else
|
|
{
|
|
// If texture file, must copy the texture name
|
|
if(AsyncTextures[k].IsTextureFile[l])
|
|
{
|
|
CTextureFile *textFile= safe_cast<CTextureFile*>((ITexture*)texNSV);
|
|
AsyncTextures[k].TextureNames[l]= textFile->getFileName();
|
|
}
|
|
// else replace the texture.
|
|
else
|
|
Materials[k].setTexture(uint8(l), texNSV);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Flag the instance as AsyncTextureDirty if in this mode
|
|
if(_AsyncTextureMode)
|
|
{
|
|
setAsyncTextureDirty(true);
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::initAnimatedLightIndex (const CScene &scene)
|
|
{
|
|
/* Scan lightmaps used by the shape, and for each, bind the transform shape to an
|
|
* animated lightmap index from the scene. This index will be used at runtime to
|
|
* get quickly a lightmap factor. This index is not set in the CShape because
|
|
* the CShape can be used with several CScene.
|
|
*/
|
|
|
|
// For each lightmap in the shape
|
|
CMeshBase *pMB = static_cast<CMeshBase*> (static_cast<IShape*> (Shape));
|
|
const uint count = (uint)pMB->_LightInfos.size ();
|
|
uint i;
|
|
|
|
// Resize the index array
|
|
_AnimatedLightmap.resize (count);
|
|
|
|
for (i=0; i<count; i++)
|
|
{
|
|
// The light info
|
|
CMeshBase::CLightMapInfoList &lightInfo = pMB->_LightInfos[i];
|
|
|
|
// Get the lightmap info
|
|
_AnimatedLightmap[i] = scene.getAnimatedLightNameToIndex (lightInfo.AnimatedLight);
|
|
}
|
|
|
|
// Must be traversed in AnimDetail, even if no channel mixer registered
|
|
CTransform::setIsForceAnimDetail (count != 0);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
uint CMeshBaseInstance::getNumMaterial () const
|
|
{
|
|
return (uint)Materials.size ();
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
const CMaterial *CMeshBaseInstance::getMaterial (uint materialId) const
|
|
{
|
|
return &(Materials[materialId]);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CMaterial *CMeshBaseInstance::getMaterial (uint materialId)
|
|
{
|
|
return &(Materials[materialId]);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CMeshBaseInstance::fastIntersect(const NLMISC::CVector &p0, const NLMISC::CVector &dir, float &dist2D, float &distZ, bool computeDist2D)
|
|
{
|
|
if(!Shape || !supportFastIntersect())
|
|
return false;
|
|
|
|
// Use the system geometry to test the intersection
|
|
CMeshBase *pMB = static_cast<CMeshBase*> (static_cast<IShape*> (Shape));
|
|
return pMB->getSystemGeometry().fastIntersect(getWorldMatrix(), p0, dir, dist2D, distZ, computeDist2D);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
// Async texture loading
|
|
// ***************************************************************************
|
|
// ***************************************************************************
|
|
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::enableAsyncTextureMode(bool enable)
|
|
{
|
|
// if same, no-op.
|
|
if(_AsyncTextureMode==enable)
|
|
return;
|
|
_AsyncTextureMode= enable;
|
|
|
|
// if comes to async texture mode, must prepare AsyncTexturing
|
|
if(_AsyncTextureMode)
|
|
{
|
|
_AsyncTextureReady= true;
|
|
|
|
// For all TextureFiles in material
|
|
for(uint i=0;i<Materials.size();i++)
|
|
{
|
|
for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
|
|
{
|
|
// test if really a CTextureFile
|
|
CTextureFile *text= dynamic_cast<CTextureFile*>(Materials[i].getTexture(uint8(stage)));
|
|
if(text)
|
|
{
|
|
// Must setup the AsyncTextures
|
|
AsyncTextures[i].IsTextureFile[stage]= true;
|
|
AsyncTextures[i].TextureNames[stage]= text->getFileName();
|
|
AsyncTextures[i].TextIds[stage]= std::numeric_limits<uint>::max();
|
|
// Now, must copy the textureFile, to Avoid writing in CMeshBase TextureFile descriptor !!!
|
|
CTextureFile *tf = new CTextureFile(*text);
|
|
// setup a dummy texture => Instance won't block rendering because texture not yet ready
|
|
tf->setFileName("blank.tga");
|
|
Materials[i].setTexture(uint8(stage), tf);
|
|
}
|
|
else
|
|
{
|
|
AsyncTextures[i].IsTextureFile[stage]= false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// For convenience, flag the instance as Dirty.
|
|
setAsyncTextureDirty(true);
|
|
}
|
|
// else, AsyncTextureMode disabled
|
|
else
|
|
{
|
|
// first, must stop and release all textures in the async manager.
|
|
releaseCurrentAsyncTextures();
|
|
nlassert(_AsyncTextureToLoadRefCount==0);
|
|
// clear the array => ensure good work if enableAsyncTextureMode(true) is made later
|
|
contReset(_CurrentAsyncTextures);
|
|
|
|
// For all TextureFiles in material, copy User setup from AsyncTextures, to real fileName
|
|
for(uint i=0;i<Materials.size();i++)
|
|
{
|
|
for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
|
|
{
|
|
// if an async texture file
|
|
if(AsyncTextures[i].IsTextureFile[stage])
|
|
{
|
|
// copy the texture name into the texture file.
|
|
CTextureFile *text= safe_cast<CTextureFile*>(Materials[i].getTexture(uint8(stage)));
|
|
text->setFileName(AsyncTextures[i].TextureNames[stage]);
|
|
// clear string space
|
|
AsyncTextures[i].TextureNames[stage].clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::startAsyncTextureLoading(const NLMISC::CVector &position)
|
|
{
|
|
if(!getAsyncTextureMode())
|
|
return;
|
|
|
|
// If the async texutre manager is not setuped in the scene, abort.
|
|
CAsyncTextureManager *asyncTextMgr= getOwnerScene()->getAsyncTextureManager();
|
|
if(!asyncTextMgr)
|
|
return;
|
|
|
|
uint i;
|
|
|
|
|
|
/* for all new texture names to load, add them to the manager
|
|
NB: done first before release because of RefCount Management (in case of same texture name).
|
|
*/
|
|
for(i=0;i<AsyncTextures.size();i++)
|
|
{
|
|
for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
|
|
{
|
|
if(AsyncTextures[i].IsTextureFile[stage])
|
|
{
|
|
uint id;
|
|
id= asyncTextMgr->addTextureRef(AsyncTextures[i].TextureNames[stage], this, position);
|
|
AsyncTextures[i].TextIds[stage]= id;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* For all old textures (0 for the first time...), release them.
|
|
*/
|
|
releaseCurrentAsyncTextures();
|
|
|
|
// OK! bkup the setup
|
|
_CurrentAsyncTextures= AsyncTextures;
|
|
|
|
// texture async is not ready.
|
|
_AsyncTextureReady= false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CMeshBaseInstance::releaseCurrentAsyncTextures()
|
|
{
|
|
// If the async texutre manager is not setuped in the scene, abort.
|
|
CAsyncTextureManager *asyncTextMgr= getOwnerScene()->getAsyncTextureManager();
|
|
if(!asyncTextMgr)
|
|
return;
|
|
|
|
// release all texture in the manager
|
|
for(uint i=0;i<_CurrentAsyncTextures.size();i++)
|
|
{
|
|
for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
|
|
{
|
|
if(_CurrentAsyncTextures[i].IsTextureFile[stage])
|
|
{
|
|
asyncTextMgr->releaseTexture(_CurrentAsyncTextures[i].TextIds[stage], this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CMeshBaseInstance::isAsyncTextureReady()
|
|
{
|
|
// if ok, just quit
|
|
if(_AsyncTextureReady)
|
|
return true;
|
|
|
|
// test if async loading ended
|
|
if(_AsyncTextureToLoadRefCount==0)
|
|
{
|
|
// must copy all fileNames into the actual Texture Files. Those are the valid ones now!
|
|
for(uint i=0;i<_CurrentAsyncTextures.size();i++)
|
|
{
|
|
for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
|
|
{
|
|
if(_CurrentAsyncTextures[i].IsTextureFile[stage])
|
|
{
|
|
// copy the texture name into the texture file.
|
|
CTextureFile *text= safe_cast<CTextureFile*>(Materials[i].getTexture(uint8(stage)));
|
|
// Since the texture is really uploaded in the driver, the true driver Texture Id will
|
|
// be bound to this texture.
|
|
text->setFileName(_CurrentAsyncTextures[i].TextureNames[stage]);
|
|
/* Since driver setup will only occurs when object become visible, it is a good idea to release
|
|
Old driver info, because it may points to old driver texture data (eg: old shared textureFile).
|
|
thus doing so release VRAM Texture Memory
|
|
*/
|
|
text->releaseDriverSetup();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ok, we are now ready.
|
|
_AsyncTextureReady= true;
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
sint CMeshBaseInstance::getAsyncTextureId(uint matId, uint stage) const
|
|
{
|
|
if(matId>=_CurrentAsyncTextures.size())
|
|
return -1;
|
|
if(!_CurrentAsyncTextures[matId].isTextureFile(stage))
|
|
return -1;
|
|
return _CurrentAsyncTextures[matId].TextIds[stage];
|
|
}
|
|
|
|
|
|
|
|
} // NL3D
|