void Attribute<ForceIdentifierEnum8>::reflectAttribute(const RTI::AttributeHandleValuePairSet& theAttributes, int idx) throw (RTI::FederateInternalError)
{
unsigned char data[1];
copyData(theAttributes, idx, data, sizeof(data));
value = ForceIdentifierEnum8(fromNet<unsigned char>(data+0));
std::cout << "Force id " << value;
std::cout << std::endl;
}
//------------------------------------------------------------------------------
// reflectAttributeValues() -- (Input support)
// Called by our FederateAmbassador to update the attribute values for
// this object instance. (Also handles the network to host byte swapping)
//------------------------------------------------------------------------------
void Nib::reflectAttributeValues(const RTI::AttributeHandleValuePairSet& theAttrs)
{
NetIO* netIO = static_cast<NetIO*>(getNetIO());
if (netIO != nullptr && baseEntity != nullptr) {
// PhysicalEntity pointer
PhysicalEntity* physicalEntity = dynamic_cast<PhysicalEntity*>(baseEntity);
RTI::ULong length;
char netBuffer[1000];
for (RTI::ULong j = 0; j < theAttrs.size(); j++ ) {
// get the attribute's handle and data (network byte order)
RTI::AttributeHandle theAttr = theAttrs.getHandle(j);
theAttrs.getValue(j, netBuffer, length);
// Process the attribute
switch ( netIO->findAttributeIndex(theAttr) ) {
// Update Federate ID
case NetIO::ENTITY_IDENTIFIER_AI : {
EntityIdentifierStruct* net = reinterpret_cast<EntityIdentifierStruct*>(&netBuffer);
base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.federateIdentifier.applicationID, net->federateIdentifier.applicationID );
base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.federateIdentifier.siteID, net->federateIdentifier.siteID );
base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.entityNumber, net->entityNumber );
setAttributeUpdateRequiredFlag(NetIO::ENTITY_IDENTIFIER_AI, true);
}
break;
// Update Entity Type
case NetIO::ENTITY_TYPE_AI : {
EntityTypeStruct* net = reinterpret_cast<EntityTypeStruct*>(&netBuffer);
// All bytes except for country
baseEntity->entityType = *net;
base::NetHandler::fromNetOrder(&baseEntity->entityType.countryCode, net->countryCode );
setAttributeUpdateRequiredFlag(NetIO::ENTITY_TYPE_AI, true);
}
break;
// Update Spatial
case NetIO::SPATIAL_AI : {
// NIB's base entity structure pointers
SpatialStruct* spatial = &(baseEntity->spatial);
SpatialRVStruct* spatialRvw = &(baseEntity->spatialRvw);
WorldLocationStruct* worldLocation = &spatialRvw->worldLocation;
OrientationStruct* orientation = &spatialRvw->orientation;
VelocityVectorStruct* velocityVector = &spatialRvw->velocityVector;
AccelerationVectorStruct* accelerationVector = &spatialRvw->accelerationVector;
AngularVelocityVectorStruct* angularVelocity = &spatialRvw->angularVelocity;
// Net buffer component pointers
SpatialStruct* netSpatial = reinterpret_cast<SpatialStruct*>(&netBuffer[0]);
WorldLocationStruct* netWorldLocation = nullptr;
OrientationStruct* netOrientation = nullptr;
VelocityVectorStruct* netVelocityVector = nullptr;
AccelerationVectorStruct* netAccelerationVector = nullptr;
AngularVelocityVectorStruct* netAngularVelocity = nullptr;
// Dead reckoning
spatial->deadReckoningAlgorithm = netSpatial->deadReckoningAlgorithm;
// find network components based on dead reckoning algorithm
// (and set the isFrozen flag)
switch (spatial->deadReckoningAlgorithm) {
case DRM_STATIC : {
SpatialStaticStruct* netSpatialStatic = reinterpret_cast<SpatialStaticStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialStatic->isFrozen;
netWorldLocation = &netSpatialStatic->worldLocation;
netOrientation = &netSpatialStatic->orientation;
}
break;
case DRM_FPW : {
SpatialFPStruct* netSpatialFpw = reinterpret_cast<SpatialFPStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialFpw->isFrozen;
netWorldLocation = &netSpatialFpw->worldLocation;
netOrientation = &netSpatialFpw->orientation;
netVelocityVector = &netSpatialFpw->velocityVector;
}
break;
case DRM_RPW : {
SpatialRPStruct* netSpatialRpw = reinterpret_cast<SpatialRPStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialRpw->isFrozen;
netWorldLocation = &netSpatialRpw->worldLocation;
netOrientation = &netSpatialRpw->orientation;
netVelocityVector = &netSpatialRpw->velocityVector;
netAngularVelocity = &netSpatialRpw->angularVelocity;
}
break;
case DRM_RVW : {
SpatialRVStruct* netSpatialRvw = reinterpret_cast<SpatialRVStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialRvw->isFrozen;
netWorldLocation = &netSpatialRvw->worldLocation;
netOrientation = &netSpatialRvw->orientation;
netVelocityVector = &netSpatialRvw->velocityVector;
netAccelerationVector = &netSpatialRvw->accelerationVector;
netAngularVelocity = &netSpatialRvw->angularVelocity;
}
break;
case DRM_FVW : {
SpatialFVStruct* netSpatialFvw = reinterpret_cast<SpatialFVStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialFvw->isFrozen;
netWorldLocation = &netSpatialFvw->worldLocation;
netOrientation = &netSpatialFvw->orientation;
netVelocityVector = &netSpatialFvw->velocityVector;
netAccelerationVector = &netSpatialFvw->accelerationVector;
}
break;
} // end dead rec switch
if (netWorldLocation != nullptr) {
base::NetHandler::fromNetOrder(&worldLocation->x, netWorldLocation->x);
base::NetHandler::fromNetOrder(&worldLocation->y, netWorldLocation->y);
base::NetHandler::fromNetOrder(&worldLocation->z, netWorldLocation->z);
}
else {
worldLocation->x = 0;
worldLocation->y = 0;
worldLocation->z = 0;
}
if (netOrientation != nullptr) {
base::NetHandler::fromNetOrder(&orientation->phi, netOrientation->phi);
base::NetHandler::fromNetOrder(&orientation->theta, netOrientation->theta);
base::NetHandler::fromNetOrder(&orientation->psi, netOrientation->psi);
}
else {
orientation->phi = 0;
orientation->theta = 0;
orientation->psi = 0;
}
if (netVelocityVector != nullptr) {
base::NetHandler::fromNetOrder(&velocityVector->xVelocity, netVelocityVector->xVelocity);
base::NetHandler::fromNetOrder(&velocityVector->yVelocity, netVelocityVector->yVelocity);
base::NetHandler::fromNetOrder(&velocityVector->zVelocity, netVelocityVector->zVelocity);
}
else {
velocityVector->xVelocity = 0;
velocityVector->yVelocity = 0;
velocityVector->zVelocity = 0;
}
if (netAccelerationVector != nullptr) {
base::NetHandler::fromNetOrder(&accelerationVector->xAcceleration, netAccelerationVector->xAcceleration);
base::NetHandler::fromNetOrder(&accelerationVector->yAcceleration, netAccelerationVector->yAcceleration);
base::NetHandler::fromNetOrder(&accelerationVector->zAcceleration, netAccelerationVector->zAcceleration);
}
else {
accelerationVector->xAcceleration = 0;
accelerationVector->yAcceleration = 0;
accelerationVector->zAcceleration = 0;
}
if (netAngularVelocity != nullptr) {
base::NetHandler::fromNetOrder(&angularVelocity->xAngularVelocity, netAngularVelocity->xAngularVelocity);
base::NetHandler::fromNetOrder(&angularVelocity->yAngularVelocity, netAngularVelocity->yAngularVelocity);
base::NetHandler::fromNetOrder(&angularVelocity->zAngularVelocity, netAngularVelocity->zAngularVelocity);
}
else {
angularVelocity->xAngularVelocity = 0;
angularVelocity->yAngularVelocity = 0;
angularVelocity->zAngularVelocity = 0;
}
setAttributeUpdateRequiredFlag(NetIO::SPATIAL_AI, true);
}
break;
case NetIO::FORCE_IDENTIFIER_AI : {
unsigned char* net = reinterpret_cast<unsigned char*>(&netBuffer);
physicalEntity->forceIdentifier = ForceIdentifierEnum8( *net );
//std::cout << "Recv force: " << physicalEntity->forceIdentifier << std::endl;;
setAttributeUpdateRequiredFlag(NetIO::FORCE_IDENTIFIER_AI, true);
}
break;
} // end -- process attribute switch
} // end -- for each attribute pair
// Update the basic NIB state data with this new data
entityState2Nib();
}
}