/*
*******************************************************************
* Function:
*
* Description:
*
* Parameters:
*
* Returns:
*
*******************************************************************
*/
void xDistributedSession::onGhostRemove()
{
xNetInterface *netInterface = getNetInterface();
if (getNetInterface())
{
if(!getNetInterface()->IsServer())
{
xDistributedObjectsArrayType *distObjects = netInterface->getDistributedObjects();
xDistObjectIt begin = distObjects->begin();
xDistObjectIt end = distObjects->end();
while (begin!=end)
{
xDistributedObject *distObject = *begin;
if (distObject)
{
xDistributedClass *_class = distObject->getDistributedClass();
if (_class)
{
if (_class->getEnitityType() == E_DC_BTYPE_CLIENT )
{
xDistributedClient *distClient = static_cast<xDistributedClient*>(distObject);
if (distClient && distClient->getSessionID() == getSessionID() )
{
distClient->setSessionID(-1);
disableFlag(distClient->getClientFlags(),E_CF_SESSION_JOINED);
enableFlag(distClient->getClientFlags(),E_CF_DELETING);
enableFlag(distClient->getClientFlags(),E_CF_SESSION_DESTROYED);
}
}
}
}
begin++;
}
}
if(getNetInterface()->IsServer())
{
xLogger::xLog(XL_START,ELOGINFO,E_LI_SESSION,"Server : Session is going to be deleted : %s",this->GetName().getString());
}
getNetInterface()->getDistObjectInterface()->removeObject(this);
}
}
osg::ref_ptr<ossimPlanetImage> ossimPlanetCacheTextureLayer::getTexture(ossim_uint32 width,
ossim_uint32 height,
const ossimPlanetTerrainTileId& tileId,
const ossimPlanetGrid& grid,
ossim_int32 padding)
{
if(!enableFlag())
{
return 0;
}
osg::ref_ptr<ossimPlanetImage> result;
if(m_cache.valid())
{
result = m_cache->get(tileId);
}
if(!result.valid()&&m_textureLayer.valid())
{
result = m_textureLayer->getTexture(width, height, tileId, grid, padding);
if(result.valid()&&m_cache.valid())
{
m_cache->addOrUpdate(result.get());
}
}
result = applyBrightnessContrast(result.get(), true);
return result;
}
void ossimPlanetIoSocketServerChannel::handleAccept (void)// for tcp servers we can accept
{
netAddress addr ;
int h = accept ( &addr ) ;
if(h != -1)
{
theIoListMutex.lock();
if(!protectedFindHandle(h))
{
// std::cout << "Addind a io to the handleAccept " << h << "\n";
osg::ref_ptr<ossimPlanetIoSocket> socket = new ossimPlanetIoSocket();
socket->setIoDirection(ossimPlanetIoDirection_IN);
socket->setHandle(h);
socket->setBlockingFlag(false);
//socket->setAutoCloseOnPeerShutdownFlag(true);
socket->setAutoReconnectFlag(false);
if(enableFlag())
{
theIoList.push_back(socket.get());
// std::cout << "Io list size === " << theIoList.size() << std::endl;
}
}
theIoListMutex.unlock();
}
}
/**
* Parses the command line, updating the flags or params according to its contents.
* @param _argc The argument count of the command line.
* @param _argv The arguments of the command line.
* @exception UnknownArg if an argument doesn't exist
* @exception MissingVal if a param hasn't got a value
*/
void Parser::parse (int _argc, char **_argv)
{
int i;
for (i=1 ; i<_argc ; i++)
{
try
{
enableFlag(_argv[i]);
}
catch (UnknownArg& )
{
//if it isn't a flag, perhaps is a param
setParamValue(_argv[i], _argv[++i]);
}
}
// after parsing the command line, check if all the required params have changed
vector<Param>::iterator pos;
for (pos=params.begin() ; pos!=params.end() ; pos++)
if (pos->required() && !pos->changed())
break;
// if there is an unchanged required param ...
if (pos!=params.end())
{
throw Parser::MissingReqParam(pos->shortName());
}
};
void ossimPlanetIoSocketServerChannel::setEnableFlag(bool flag)
{
bool clearBuffersFlag = false;
// if we are currently going from enabled to disabled then clear the lists after we disable
// ourselves
if(!flag&&enableFlag())
{
clearBuffersFlag = true;
}
ossimPlanetIo::setEnableFlag(flag);
}
bool pJointBall::setSwingLimit( pJointLimit limit )
{
NxSphericalJointDesc descr;
NxSphericalJoint *joint = static_cast<NxSphericalJoint*>(getJoint());
if (!joint)return false ;
joint->saveToDesc(descr);
if ( limit.hardness != 0.0f || limit.restitution != 0.0f || limit.value !=0.0f )
{
enableFlag(NX_SJF_SWING_LIMIT_ENABLED,1);
NxJointLimitDesc sLimit; sLimit.value = limit.value;sLimit.restitution = limit.restitution;sLimit.hardness = limit.hardness;
if (!sLimit.isValid())return false;
descr.swingLimit= sLimit;
joint->loadFromDesc(descr);
return true;
}else
{
enableFlag(NX_SJF_SWING_LIMIT_ENABLED,0);
}
return false;
}
osg::ref_ptr<ossimPlanetMessage> ossimPlanetIoSocketServerChannel::popMessage()
{
osg::ref_ptr<ossimPlanetMessage> message;
if(!enableFlag()) return message;
theInQueueMutex.lock();
if(!theInQueue.empty())
{
message = theInQueue.front();
theInQueue.pop();
}
theInQueueMutex.unlock();
return message;
}
void ossimPlanetPointModel::traverse(osg::NodeVisitor& nv)
{
if(!enableFlag()||!theNode.valid())
{
ossimPlanetAnnotationLayerNode::traverse(nv);
return;
}
switch(nv.getVisitorType())
{
case osg::NodeVisitor::UPDATE_VISITOR:
{
setRedrawFlag(false); // let's reset the redraw notification
if(!theLsrSpaceTransform->model()&&layer()) theLsrSpaceTransform->setModel(layer()->model());
// if(checkPointers())
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(thePointModelPropertyMutex);
if(theNodeChangedFlag)
{
if(theLsrSpaceTransform->getNumChildren() > 0)
{
theLsrSpaceTransform->removeChildren(0, theLsrSpaceTransform->getNumChildren());
}
theLsrSpaceTransform->addChild(theNode.get());
theNodeChangedFlag = false;
}
}
break;
}
case osg::NodeVisitor::CULL_VISITOR:
{
break;
}
default:
{
break;
}
}
theLsrSpaceTransform->accept(nv);
ossimPlanetAnnotationLayerNode::traverse(nv);
}
void ossimPlanetIoSocketServerChannel::handleRead (void) // for udp servers we can read
{
netAddress addr ;
accept ( &addr ) ;
int h = getHandle();
if(h > -1)
{
theIoListMutex.lock();
if(!protectedFindHandle(h))
{
osg::ref_ptr<ossimPlanetIoSocket> socket = new ossimPlanetIoSocket();
socket->setIoDirection(ossimPlanetIoDirection_IN);
//socket->setAutoCloseOnPeerShutdownFlag(true);
socket->setAutoReconnectFlag(false);
socket->setHandle(getHandle());
if(enableFlag())
{
theIoList.push_back(socket.get());
}
// std::cout << "List size = " << theIoList.size() << "\n";;
}
theIoListMutex.unlock();
}
}
void ossimPlanetIoSocketServerChannel::performIo()
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theSocketMutex);
if(handle() < 0)
{
if(theAutoReconnectFlag)
{
if(theLastTick == 0)
{
theLastTick = osg::Timer::instance()->tick();
return;
}
else
{
double delta = osg::Timer::instance()->delta_m(theLastTick, osg::Timer::instance()->tick());
if(delta < 0.0)
{
theLastTick = 0;
}
else if(delta > theAutoReconnectInterval)
{
theLastTick = 0; // reset the next try
if(!protectedSetSocket(theHost, thePort, theIoType))
{
return;
}
else if(handle() < 0)// Quick test again to make sure its valid
{
return;
}
}
else // we were not able to update the handle yet so return, still invalid
{
return;
}
}
}
else// we were not able to update the handle yet so return, still invalid
{
return;
}
}
// poll for additional I/O connections
poll(10);
// handle any current connections and process the messages.
OpenThreads::ScopedLock<OpenThreads::Mutex> lockList(theIoListMutex);
std::vector<osg::ref_ptr<ossimPlanetIo> >::iterator iter = theIoList.begin();
while(iter!=theIoList.end())
{
osg::ref_ptr<ossimPlanetMessage> msg;
// perform IO
(*iter)->performIo();
// now pop any message for handling
//
while((msg=(*iter)->popMessage()).valid())
{
theInQueueMutex.lock();
if(enableFlag())
{
theInQueue.push(msg);
}
else
{
while(!theInQueue.empty())
{
theInQueue.pop();
}
}
theInQueueMutex.unlock();
}
// check to see if it's been marked as finished and if so remove from the list
if((*iter)->finishedFlag())
{
iter = theIoList.erase(iter);
}
else
{
++iter;
}
}
}
void ossimPlanetKmlScreenOverlayNode::traverse(osg::NodeVisitor& nv)
{
if(!enableFlag()) return;
switch(nv.getVisitorType())
{
case osg::NodeVisitor::UPDATE_VISITOR:
{
if(theViewport.valid()&&theViewportChangedFlag)
{
theCameraNode->setProjectionMatrix(osg::Matrix::ortho2D(theViewport->x(),
theViewport->width(),
theViewport->y(),
theViewport->height()));
theViewportChangedFlag = false;
update();
}
if(theNeedsUpdateFlag)
{
update();
}
break;
}
case osg::NodeVisitor::CULL_VISITOR:
{
osgUtil::CullVisitor* cullVisitor = dynamic_cast<osgUtil::CullVisitor*>(&nv);
if(cullVisitor)
{
double x = cullVisitor->getViewport()->x();
double y = (int)cullVisitor->getViewport()->y();
double w = (int)cullVisitor->getViewport()->width();
double h = (int)cullVisitor->getViewport()->height();
if(!theViewport.valid())
{
theViewport = new osg::Viewport(x,y,w,h);
theViewportChangedFlag = true;
}
else
{
if( !ossim::almostEqual(theViewport->x(), x)||
!ossim::almostEqual(theViewport->y(), y)||
!ossim::almostEqual(theViewport->width(), w)||
!ossim::almostEqual(theViewport->height(), h))
{
theViewport->setViewport(x,y,w,h);
theViewportChangedFlag = true;
}
}
}
break;
}
default:
{
if(dynamic_cast<osgUtil::IntersectVisitor*>(&nv))
{
return;
}
break;
}
}
// if the viewport is valid and we have been setup to draw for the current viewport
//
if(theViewport.valid())
{
theGroup->accept(nv);
}
}
void ossimPlanetAnnotationPlacemark::traverse(osg::NodeVisitor& nv)
{
if(!enableFlag()) return;
if(!isStaged())
{
return;
}
bool needRedraw = false;
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theUpdateMutex);
switch(nv.getVisitorType())
{
case osg::NodeVisitor::UPDATE_VISITOR:
{
if(isDirtyBitSet(LABEL_DIRTY)&&theLabel.valid())
{
needRedraw = true;
if(theLabel.valid())
{
theLabel->setText(name().c_str());
}
clearDirtyBit(LABEL_DIRTY);
}
if(isDirtyBitSet(COLOR_DIRTY))
{
if(theLabelStyle.valid()&&theLabel.valid())
{
needRedraw = true;
if(theLabelStyle->colorMode() == ossimPlanetAnnotationColorMode_NORMAL)
{
theLabel->setColor(theLabelStyle->color());
}
else
{
theLabel->setColor(osg::Vec4d((ossim_float64)rand()/(ossim_float64)RAND_MAX,
(ossim_float64)rand()/(ossim_float64)RAND_MAX,
(ossim_float64)rand()/(ossim_float64)RAND_MAX,
theLabel->getColor()[3]));
}
}
clearDirtyBit(COLOR_DIRTY);
}
if(theExpireTime.valid())
{
if(theExpireTime->hasExpired())
{
if(theLayer)
{
theLayer->needsRemoving(this);
}
}
needRedraw = true;
}
break;
}
default:
{
break;
}
}
if(theExpireTime.valid())
{
setRedrawFlag(true);
}
osg::ref_ptr<ossimPlanetAnnotationGeometry> geom = geometry();
if(geom.valid())
{
geom->traverse(nv);
}
ossimPlanetAnnotationLayerNode::traverse(nv);
if(needRedraw) setRedrawFlag(true);
}
/*
*******************************************************************
* Function:
*
* Description:
*
* Parameters:
*
* Returns:
*
*******************************************************************
*/
void xDistributedSession::removeUser(xDistributedClient *client)
{
xNetInterface *nInterface = getNetInterface();
if (!nInterface)
{
return;
}
xDistributedClient *myClient = nInterface->getMyClient();
if (client && myClient && client->getUserID() == myClient->getUserID())
{
myClient->setSessionID(-1);
}
if (client)
{
if (isClientJoined(client->getUserID()))
{
//////////////////////////////////////////////////////////////////////////
if (client->getUserID() == getUserID())
{
xLogger::xLog(XL_START,ELOGINFO,E_LI_SESSION,"Session master %d left session %d",client->getUserID(),getSessionID());
if (nInterface)
{
//////////////////////////////////////////////////////////////////////////
//we tag all existing users as new :
IDistributedObjects *doInterface = nInterface->getDistObjectInterface();
xDistributedObjectsArrayType *distObjects = nInterface->getDistributedObjects();
xDistObjectIt begin = distObjects->begin();
xDistObjectIt end = distObjects->end();
while (begin!=end)
{
xDistributedObject *distObject = *begin;
if (distObject)
{
xDistributedClass *_class = distObject->getDistributedClass();
if (_class)
{
if (_class->getEnitityType() == E_DC_BTYPE_CLIENT )
{
xDistributedClient *distClient = static_cast<xDistributedClient*>(distObject);
if (distClient && isClientJoined(distClient->getUserID()))
{
if (isFlagOn(distClient->getClientFlags(),E_CF_SESSION_JOINED))
{
//distClient->setSessionID(-1);
disableFlag(distClient->getClientFlags(),E_CF_SESSION_JOINED);
enableFlag(distClient->getClientFlags(),E_CF_DELETING);
enableFlag(distClient->getClientFlags(),E_CF_SESSION_DESTROYED);
xLogger::xLogExtro(0,"\tRemoving user %d from session",distClient->getUserID(),getSessionID());
}
}
}
}
}
begin++;
}
getClientTable().clear();
goto ENDUPDATE;
return;
}
}
}
if (client->getUserID() != getUserID())
{
enableFlag(client->getClientFlags(),E_CF_REMOVED);
client->setSessionID(-1);
}
//////////////////////////////////////////////////////////////////////////
for(int i = 0 ; i < getClientTable().size() ; i++)
{
std::vector<xDistributedClient*>::iterator begin = getClientTable().begin();
std::vector<xDistributedClient*>::iterator end = getClientTable().end();
while (begin !=end)
{
xDistributedClient *current = *begin;
if (current && current->getUserID() == client->getUserID() )
{
getClientTable().erase(begin);
}
begin++;
}
}
goto ENDUPDATE;
ENDUPDATE :
xDistributedInteger *numUser= (xDistributedInteger *)getProperty(E_DC_S_NP_NUM_USERS);
numUser->updateValue(getClientTable().size(),0);
setNumUsers(getClientTable().size());
int blockIndex = numUser->getBlockIndex();
getUpdateBits().set(1<<blockIndex,true);
setMaskBits(1<<blockIndex);
}else
xLogger::xLog(XL_START,ELOGERROR,E_LI_SESSION,"couldn't find client object");
}
