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(); } }