FvTupleBaseNode* FvDynamicTuple::CreateNode(const FvUInt32 uiType)
{
_List& kList = S_List();
if(uiType < kList.size())
{
pCreateFunc pkFunc = kList[uiType];
FV_ASSERT(pkFunc);
return (*pkFunc)();
}
else
return NULL;
}
FvController::FvController(FvEntity* pkEntity) :
m_uiID(0),
m_bIsNew(false),
m_pkParent(NULL),
m_pkEntity(pkEntity)
{
FV_ASSERT(m_pkEntity);
if(m_pkEntity->m_kFreeIDs.empty())
{
m_uiID = m_pkEntity->m_kControllers.size();
m_pkEntity->m_kControllers.push_back(this);
}
else
{
m_uiID = m_pkEntity->m_kFreeIDs.front();
m_pkEntity->m_kFreeIDs.pop();
FV_ASSERT(m_pkEntity->m_kControllers[m_uiID] == NULL);
m_pkEntity->m_kControllers[m_uiID] = this;
}
m_uiMemoryOffset = (FvUInt32(this) - FvUInt32(pkEntity));
}
void FvLodTickList::UpdateList(const float fDeltaTime)
{
m_TaskList.BeginIterator();
while (!m_TaskList.IsEnd())
{
List::iterator iter = m_TaskList.GetIterator();
FvLodTickNode* pkTask = static_cast<FvLodTickNode*>(iter);
m_TaskList.Next();
FV_ASSERT(pkTask);
pkTask->Exec(fDeltaTime);
}
}
void FvFTDTerrainPageSerializerImpl::ReadHeightMap(Ogre::DataStreamPtr &spStream,
FvTerrainPage *pkDest, FvUInt32 uiLodLevel)
{
FV_ASSERT(pkDest);
FTDHeightMapHeader kHeader;
spStream->read(&kHeader,sizeof(FTDHeightMapHeader));
pkDest->m_fMinHeight = kHeader.m_fMinHeight;
pkDest->m_fMaxHeight = kHeader.m_fMaxHeight;
pkDest->m_uiHeightLodLevel = uiLodLevel;
pkDest->m_uiVisiableOffset = pkDest->m_uiHeightLodLevel > 0 ? 0 : FV_DEFAULT_VISIBLE_OFFSET;
if (pkDest->m_fMaxHeight < pkDest->m_fMinHeight)
std::swap(pkDest->m_fMinHeight, pkDest->m_fMaxHeight);
if(kHeader.m_uiVersion == VERSION_PNG)
pkDest->m_kHeights.load(spStream,"png");
else if(kHeader.m_uiVersion == VERSION_DDS)
pkDest->m_kHeights.load(spStream,"dds");
FV_ASSERT(pkDest->m_kHeights.getWidth() == kHeader.m_uiWidth);
FV_ASSERT(pkDest->m_kHeights.getHeight() == kHeader.m_uiHeight);
}
bool FvXMLAnimationModelSerializerImpl::ImportModel(
Ogre::DataStreamPtr& kStream, FvAnimationModel* pkDest )
{
FvXMLSectionPtr spScene = FvXMLSection::OpenSection(kStream);
if(spScene == NULL)
return false;
pkDest->m_kBoundingBox.SetBounds(spScene->ReadVector3("boundingBox/min"),
spScene->ReadVector3("boundingBox/max"));
#ifndef FV_SERVER
//FvXMLSectionPtr spNodes = spScene->OpenSection("nodes");
std::vector<FvXMLSectionPtr> kNodesSections;
spScene->OpenSections("nodes", kNodesSections);
for(FvUInt32 i(0); i < kNodesSections.size(); ++i)
{
FvUInt32 u32Lod = kNodesSections[i]->AsAttributeInt("Lod");
FV_ASSERT(u32Lod < FV_MAX_LOD_LEVEL);
pkDest->m_u32CurrentLodLevel = u32Lod;
FV_ASSERT(pkDest->m_akNodes[u32Lod].m_pkNode);
FvXMLSectionIterator kIt = kNodesSections[i]->Begin();
for(; kIt != kNodesSections[i]->End(); ++kIt)
this->ReadNode(*kIt,pkDest->m_akNodes[u32Lod].m_pkNode,pkDest);
}
pkDest->m_u32CurrentLodLevel = 0;
//pkDest->m_pkNode->_update(true,true);
#endif // !FV_SERVER
FvXMLSectionPtr spCollision = spScene->OpenSection("bspCollision");
if(spCollision)
this->ReadCollision(spCollision,pkDest);
return true;
}
void FvXMLAnimationModelSerializerImpl::ReadAnimation(
FvXMLSectionPtr spSection, Ogre::SceneNode* pkNode, FvAnimationModel* pkDest )
{
Ogre::SceneManager *pkSceneManager = Ogre::Root::getSingleton().
_getCurrentSceneManager();
FV_ASSERT(pkSceneManager);
FvString kAnimationName = spSection->ReadString("name");
bool bEnable = spSection->ReadBool("enable");
bool bLoop = spSection->ReadBool("loop");
FvString kIterpolationMode = spSection->ReadString("interpolationMode");
FvString kRotationIterpolationMode = spSection->ReadString("rotationInterpolationMode");
float fLength = spSection->ReadFloat("length");
if(!pkSceneManager->hasAnimation(pkNode->getName() + kAnimationName))
{
std::vector<FvXMLSectionPtr> kKeyFrames;
spSection->OpenSections("keyframe",kKeyFrames);
Animation *pkAnimation = pkSceneManager->createAnimation(pkNode->getName() + kAnimationName, fLength);
if(strcmp(kIterpolationMode.c_str(),"spline") == 0)
pkAnimation->setInterpolationMode(Animation::IM_SPLINE);
else
pkAnimation->setInterpolationMode(Animation::IM_LINEAR);
if(strcmp(kRotationIterpolationMode.c_str(),"spherical") == 0)
pkAnimation->setRotationInterpolationMode(Animation::RIM_SPHERICAL);
else
pkAnimation->setRotationInterpolationMode(Animation::RIM_LINEAR);
NodeAnimationTrack *pkAnimationTrack = pkAnimation->createNodeTrack(
pkAnimation->getNumNodeTracks() + 1, pkNode);
for (size_t stKeyframeIndex = 0; stKeyframeIndex < kKeyFrames.size(); stKeyframeIndex++)
{
float fTime = kKeyFrames[stKeyframeIndex]->ReadFloat("time");
FvVector3 kPosition = kKeyFrames[stKeyframeIndex]->ReadVector3("translation");
FvVector3 kScale = kKeyFrames[stKeyframeIndex]->ReadVector3("scale");
FvQuaternion kQuaternion = kKeyFrames[stKeyframeIndex]->ReadQuaternion("rotation");
TransformKeyFrame *pkKeyFrame = pkAnimationTrack->createNodeKeyFrame(fTime);
pkKeyFrame->setTranslate(Vector3(kPosition.x,kPosition.y,kPosition.z));
pkKeyFrame->setRotation(Quaternion(kQuaternion.w,kQuaternion.x,kQuaternion.y,kQuaternion.z));
pkKeyFrame->setScale(Vector3(kScale.x,kScale.y,kScale.z));
}
AnimationState *pkAnimationState = pkSceneManager->createAnimationState(pkNode->getName() + kAnimationName);
pkAnimationState->setEnabled(bEnable);
pkAnimationState->setLoop(bLoop);
pkDest->m_kModelAnimations.insert(std::make_pair(kAnimationName,pkAnimationState));
}
}
int MySqlThreadResPool::HandleTimeout( FvNetTimerID id, void * arg )
{
FV_ASSERT( id == m_kKeepAliveTimerID );
ThreadDataVector::size_type numFreeConnections = m_kFreeThreadData.size();
for ( ThreadDataVector::size_type i = 0; i < numFreeConnections; ++i )
{
PingTask* pTask = new PingTask( *this );
this->ThreadPool().DoTask( *pTask );
}
if (!m_kMainThreadData.m_kConnection.Ping())
FV_ERROR_MSG( "MySQL m_kConnection Ping failed: %s\n",
m_kMainThreadData.m_kConnection.GetLastError() );
return 0;
}
int FvZoneTerrainCache::Focus()
{
if (!m_pkTerrain || !m_spObstacle) return 0;
const FvVector3 &kMinB = m_spObstacle->m_kBB.MinBounds();
const FvVector3 &kMaxB = m_spObstacle->m_kBB.MaxBounds();
FvVector3 kMidPt = m_spObstacle->m_kTransform.ApplyPoint( (kMinB + kMaxB) / 2.f );
FvZoneSpace::Column *pkCol = m_pkZone->Space()->pColumn( kMidPt );
FV_ASSERT( pkCol );
pkCol->AddObstacle( *m_spObstacle );
return 1;
}
void FvZoneTerrain::CalculateBB()
{
FV_ASSERT( m_spCacheEntry && m_spCacheEntry->GetPage() );
m_kBB = m_spCacheEntry->GetPage()->BoundingBox();
if (m_pkZone != NULL)
{
FvBoundingBox kLocalBB = m_pkZone->LocalBB();
if( AddZBounds( kLocalBB ) )
{
m_pkZone->LocalBB( kLocalBB );
kLocalBB.TransformBy( m_pkZone->Transform() );
m_pkZone->BoundingBox( kLocalBB );
}
}
}
MySqlThreadData& MySqlThreadResPool::AcquireThreadDataAlways( int
mainThreadThreshold )
{
MySqlThreadData* pThreadData = this->AcquireThreadDataInternal();
if (!pThreadData)
{
if (this->GetNumConnections() <= mainThreadThreshold)
{
pThreadData = &m_kMainThreadData;
}
else
{
m_kThreadPool.WaitForOneTask();
pThreadData = this->AcquireThreadDataInternal();
FV_ASSERT( pThreadData );
}
}
return *pThreadData;
}
void MySqlThreadResPool::ReleaseThreadData( MySqlThreadData& threadData )
{
m_kFreeThreadData.push_back( &threadData );
FV_ASSERT( m_kFreeThreadData.size() <= m_kThreadDataPool.container.size() );
for ( ThreadDataProcJobs::iterator it = m_kThreadDataJobs.begin();
it != m_kThreadDataJobs.end(); )
{
ThreadDataProcJobs::iterator cur = it;
++it;
this->ApplyThreadDataJob( threadData, *cur );
if (cur->m_kUnprocessedItems.size() == 0)
{
cur->m_kProcessor.Done();
m_kThreadDataJobs.erase( cur );
}
}
}
void FvBackgroundTaskThread::Run()
{
while (true)
{
FvBackgroundTaskPtr spTask = m_kBGTaskManager.PullBackgroundTask();
if (spTask)
{
#ifdef FORCE_MAIN_THREAD
FV_ASSERT( 0 );
#endif // FORCE_MAIN_THREAD
spTask->DoBackgroundTask( m_kBGTaskManager );
}
else
{
break;
}
}
m_kBGTaskManager.AddMainThreadTask( new FvThreadFinisher( this ) );
}
MySqlThreadResPool::MySqlThreadResPool( FvWorkerThreadManager& threadMgr,
FvNetNub& nub,
int numConnections,
int maxSpaceDataSize,
const FvDBConfigConnection& connInfo,
const FvEntityDefs& entityDefs,
bool shouldLockDB )
: m_kThreadPool( threadMgr, numConnections - 1 ), m_kThreadDataPool(),
m_kFreeThreadData(),
m_kMainThreadData( connInfo, maxSpaceDataSize, entityDefs ),
m_kDBLock( m_kMainThreadData.m_kConnection, connInfo.GenerateLockName(),
shouldLockDB ),
m_kNub( nub ),
m_uiOPCount( 0 ), m_uiOPDurationTotal( 0 ), m_uiResetTimeStamp( Timestamp() )
{
int numThreads = m_kThreadPool.GetNumFreeThreads();
FV_ASSERT( (numThreads == 0) || ((numThreads > 0) && mysql_thread_safe()) );
struct InitMySqlTask : public FvWorkerThread::ITask
{
virtual void Run() { mysql_thread_init(); }
virtual void OnRunComplete() {}
} initMySqlTask;
while ( m_kThreadPool.DoTask( initMySqlTask ) ) {}
m_kThreadPool.WaitForAllTasks();
m_kThreadDataPool.container.reserve( numThreads );
for ( int i = 0; i < numThreads; ++i )
{
m_kThreadDataPool.container.push_back(
new MySqlThreadData( connInfo, maxSpaceDataSize, entityDefs ) );
}
m_kFreeThreadData = m_kThreadDataPool.container;
m_kKeepAliveTimerID = m_kNub.RegisterTimer( 1800000000, this );
}
bool FvUserDataObjectType::Load( FvUserDataObjectTypes& kTypes )
{
FV_ASSERT(0);
//Ogre::DataStreamPtr spDataStream = Ogre::ResourceGroupManager::getSingleton().openResource(FvEntityDef::Constants::UserDataObjectsFile());
//if(spDataStream.isNull())
//{
// FV_WARNING_MSG( "FvUserDataObjectpType::Init: "
// "No user data object mapping present\n" );
// return true;
//}
//FvXMLSectionPtr spSection = FvXMLSection::OpenSection(spDataStream);
//if(spSection == NULL)
//{
// FV_WARNING_MSG( "FvUserDataObjectpType::Init: "
// "No user data object mapping present\n" );
// return false;
//}
//FvUserDataObjectDescriptionMap kUserDataObjectDescriptionMap;
//if(!kUserDataObjectDescriptionMap.Parse(spSection))
//{
// FV_ERROR_MSG( "FvUserDataObjectType::Init: "
// "Failed to parse UserDataObjectDescriptionMap\n" );
// return false;
//}
//for(FvUserDataObjectDescriptionMap::DescriptionMap::const_iterator i = kUserDataObjectDescriptionMap.Begin();
// i != kUserDataObjectDescriptionMap.End(); ++i)
//{
// const FvUserDataObjectDescription& kDesc = i->second;
// kTypes[kDesc.Name()] = new FvUserDataObjectType(kDesc);
//}
return true;
}
//----------------------------------------------------------------------------
FvVector3 FvBoundingBox::HalfSize() const
{
FV_ASSERT(!InsideOut());
return (m_kMax - m_kMin) * 0.5f;
}
static void
fv_corner_eigen_vals_vecs(fv_mat_t *dst, fv_mat_t *src,
fv_s32 block_size, fv_s32 aperture_size,
double k, fv_s32 border_type,
void (*calc_eigen_val)(fv_mat_t *, fv_mat_t *, double))
{
fv_mat_t *dx;
fv_mat_t *dy;
fv_mat_t *cov;
fv_mat_t *cov2;
float *cov_data;
float *dxdata;
float *dydata;
double scale;
float dx_data;
float dy_data;
fv_u32 atr;
fv_s32 depth;
fv_s32 i;
fv_s32 j;
FV_ASSERT(dst->mt_atr == FV_32FC1 && dst->mt_rows == src->mt_rows &&
dst->mt_cols == src->mt_cols);
scale = (double)(1 << ((aperture_size > 0 ?
aperture_size : 3) - 1)) * block_size;
if (aperture_size < 0) {
scale *= 2;
}
depth = FV_MAT_DEPTH(src);
if (depth == FV_DEPTH_8U) {
scale *= 255;
}
scale = 1.0/scale;
FV_ASSERT(src->mt_atr == FV_8UC1 || src->mt_atr == FV_32FC1);
atr = FV_32FC(FV_MAT_NCHANNEL(src));
dx = fv_create_mat(src->mt_rows, src->mt_cols, atr);
FV_ASSERT(dx != NULL);
dy = fv_create_mat(src->mt_rows, src->mt_cols, atr);
FV_ASSERT(dy != NULL);
FV_LOG_PRINT("scale = %f\n", scale);
if (aperture_size > 0) {
_fv_sobel(dx, src, FV_DEPTH_32F, 1, 0, aperture_size,
scale, 0, border_type);
_fv_sobel(dy, src, FV_DEPTH_32F, 0, 1, aperture_size,
scale, 0, border_type);
} else {
_fv_scharr(dx, src, FV_DEPTH_32F, 1, 0, scale, 0, border_type);
_fv_scharr(dy, src, FV_DEPTH_32F, 0, 1, scale, 0, border_type);
}
cov = fv_create_mat(src->mt_rows, src->mt_cols, FV_32FC3);
FV_ASSERT(cov != NULL);
dxdata = dx->mt_data.dt_fl;
dydata = dy->mt_data.dt_fl;
for (i = 0; i < src->mt_rows; i++) {
cov_data = (float *)(cov->mt_data.dt_ptr + i*cov->mt_step);
for (j = 0; j < src->mt_cols; j++, dxdata++, dydata++) {
dx_data = *dxdata;
dy_data = *dydata;
cov_data[j*3] = dx_data*dx_data;
cov_data[j*3 + 1] = dx_data*dy_data;
cov_data[j*3 + 2] = dy_data*dy_data;
}
}
fv_release_mat(&dy);
fv_release_mat(&dx);
cov2 = fv_create_mat(cov->mt_rows, cov->mt_cols, cov->mt_atr);
FV_ASSERT(cov2 != NULL);
fv_box_filter(cov2, cov, FV_MAT_DEPTH(cov), fv_size(block_size, block_size),
fv_point(-1, -1), 0, border_type);
fv_release_mat(&cov);
calc_eigen_val(dst, cov2, k);
fv_release_mat(&cov2);
}
bool FvFTDTerrainPageSerializerImpl::ImportTerrainPage(
Ogre::DataStreamPtr &kStream, FvTerrainPage *pkDest)
{
if(kStream.isNull() || kStream->eof())
return false;
FTDTerrainHeader kFTDHeader;
kStream->read(&kFTDHeader,sizeof(FTDTerrainHeader));
if(kFTDHeader.m_uiIdentify != FTDTerrainHeader::IDENTIFY)
{
return false;
}
FTDChunkHeader kChunkHeader;
char *pcTempData = new char[409600];
while(!kStream->eof())
{
if(kStream->read(&kChunkHeader,sizeof(FTDChunkHeader))
!= sizeof(FTDChunkHeader))
continue;
FV_ASSERT(kChunkHeader.m_uiSize < 409600);
if(kStream->read(pcTempData,kChunkHeader.m_uiSize)
!= kChunkHeader.m_uiSize)
continue;
Ogre::DataStreamPtr spData(OGRE_NEW Ogre::MemoryDataStream(pcTempData,
kChunkHeader.m_uiSize));
switch(kChunkHeader.m_uiID)
{
case ID_HEIGHTS:
case ID_HEIGHTS_1:
case ID_HEIGHTS_2:
case ID_HEIGHTS_3:
case ID_HEIGHTS_4:
case ID_HEIGHTS_5:
case ID_HEIGHTS_6:
{
FvUInt32 uiLodLevel = kChunkHeader.m_uiID - ID_HEIGHTS;
if(uiLodLevel == pkDest->m_spTerrainSettings->DefaultHeightMapLod())
this->ReadHeightMap(spData,pkDest,uiLodLevel);
}
break;
case ID_HOLE_MAP:
this->ReadHoleMap(pcTempData,kChunkHeader.m_uiSize,pkDest);
break;
case ID_DOMINANT_TEXUTRES:
this->ReadDominantTextureMap(pcTempData,kChunkHeader.m_uiSize,pkDest);
break;
#ifndef FV_SERVER
case ID_NORMALS:
this->ReadNormalMap(spData,pkDest);
break;
case ID_LOD_TEXTURE:
this->ReadLodTextureMap(spData,pkDest);
break;
case ID_LOD_NORMALS:
this->ReadLodNormalMap(spData,pkDest);
break;
case ID_HORIZON_SHADOWS:
this->ReadHorizonShadowMap(pcTempData,kChunkHeader.m_uiSize,pkDest);
break;
case ID_THUMBNAIL:
break;
default:
if(kChunkHeader.m_uiID >= ID_LAYER_BEGIN)
{
this->ReadLayerMap(spData,pkDest,kChunkHeader.m_uiID - ID_LAYER_BEGIN);
}
break;
#endif // !FV_SERVER
}
}
delete[] pcTempData;
if(pkDest->m_kMaterialNames.size() == 0)
pkDest->m_eOceanType = FvTerrainPage::OCEAN_TYPE_ONLY;
for(size_t i = 0; i < pkDest->m_kMaterialNames.size(); i++)
{
FV_ASSERT(pkDest->m_spTerrainSettings);
FV_ASSERT(!pkDest->m_kMaterialNames[i].empty());
if(pkDest->m_spTerrainSettings->IsOceanMap(
pkDest->m_kMaterialNames[i]))
{
pkDest->m_eOceanType = FvTerrainPage::OCEAN_TYPE_LAND;
break;
}
}
if(pkDest->m_kHeights.getData() == NULL)
return false;
#ifndef FV_SERVER
pkDest->GenerateCombinedLayers();
pkDest->GenerateMaterial();
#endif // !FV_SERVER
return true;
}
void FvFTDTerrainPageSerializerImpl::ReadDominantTextureMap(char *pcData, size_t stSize,
FvTerrainPage *pkDest)
{
FTDDominantTextureMapHeader *pkHeader = (FTDDominantTextureMapHeader*)pcData;
if(stSize <= sizeof(FTDDominantTextureMapHeader))
{
FV_ERROR_MSG("FvFTDTerrainPageSerializerImpl:ReadDominantTextureMap header size error");
return;
}
if ( pkHeader->m_uiMagic != FTDDominantTextureMapHeader::MAGIC ||
pkHeader->m_uiVersion != FTDDominantTextureMapHeader::VERSION_ZIP )
{
FV_ERROR_MSG("FvFTDTerrainPageSerializerImpl::ReadDominantTextureMap magic or version error");
return;
}
FvUInt32 uiTextureDataSize = pkHeader->m_uiTextureNameSize * pkHeader->m_uiNumTextures;
stSize -= sizeof(FTDDominantTextureMapHeader);
if(stSize < uiTextureDataSize)
{
FV_ERROR_MSG("FvFTDTerrainPageSerializerImpl::ReadDominantTextureMap texture data size error");
return;
}
char *pcNameBuf = new char[pkHeader->m_uiTextureNameSize + 1];
char *pcPtr = (char*)( pkHeader + 1 );
for( FvUInt32 i = 0; i < pkHeader->m_uiNumTextures; ++i )
{
strncpy( pcNameBuf, pcPtr, pkHeader->m_uiTextureNameSize);
pcNameBuf[ std::min( FvUInt32(strlen(pcPtr)), pkHeader->m_uiTextureNameSize ) ] = '\0';
FvString kTexName = pcNameBuf;
Ogre::StringUtil::toLowerCase(kTexName);
pkDest->m_kMaterialNames.push_back( kTexName );
pcPtr += pkHeader->m_uiTextureNameSize;
}
delete[] pcNameBuf;
stSize -= uiTextureDataSize;
if(stSize <= int( COMPRESSED_HEADER_SZ * sizeof( FvUInt32 ) ))
{
FV_ERROR_MSG("FvFTDTerrainPageSerializerImpl::ReadDominantTextureMap image data size error");
return;
}
if(*((FvUInt32*)pcPtr) != COMPRESSED_MAGIC1 ||
*((FvUInt32*)pcPtr + 1) != COMPRESSED_MAGIC2)
{
FV_ERROR_MSG("FvFTDTerrainPageSerializerImpl::ReadDominantTextureMap image data format error");
return;
}
uLongf uiUncompressSize = *((FvUInt32 *)pcPtr + COMPRESSED_HEADER_SZ - 1);
if(uiUncompressSize != pkHeader->m_uiWidth * pkHeader->m_uiHeight)
{
FV_ERROR_MSG("FvFTDTerrainPageSerializerImpl::ReadDominantTextureMap width or height error");
return;
}
pkDest->m_pkMaterialIndexs = new FvUInt8[uiUncompressSize];
memset(pkDest->m_pkMaterialIndexs,0xff,uiUncompressSize);
FvUInt8 *pcRawData = (FvUInt8 *)pcPtr + COMPRESSED_HEADER_SZ*sizeof(FvUInt32);
FvUInt32 uiRawDataSize = FvUInt32(stSize) - COMPRESSED_HEADER_SZ*sizeof(FvUInt32);
int iResult =
uncompress
(
pkDest->m_pkMaterialIndexs,
&uiUncompressSize,
pcRawData,
uiRawDataSize
);
FV_ASSERT(iResult == Z_OK);
pkDest->m_uiMaterialWidth = pkHeader->m_uiWidth;
pkDest->m_uiMaterialHeight = pkHeader->m_uiHeight;
}
FvSpace::CellInfo* FvSpace::GetCellInfo()
{
FV_ASSERT(m_pkCell);
return m_pkCell->GetCellInfo();
}
FvBinaryOStream* FvMailBox::GetStream(Destination eDest, FvInt32 iMethodIdx, FvUInt8 uiCBCnt)
{
FV_ASSERT(eDest>=ToCLIENT && eDest<=ToBASE);
FV_ASSERT(!ms_uiState && !ms_kStream.Size());
if(!IsValid())
{
FV_ERROR_MSG("%s, MB is Invalid\n", __FUNCTION__);
return NULL;
}
if(eDest == ToCLIENT)
{
FvRobotEntityExport* pkExport = m_pkEntity->GetAttrib().GetExport();
FV_ASSERT(pkExport);
FV_ASSERT(iMethodIdx < pkExport->kMethodCnts.uiClientCnt);
FV_ASSERT(uiCBCnt == 0);//! 客户端不能有带回调的函数
ms_uiState = 1;
ms_uiMethodID = FvUInt16(iMethodIdx);
return &ms_kStream;
}
else if(eDest == ToCELL)
{
//! 压缩消息id
FvRobotEntityExport* pkExport = m_pkEntity->GetAttrib().GetExport();
FV_ASSERT(pkExport);
FV_ASSERT(iMethodIdx < pkExport->kMethodCnts.uiCellExpCnt);
FV_ASSERT(iMethodIdx < 0x1F00);
FvUInt8 uiBaseID(iMethodIdx >> 8);
FvUInt8 uiExtID(iMethodIdx);
if(m_pkEntity->GetEntityID() == m_pkServer->ConnectedID())
{
if(uiCBCnt)
{
FvBinaryOStream* pkOS = m_pkServer->StartAvatarMessage(uiBaseID | 0x20);
*pkOS << uiExtID << uiCBCnt;
return pkOS;
}
else
{
FvBinaryOStream* pkOS = m_pkServer->StartAvatarMessage(uiBaseID);
*pkOS << uiExtID;
return pkOS;
}
}
else
{
if(uiCBCnt)
{
FvBinaryOStream* pkOS = m_pkServer->StartEntityMessage(uiBaseID | 0x20, m_pkEntity->GetEntityID());
*pkOS << uiExtID << uiCBCnt;
return pkOS;
}
else
{
FvBinaryOStream* pkOS = m_pkServer->StartEntityMessage(uiBaseID, m_pkEntity->GetEntityID());
*pkOS << uiExtID;
return pkOS;
}
}
}
//----------------------------------------------------------------------------
FvVector3 FvBoundingBox::Centre() const
{
FV_ASSERT(!InsideOut());
return (m_kMin + m_kMax) * 0.5f;
}
//----------------------------------------------------------------------------
const FvVector3& FvBoundingBox::MaxBounds() const
{
FV_ASSERT(!InsideOut());
return m_kMax;
}
void MyApp::DrawGlobalMode()
{
FvRobotMainApp::SpaceList& kSpaceList = FvRobotMainApp::pInstance()->GetSpaceList();
FvRobotMainApp::SpaceEntityList& kSpaceEntityList = FvRobotMainApp::pInstance()->GetSpaceEntityList();
int lineStart(LINE_START);
int lineStep(LINE_STEP);
//! 显示地图信息
DrawString(0, lineStart, CLR_WHITE, "-------Global Mode-------");
lineStart += lineStep;
DrawString(0, lineStart, CLR_WHITE, "ShowHelpInfo: H");
lineStart += lineStep;
if(1)
{
int iCtrlers(0), iOthers(0);
if(kSpaceEntityList.size())
{
FvRobotMainApp::SpaceEntity* pkSpaceEntity(NULL);
if(m_iSpaceIdx >= (int)kSpaceEntityList.size())
{
m_bResetWindow4Space = true;
m_iSpaceIdx = m_iSpaceIdx % kSpaceEntityList.size();
}
DrawString(0, lineStart, CLR_WHITE, "Spaces:%d,Idx:%d", kSpaceEntityList.size(), m_iSpaceIdx);
lineStart += lineStep;
int idx(0);
FvRobotMainApp::SpaceEntityList::iterator itrB = kSpaceEntityList.begin();
FvRobotMainApp::SpaceEntityList::iterator itrE = kSpaceEntityList.end();
while(itrB != itrE)
{
if(idx == m_iSpaceIdx)
{
pkSpaceEntity = &(*itrB);
break;
}
++itrB;
++idx;
}
DrawString(0, lineStart, CLR_WHITE, "id:%d, type:%d", pkSpaceEntity->m_iSpaceID, pkSpaceEntity->m_uiSpaceType);
lineStart += lineStep;
//! 显示Space
{
const FvRobotMainApp::SpaceInfo* pkSpaceInfo = FvRobotMainApp::Instance().FindSpaceInfo(pkSpaceEntity->m_uiSpaceType);
FV_ASSERT(pkSpaceInfo);
if(m_bResetWindow4Space)
{
m_bResetWindow4Space = false;
SetWindowFit2Rect(pkSpaceInfo->kSpaceRect);
}
for(int i=0; i<(int)pkSpaceInfo->kCells.size(); ++i)
{
DrawRect(pkSpaceInfo->kCells[i], CLR_YELLOW);
}
DrawRect(pkSpaceInfo->kSpaceRect, CLR_YELLOW);
}
//! 显示实体
if(1)
{
FvRobotMainApp::Entities& kEntityMap = pkSpaceEntity->m_kEntities;
//! 显示实体数量
DrawString(0, lineStart, CLR_WHITE, "Entities:%d", kEntityMap.size());
lineStart += lineStep;
FvRobotMainApp::Entities::iterator itrB = kEntityMap.begin();
FvRobotMainApp::Entities::iterator itrE = kEntityMap.end();
while(itrB != itrE)
{
FvEntity* pkEntity = itrB->second;
p2Clr clr;
const FvVector3& p3 = pkEntity->GetPos();
FvVector2 p2(p3.x, p3.y);
int x,y;
char charID[32] = {0};
char robotID[32] = {0};
char charPos[64] = {0};
bool bConvertPos(false);
if(m_bShowEntityID)
{
bConvertPos = true;
sprintf(charID, "%d", pkEntity->GetEntityID());
}
if(m_bShowRobotID)
{
bConvertPos = true;
sprintf(robotID, "%d", pkEntity->GetRobotID());
}
if(m_bShowEntityPos)
{
bConvertPos = true;
sprintf(charPos, "%.2f,%.2f,%.2f", p3.x, p3.y, p3.z);
}
if(bConvertPos)
{
ConvertWorldToScreen(p2, x, y);
}
if(pkEntity->IsCtrler())//! ctrler
{
++iCtrlers;
clr = CLR_RED;
DrawPoint(p3, clr);
if(m_bShowEntityID)
{
DrawString(x, y, clr, charID);
}
if(m_bShowRobotID)
{
DrawString(x, y-lineStep, clr, robotID);
}
if(m_bShowEntityPos)
{
DrawString(x, y+lineStep, clr, charPos);
}
}
else//! others
{
++iOthers;
clr = CLR_BLUE;
DrawPoint(p3, clr);
if(m_bShowEntityID)
{
DrawString(x, y, clr, charID);
}
if(m_bShowEntityPos)
{
DrawString(x, y+lineStep, clr, charPos);
}
}
//! 显示非Ctrler实体的属性,测试Lod
if(m_bShowEntityProp)
{
/**
FvEntity* pkOther = pkEntity;
DrawString(0, lineStart, CLR_WHITE, "-------------");
lineStart += lineStep;
DrawString(0, lineStart, CLR_WHITE, "Entity:%d", pkOther->GetEntityID());
lineStart += lineStep;
const FvEntityDescription* pkEntityDes = pkOther->GetEntityDes();
FvUInt32 cnt = pkEntityDes->PropertyCount();
for(FvUInt32 i=0; i<cnt; ++i)
{
FvDataDescription* pkDataDes = pkEntityDes->Property(i);
FvObjPtr spObj = pkOther->FindProperty(i);
if(!spObj)
continue;
switch(spObj->RTTI())
{
case FVOBJ_RTTI_INT8:
{
FvInt8 v = FVOBJ_GETVAL(spObj, FvObjInt8);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%d", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_UINT8:
{
FvUInt8 v = FVOBJ_GETVAL(spObj, FvObjUInt8);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%d", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_INT16:
{
FvInt16 v = FVOBJ_GETVAL(spObj, FvObjInt16);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%d", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_UINT16:
{
FvUInt16 v = FVOBJ_GETVAL(spObj, FvObjUInt16);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%d", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_INT32:
{
FvInt32 v = FVOBJ_GETVAL(spObj, FvObjInt32);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%d", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_UINT32:
{
FvUInt32 v = FVOBJ_GETVAL(spObj, FvObjUInt32);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%d", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_INT64:
{
FvInt64 v = FVOBJ_GETVAL(spObj, FvObjInt64);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%I64d", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_UINT64:
{
FvUInt64 v = FVOBJ_GETVAL(spObj, FvObjUInt64);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%I64u", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_FLOAT:
{
float v = FVOBJ_GETVAL(spObj, FvObjFloat);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%f", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_DOUBLE:
{
double v = FVOBJ_GETVAL(spObj, FvObjDouble);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%f", pkDataDes->Name().c_str(), v);
}
break;
case FVOBJ_RTTI_STRING:
{
FvString v = FVOBJ_GETVAL(spObj, FvObjString);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%s", pkDataDes->Name().c_str(), v.c_str());
}
break;
case FVOBJ_RTTI_MAILBOX:
{
FVOBJ_CONVERT_P(spObj, FvObjMailBox, pMB);
DrawString(0, lineStart, CLR_WHITE, "PropName:%s,Val:%s", pkDataDes->Name().c_str(), pMB->c_str());
}
break;
default:
{
DrawString(0, lineStart, CLR_WHITE, "PropName:%s", pkDataDes->Name().c_str());
}
break;
}
lineStart += lineStep;
}
**/
}
++itrB;
}
}
DrawString(0, lineStart, CLR_WHITE, "Ctrler:%d, Others:%d", iCtrlers, iOthers);
lineStart += lineStep;
}
else
{
DrawString(0, lineStart, CLR_WHITE, "Spaces:%d,Idx:%d", 0, 0);
lineStart += lineStep;
DrawString(0, lineStart, CLR_WHITE, "Entities:%d", 0);
lineStart += lineStep;
DrawString(0, lineStart, CLR_WHITE, "Ctrler:%d, Others:%d", 0, 0);
lineStart += lineStep;
}
}
}
FvSpace::FvSpace( FvSpaceID id, FvUInt16 type, FvUInt16 cellIdx, const FvString& kSpacePath )
:m_iSpaceID(id)
,m_uiSpaceType(type)
,m_kSpacePath(kSpacePath)
,m_iTransitionAndGhostTimerID(NULL)
,m_iAoIAndTrapTimerID(NULL)
,m_iEventSyncTimerID(NULL)
,m_iEntityTickTimerID(NULL)
,m_iSystemManageTimerID(NULL)
,m_iZoneTickTimerID(NULL)
{
m_pkTimeOfDay = new FvTimeOfDay();
m_pkSpaceInfo = FvEntityManager::Instance().FindSpaceInfo(type);
FV_ASSERT(m_pkSpaceInfo);
m_kCellInfos.resize(m_pkSpaceInfo->m_uiCellCnt);
for(FvUInt16 i=0; i<m_pkSpaceInfo->m_uiCellCnt; ++i)
{
m_kCellInfos[i].m_uiIdx = i;
m_kCellInfos[i].m_fLoad = 0.0f;
m_kCellInfos[i].m_pkCellData = &(m_pkSpaceInfo->m_pkCellDatas[i]);
}
m_kCellInfos[cellIdx].m_kAddr = FvEntityManager::Instance().Address();
m_pkCell = new FvCell(*this, &m_kCellInfos[cellIdx]);
bool bLoadZone = FvServerConfig::Get( "LoadZone", bool(false) );
if(bLoadZone && m_kCellInfos[cellIdx].m_pkCellData->m_bLoadZone)
{
m_spZoneSpace = FvZoneManager::Instance().Space(m_iSpaceID,false);
if(m_spZoneSpace)
{
m_spZoneSpace->Clear();
FvZoneManager::Instance().DelSpace(m_spZoneSpace.Get());
m_spZoneSpace = NULL;
FV_INFO_MSG("FvSpace::FvSpace space id:%d exist,delete this space.",m_iSpaceID);
}
m_spZoneSpace = new FvZoneSpace(m_iSpaceID);
FvZoneDirMapping *pkMapping = m_spZoneSpace->AddMapping(
FvZoneSpaceEntryID(m_kCellInfos[cellIdx].m_kAddr.m_uiIP,
m_kCellInfos[cellIdx].m_kAddr.m_uiPort),
(float*)&FvMatrix::IDENTITY,"General",m_kSpacePath);
//int iGridMinX = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.LeftBorder() );
//int iGridMaxX = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.RightBorder() );
//int iGridMinY = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.BottomBorder() );
//int iGridMaxY = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.TopBorder() );
//! 多载入一圈
int iGridMinX = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.LeftBorder() ) -1;
int iGridMaxX = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.RightBorder() ) +1;
int iGridMinY = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.BottomBorder() ) -1;
int iGridMaxY = FvZoneSpace::PointToGrid( m_kCellInfos[cellIdx].m_pkCellData->m_kRect.TopBorder() ) +1;
int iSpaceMinX = FvZoneSpace::PointToGrid( m_pkSpaceInfo->m_kSpaceRect.LeftBorder() );
int iSpaceMaxX = FvZoneSpace::PointToGrid( m_pkSpaceInfo->m_kSpaceRect.RightBorder() );
int iSpaceMinY = FvZoneSpace::PointToGrid( m_pkSpaceInfo->m_kSpaceRect.BottomBorder() );
int iSpaceMaxY = FvZoneSpace::PointToGrid( m_pkSpaceInfo->m_kSpaceRect.TopBorder() );
if(iGridMinX < iSpaceMinX) iGridMinX = iSpaceMinX;
if(iGridMaxX > iSpaceMaxX) iGridMaxX = iSpaceMaxX;
if(iGridMinY < iSpaceMinY) iGridMinY = iSpaceMinY;
if(iGridMaxY > iSpaceMaxY) iGridMaxY = iSpaceMaxY;
for(int iX = iGridMinX; iX < iGridMaxX; iX++)
{
for(int iY = iGridMinY; iY < iGridMaxY; iY++)
{
if ( iX < pkMapping->MinLGridX() || iX > pkMapping->MaxLGridX() ||
iY < pkMapping->MinLGridY() || iY > pkMapping->MaxLGridY() )
continue;
FvString kZoneName = pkMapping->OutsideZoneIdentifier( iX, iY, false );
FvZone *pkZone = new FvZone( kZoneName, pkMapping );
pkMapping->pSpace()->AddZone( pkZone );
if( pkZone && !pkZone->Loading() && !pkZone->Loaded() )
{
m_kLoadingZones.push_back( pkZone );
pkZone->Loading( true );
pkZone->Mapping()->IncRef();
FvZoneLoader::Load( pkZone, FvBGTaskManager::DEFAULT );
}
}
}
}
//! TODO: 可以根据不同space类型做调整,让小场景更及时
m_iTransitionAndGhostTimerID = FvEntityManager::Instance().Nub().RegisterTimer(1000000, this);
m_iAoIAndTrapTimerID = FvEntityManager::Instance().Nub().RegisterTimer(1000000, this);
m_iEventSyncTimerID = FvEntityManager::Instance().Nub().RegisterTimer(150000, this);
m_iEntityTickTimerID = FvEntityManager::Instance().Nub().RegisterTimer(333000, this);
m_iSystemManageTimerID = FvEntityManager::Instance().Nub().RegisterTimer(5000000, this);
m_iZoneTickTimerID = FvEntityManager::Instance().Nub().RegisterTimer(150000,this);
//m_iTransitionAndAoiUpdateTimerID = FvEntityManager::Instance().Nub().RegisterTimer(200000, this);
//m_iEventSyncTimerID = FvEntityManager::Instance().Nub().RegisterTimer(100000, this);
//m_iEntityTickTimerID = FvEntityManager::Instance().Nub().RegisterTimer(500000, this);
//m_iSystemManageTimerID = FvEntityManager::Instance().Nub().RegisterTimer(5000000, this);
if(1)
{
CellInfo* pkCellInfo = GetCellInfo();
//! TODO: 把ghost边界抽出来
float fGhostSize(100.0f);
float x = pkCellInfo->m_pkCellData->m_kRect.LeftBorder() - fGhostSize;
float y = pkCellInfo->m_pkCellData->m_kRect.BottomBorder() - fGhostSize;
float w = pkCellInfo->m_pkCellData->m_kRect.RightBorder() - pkCellInfo->m_pkCellData->m_kRect.LeftBorder() + fGhostSize*2.0f;
float h = pkCellInfo->m_pkCellData->m_kRect.TopBorder() - pkCellInfo->m_pkCellData->m_kRect.BottomBorder() + fGhostSize*2.0f;
//! TODO: 考虑把所有Space的内存分配器统一起来
m_kAoIMgr.Init(x, y, w, h,
pkCellInfo->m_pkCellData->m_kAoICfg.m_fGridSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiRefPtLvl,
pkCellInfo->m_pkCellData->m_kAoICfg.m_fMinMoveStep,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiObjInitSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiObjIncrSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiPosInitSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiPosIncrSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiEvtInitSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiEvtIncrSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiAoIExtInitSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiAoIExtIncrSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiTrapExtInitSize,
pkCellInfo->m_pkCellData->m_kAoICfg.m_uiTrapExtIncrSize);
}
}
