ODataPtr OGroup::createData(Alembic::Util::uint64_t iSize, const void * iData)
{
ODataPtr child;
if (isFrozen())
{
return child;
}
if (iSize == 0)
{
mData->childVec.push_back(EMPTY_DATA);
child.reset(new OData());
return child;
}
Alembic::Util::uint64_t pos = mData->stream->getAndSeekEndPos();
Alembic::Util::uint64_t size = iSize;
mData->stream->write(&size, 8);
mData->stream->write(iData, iSize);
child.reset(new OData(mData->stream, pos, iSize));
return child;
}
UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern,
ParsePosition& pos,
uint32_t options,
const SymbolTable* symbols,
UErrorCode& status) {
if (U_FAILURE(status)) {
return *this;
}
if (isFrozen()) {
status = U_NO_WRITE_PERMISSION;
return *this;
}
// Need to build the pattern in a temporary string because
// _applyPattern calls add() etc., which set pat to empty.
UnicodeString rebuiltPat;
RuleCharacterIterator chars(pattern, symbols, pos);
applyPattern(chars, symbols, rebuiltPat, options, &UnicodeSet::closeOver, status);
if (U_FAILURE(status)) return *this;
if (chars.inVariable()) {
// syntaxError(chars, "Extra chars in variable value");
status = U_MALFORMED_SET;
return *this;
}
setPattern(rebuiltPat);
return *this;
}
GlobalDataTypeRegistry::RegistResult GlobalDataTypeRegistry::remove(Entry* dtd)
{
if (!dtd)
{
UAVCAN_ASSERT(0);
return RegistResultInvalidParams;
}
if (isFrozen())
{
return RegistResultFrozen;
}
List* list = selectList(dtd->descriptor.getKind());
if (!list)
{
return RegistResultInvalidParams;
}
list->remove(dtd); // If this call came from regist<>(), that would be enough
Entry* p = list->get(); // But anyway
while (p)
{
Entry* const next = p->getNextListNode();
if (p->descriptor.match(dtd->descriptor.getKind(), dtd->descriptor.getFullName()))
{
list->remove(p);
}
p = next;
}
return RegistResultOk;
}
void OGroup::addEmptyData()
{
if (!isFrozen())
{
mData->childVec.push_back(EMPTY_DATA);
}
}
float MeshEntity::surfaceArea(Material* m) const
{
if(isFrozen() && (m == nullptr || m == mMaterialOverride))
return mSurfaceArea_Cache;
else
return mMesh->surfaceArea(m, flags() & EF_LocalArea ? PM::pm_Identity() : matrix());
}
void OGroup::addEmptyGroup()
{
if (!isFrozen())
{
mData->childVec.push_back(EMPTY_GROUP);
}
}
/*!
\author Luxor
*/
void cChar::follow( pChar pc )
{
if ( isFrozen() ) {
if ( hasPath() )
safedelete( path );
return;
}
if ( dist( getBody()->getPosition(), pc->getBody()->getPosition() ) <= 1.0 ) { // Target reached
if ( hasPath() )
safedelete( path );
facexy( pc->getBody()->getPosition().x, pc->getBody()->getPosition().y );
return;
}
if ( !hasPath() || path->targetReached() ) { // We haven't got a right path, call the pathfinding.
pathFind( pc->getBody()->getPosition(), true );
walkNextStep();
return;
}
double distance = dist( path->getFinalPos(), pc->getBody()->getPosition() );
if ( distance <= 3.0 ) { // Path finalPos is pretty near... let's not overhead the processor
walkNextStep();
} else { // Path finalPos is too far, call the pathfinding.
pathFind( pc->getBody()->getPosition(), true );
walkNextStep();
}
}
void OGroup::addData(ODataPtr iData)
{
if (!isFrozen())
{
mData->childVec.push_back(iData->getPos() | 0x8000000000000000ULL);
}
}
/*!
\author Luxor
*/
void cChar::walkNextStep()
{
if ( isFrozen() )
return;
if ( !hasPath() )
return;
if ( !path->pathFound() )
path->exec();
sLocation pos = path->getNextPos();
if ( pos == getPosition() )
return;
if ( isWalkable( pos, WALKFLAG_DYNAMIC|WALKFLAG_CHARS, this ) == illegal_z ) {
safedelete( path );
return;
}
pCreatureInfo creature = creatures.getCreature( getId() );
if( creature!=NULL ) {
if( creature->canFly() && ( fly_steps>0 ) )
if ( chance( 20 ) )
playAction( 0x13 ); // Flying animation
}
uint8_t dirXY = getDirFromXY(pos);
dir = dirXY & 0x07;
MoveTo( pos );
sendToPlayers( this, dirXY );
setNpcMoveTime();
}
void RBlock::print(QDebug dbg) const {
dbg.nospace() << "RBlock(";
RObject::print(dbg);
dbg.nospace() << ", name: " << getName()
<< ", origin: " << getOrigin()
<< ", frozen: " << isFrozen()
<< ", anonymouse: " << isAnonymous()
<< ")";
}
PM::vec3 DistantLight::sample(const ShaderClosure& point, const PM::vec3& rnd, float& pdf)
{
PR_ASSERT(isFrozen());
pdf = std::numeric_limits<float>::infinity();
return mSampleDirection_Cache;
//return Projection::tangent_align(mSampleDirection_Cache, mRight_Cache, mUp_Cache,
// Projection::cos_hemi(PM::pm_GetX(rnd), PM::pm_GetY(rnd), 32, pdf));
}
OGroupPtr OGroup::addGroup()
{
OGroupPtr child;
if (!isFrozen())
{
mData->childVec.push_back(0);
child.reset(new OGroup(shared_from_this(), mData->childVec.size() - 1));
}
return child;
}
UnicodeSet&
UnicodeSet::applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode& ec) {
if (U_FAILURE(ec) || isFrozen()) return *this;
if (prop == UCHAR_GENERAL_CATEGORY_MASK) {
applyFilter(generalCategoryMaskFilter, &value, UPROPS_SRC_CHAR, ec);
} else {
IntPropertyContext c = {prop, value};
applyFilter(intPropertyFilter, &c, uprops_getSource(prop), ec);
}
return *this;
}
DataTypeSignature GlobalDataTypeRegistry::computeAggregateSignature(DataTypeKind kind,
DataTypeIDMask& inout_id_mask) const
{
UAVCAN_ASSERT(isFrozen()); // Computing the signature if the registry is not frozen is pointless
const List* list = selectList(kind);
if (!list)
{
UAVCAN_ASSERT(0);
return DataTypeSignature();
}
int prev_dtid = -1;
DataTypeSignature signature;
bool signature_initialized = false;
Entry* p = list->get();
while (p)
{
const DataTypeDescriptor& desc = p->descriptor;
const int dtid = desc.getID().get();
if (inout_id_mask[unsigned(dtid)])
{
if (signature_initialized)
{
signature.extend(desc.getSignature());
}
else
{
signature = DataTypeSignature(desc.getSignature());
}
signature_initialized = true;
}
UAVCAN_ASSERT(prev_dtid < dtid); // Making sure that list is ordered properly
prev_dtid++;
while (prev_dtid < dtid)
{
inout_id_mask[unsigned(prev_dtid++)] = false; // Erasing bits for missing types
}
UAVCAN_ASSERT(prev_dtid == dtid);
p = p->getNextListNode();
}
prev_dtid++;
while (prev_dtid <= DataTypeID::Max)
{
inout_id_mask[unsigned(prev_dtid++)] = false;
}
return signature;
}
UnicodeSet&
UnicodeSet::applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode& ec) {
if (U_FAILURE(ec) || isFrozen()) return *this;
if (prop == UCHAR_GENERAL_CATEGORY_MASK) {
applyFilter(generalCategoryMaskFilter, &value, UPROPS_SRC_CHAR, ec);
} else if (prop == UCHAR_SCRIPT_EXTENSIONS) {
UScriptCode script = (UScriptCode)value;
applyFilter(scriptExtensionsFilter, &script, UPROPS_SRC_PROPSVEC, ec);
} else {
IntPropertyContext c = {prop, value};
applyFilter(intPropertyFilter, &c, uprops_getSource(prop), ec);
}
return *this;
}
void OGroup::replaceData(Alembic::Util::uint64_t iIndex, ODataPtr iData)
{
if (!isChildData(iIndex))
{
return;
}
Alembic::Util::uint64_t pos = iData->getPos() | 0x8000000000000000ULL;
if (isFrozen())
{
mData->stream->seek(mData->pos + (iIndex + 1) * 8);
mData->stream->write(&pos, 8);
}
mData->childVec[iIndex] = pos;
}
void OGroup::addGroup(OGroupPtr iGroup)
{
if (!isFrozen())
{
if (iGroup->isFrozen())
{
mData->childVec.push_back(iGroup->mData->pos);
}
else
{
mData->childVec.push_back(EMPTY_GROUP);
iGroup->mData->parents.push_back(
ParentPair(shared_from_this(), mData->childVec.size() - 1));
}
}
}
void cNPC::showName( cUOSocket *socket )
{
if( !socket->player() )
return;
QString charName = name();
// apply titles
if( SrvParams->showNpcTitles() && !title_.isEmpty() )
charName.append( ", " + title_ );
// Append serial for GMs
if( socket->player()->showSerials() )
charName.append( QString( " [0x%1]" ).arg( serial(), 4, 16 ) );
// Frozen
if (isFrozen())
charName.append( tr(" [frozen]") );
// Guarded
if( guardedby_.size() > 0 )
charName.append( tr(" [guarded]") );
// Guarding
if( isTamed() && guarding_ )
charName.append( tr(" [guarding]") );
Q_UINT16 speechColor;
// 0x01 Blue, 0x02 Green, 0x03 Grey, 0x05 Orange, 0x06 Red
switch( notoriety( socket->player() ) )
{
case 0x01: speechColor = 0x59; break; //blue
case 0x02: speechColor = 0x3F; break; //green
case 0x03: speechColor = 0x3B2; break; //grey
case 0x05: speechColor = 0x90; break; //orange
case 0x06: speechColor = 0x22; break; //red
default: speechColor = 0x3B2; break; // grey
}
if (isInvulnerable()) {
speechColor = 0x35;
}
// Show it to the socket
socket->showSpeech( this, charName, speechColor, 3, cUOTxUnicodeSpeech::System );
}
//------------------------------------------------------------------------------
// updateTC() -- update time critical stuff here
//------------------------------------------------------------------------------
void System::updateTC(const LCreal dt0)
{
// We're nothing without an ownship ...
if (ownship == 0 && getOwnship() == 0) return;
// ---
// Delta time
// ---
// real or frozen?
LCreal dt = dt0;
if (isFrozen()) dt = 0.0;
// Delta time for methods that are running every fourth phase
LCreal dt4 = dt * 4.0f;
// ---
// Four phases per frame
// ---
Simulation* sim = ownship->getSimulation();
if (sim == 0) return;
switch (sim->phase()) {
case 0 : // Frame0 --- Dynamics method
dynamics(dt4);
break;
case 1 : // Frame1 --- Transmit method
transmit(dt4);
break;
case 2 : // Frame2 --- Receive method
receive(dt4);
break;
case 3 : // Frame3 --- Process method
process(dt4);
break;
}
// ---
// Last, update our base class
// and use 'dt' because if we're frozen then so are our subcomponents.
// ---
BaseClass::updateTC(dt);
}
// no more children can be added, commit to the stream
void OGroup::freeze()
{
// bail if we've already done this work
if (isFrozen())
{
return;
}
// we ended up not adding any children, so no need to commit this group
// to disk, use empty group instead
if (mData->childVec.empty())
{
mData->pos = 0;
}
else
{
mData->pos = mData->stream->getAndSeekEndPos();
Alembic::Util::uint64_t size = mData->childVec.size();
mData->stream->write(&size, 8);
mData->stream->write(&mData->childVec.front(), size*8);
}
// go through and update each of the parents
ParentPairVec::iterator it;
for(it = mData->parents.begin(); it != mData->parents.end(); ++it)
{
// special group owned by the archive
if (!it->first && it->second == 0)
{
mData->stream->seek(8);
mData->stream->write(&mData->pos, 8);
continue;
}
else if (it->first->isFrozen())
{
mData->stream->seek(it->first->mData->pos + (it->second + 1) * 8);
mData->stream->write(&mData->pos, 8);
}
it->first->mData->childVec[it->second] = mData->pos;
}
mData->parents.clear();
}
Spectrum DistantLight::apply(const PM::vec3& V)
{
if(!mMaterial || !mMaterial->emission())
return Spectrum();
PR_ASSERT(isFrozen());
const float d = PM::pm_Max(0.0f, PM::pm_Dot3D(V, mSampleDirection_Cache));
ShaderClosure sc;
sc.V = V;
sc.Ng = mDirection;
sc.N = mDirection;
sc.Nx = mRight_Cache;
sc.Ny = mUp_Cache;
// UV is zero
return mMaterial->emission()->eval(sc) * d;
}
//------------------------------------------------------------------------------
// nib2PlayerState() --
// Called by our processInputList() to update the state of networked player.
//------------------------------------------------------------------------------
void Nib::nib2PlayerState()
{
models::Player* player = getPlayer();
if (player != nullptr) {
// Drive modes
player->freeze( isFrozen() );
player->setMode( getMode() );
// Appearance
player->setDamage( getDamage() );
player->setSmoke( getSmoke() );
player->setFlames( getFlames() );
player->setCamouflageType( getCamouflageType() );
// IPlayer's position and Euler angles are set by the player
// during its dynamics phase and using our DR functions.
}
}
ODataPtr OGroup::createData(Alembic::Util::uint64_t iNumData,
const Alembic::Util::uint64_t * iSizes,
const void ** iDatas)
{
ODataPtr child;
if (isFrozen())
{
return child;
}
Alembic::Util::uint64_t totalSize = 0;
for (Alembic::Util::uint64_t i = 0; i < iNumData; ++i)
{
totalSize += iSizes[i];
}
if (totalSize == 0)
{
mData->childVec.push_back(EMPTY_DATA);
child.reset(new OData());
return child;
}
Alembic::Util::uint64_t pos = mData->stream->getAndSeekEndPos();
mData->stream->write(&totalSize, 8);
for (Alembic::Util::uint64_t i = 0; i < iNumData; ++i)
{
Alembic::Util::uint64_t size = iSizes[i];
if (size != 0)
{
mData->stream->write(iDatas[i], size);
}
}
child.reset(new OData(mData->stream, pos, totalSize));
return child;
}
/**
* Modifies this set to represent the set specified by the given
* pattern, optionally ignoring white space. See the class
* description for the syntax of the pattern language.
* @param pattern a string specifying what characters are in the set
* @param options bitmask for options to apply to the pattern.
* Valid options are USET_IGNORE_SPACE and USET_CASE_INSENSITIVE.
*/
UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern,
uint32_t options,
const SymbolTable* symbols,
UErrorCode& status) {
if (U_FAILURE(status) || isFrozen()) {
return *this;
}
ParsePosition pos(0);
applyPattern(pattern, pos, options, symbols, status);
if (U_FAILURE(status)) return *this;
int32_t i = pos.getIndex();
if (options & USET_IGNORE_SPACE) {
// Skip over trailing whitespace
ICU_Utility::skipWhitespace(pattern, i, TRUE);
}
if (i != pattern.length()) {
status = U_ILLEGAL_ARGUMENT_ERROR;
}
return *this;
}
void FramerateEqualizer::notifyUpdatePre( Compound* compound,
const uint32_t frameNumber )
{
_init();
// find starting point of contiguous block
const ssize_t size = static_cast< ssize_t >( _times.size( ));
ssize_t from = 0;
if( size > 0 )
{
for( ssize_t i = size-1; i >= 0; --i )
{
if( _times[i].second != 0.f )
continue;
from = i;
break;
}
}
// find max / avg time in block
size_t nSamples = 0;
#ifdef USE_AVERAGE
float sumTime = 0.f;
#else
float maxTime = 0.f;
#endif
for( ++from; from < size && nSamples < _nSamples; ++from )
{
const FrameTime& time = _times[from];
EQASSERT( time.first > 0 );
EQASSERT( time.second != 0.f );
++nSamples;
#ifdef USE_AVERAGE
sumTime += time.second;
#else
maxTime = EQ_MAX( maxTime, time.second );
#endif
EQLOG( LOG_LB2 ) << "Using " << time.first << ", " << time.second
<< "ms" << std::endl;
}
if( nSamples == _nSamples ) // If we have a full set
while( from < static_cast< ssize_t >( _times.size( )))
_times.pop_back(); // delete all older samples
if( isFrozen() || !compound->isRunning( ))
{
// always execute code above to not leak memory
compound->setMaxFPS( std::numeric_limits< float >::max( ));
return;
}
if( nSamples > 0 )
{
//TODO: totalTime *= 1.f - damping;
#ifdef USE_AVERAGE
const float time = (sumTime / nSamples) * SLOWDOWN;
#else
const float time = maxTime * SLOWDOWN;
#endif
const float fps = 1000.f / time;
#ifdef VSYNC_CAP
if( fps > VSYNC_CAP )
compound->setMaxFPS( std::numeric_limits< float >::max( ));
else
#endif
compound->setMaxFPS( fps );
EQLOG( LOG_LB2 ) << fps << " Hz from " << nSamples << "/"
<< _times.size() << " samples, " << time << "ms"
<< std::endl;
}
_times.push_front( FrameTime( frameNumber, 0.f ));
EQASSERT( _times.size() < 210 );
}
//------------------------------------------------------------------------------
// dynamics() -- update player's vehicle dynamics
//------------------------------------------------------------------------------
void JSBSimModel::dynamics(const LCreal dt)
{
// Get our Player (must have one!)
Simulation::Player* p = static_cast<Simulation::Player*>( findContainerByType(typeid(Simulation::Player)) );
if (p == 0) return;
if (fdmex == 0) return;
JSBSim::FGPropagate* Propagate = fdmex->GetPropagate();
if (Propagate == 0) return;
JSBSim::FGFCS* FCS = fdmex->GetFCS();
if (FCS == 0) return;
JSBSim::FGAccelerations* Accelerations = fdmex->GetAccelerations();
if (Accelerations == 0) return;
pitchTrimPos += pitchTrimRate * pitchTrimSw * dt;
if (pitchTrimPos > 1.0) {
pitchTrimPos = 1.0;
} else if (pitchTrimPos < -1.0) {
pitchTrimPos = -1.0;
}
FCS->SetPitchTrimCmd(pitchTrimPos);
rollTrimPos += rollTrimRate * rollTrimSw * dt;
if (rollTrimPos > 1.0) {
rollTrimPos = 1.0;
} else if (rollTrimPos < -1.0) {
rollTrimPos = -1.0;
}
FCS->SetRollTrimCmd(rollTrimPos);
fdmex->Setdt(dt);
// ---
// Pass flags & Data
// ---
#if 0
// CGB TBD
if (isFrozen() || dt == 0) freeze = -1;
else freeze = 0;
if (isPositionFrozen()) posFrz = -1;
else posFrz = 0;
if (isAltitudeFrozen()) altFrz = -1;
else altFrz = 0;
if (isFuelFrozen()) fuelFrz = -1;
else fuelFrz = 0;
rw_elev = getTerrainElevationFt();
#endif
// ---
// Run the model
// ---
fdmex->Run(); //loop JSBSim once w/o integrating
// ---
// Set values for Player & AirVehicle interfaces
// (Note: Player::dynamics() computes the new position)
// ---
p->setAltitude(Basic::Distance::FT2M * Propagate->GetAltitudeASL(), true);
p->setVelocity((LCreal)(Basic::Distance::FT2M * Propagate->GetVel(JSBSim::FGJSBBase::eNorth)), (LCreal)(Basic::Distance::FT2M * Propagate->GetVel(JSBSim::FGJSBBase::eEast)), (LCreal)(Basic::Distance::FT2M * Propagate->GetVel(JSBSim::FGJSBBase::eDown)));
p->setVelocityBody((LCreal)(Basic::Distance::FT2M * Propagate->GetUVW(1)), (LCreal)(Basic::Distance::FT2M * Propagate->GetUVW(2)), (LCreal)(Basic::Distance::FT2M * Propagate->GetUVW(3)));
// LCreal accX = Basic::Distance::FT2M * Propagate->GetUVWdot(1);
// LCreal accY = Basic::Distance::FT2M * Propagate->GetUVWdot(2);
// LCreal accZ = Basic::Distance::FT2M * Propagate->GetUVWdot(3);
const JSBSim::FGMatrix33& Tb2l = Propagate->GetTb2l();
const JSBSim::FGColumnVector3& vUVWdot = Accelerations->GetUVWdot();
p->setEulerAngles((LCreal)(Propagate->GetEuler(JSBSim::FGJSBBase::ePhi)), (LCreal)(Propagate->GetEuler(JSBSim::FGJSBBase::eTht)), (LCreal)(Propagate->GetEuler(JSBSim::FGJSBBase::ePsi)));
p->setAngularVelocities((LCreal)(Propagate->GetPQR(JSBSim::FGJSBBase::eP)), (LCreal)(Propagate->GetPQR(JSBSim::FGJSBBase::eQ)), (LCreal)(Propagate->GetPQR(JSBSim::FGJSBBase::eR)));
JSBSim::FGColumnVector3 vVeldot = Tb2l * vUVWdot;
p->setAcceleration((LCreal)(Basic::Distance::FT2M * vVeldot(1)), (LCreal)(Basic::Distance::FT2M * vVeldot(2)), (LCreal)(Basic::Distance::FT2M * vVeldot(3)));
//std::printf("(%6.1f, %6.1f, %6.1f) vel=%8.1f alt=%8.1f alt2=%8.1f\n", acData->phi, acData->theta, acData->psi, acData->vp, acData->hp, (M2FT*getAltitude()) );
//std::printf("f=%6.1f p=%6.1f, qa=%6.1f, a=%6.1f, g=%6.1f\n", hotasIO->pitchForce, acData->theta, acData->qa, acData->alpha, acData->gamma );
//{
// std::cout << "JSBSim: ---------------------------------" << std::endl;
// osg::Vec4 fq;
// fq.set(acData->e1, acData->e2, acData->e4, acData->e4);
// osg::Matrix m2;
// m2.set(
// acData->l1, acData->l2, acData->l3, 0,
// acData->m1, acData->m2, acData->m3, 0,
// acData->n1, acData->n2, acData->n3, 0,
// 0, 0, 0, 1
// );
// std::printf("Eaagles*EA: (%6.1f, %6.1f, %6.1f)\n", getRollD(), getPitchD(), getHeadingD());
// osg::Matrix m0 = getRotationalMatrix();
// osg::Quat q0 = getQuaternions();
// setRotationalMatrix(m2);
// //setQuaternions(fq);
// osg::Quat eq = getQuaternions();
// osg::Matrix m1 = getRotationalMatrix();
// std::printf("Eaagles EA: (%6.1f, %6.1f, %6.1f)\n", getRollD(), getPitchD(), getHeadingD());
// std::printf("JSBSim EA: (%6.1f, %6.1f, %6.1f)\n", acData->phi, acData->theta, acData->psi);
// std::printf("Eaagles* Q: (%6.3f, %6.3f, %6.3f, %6.3f)\n", q0[0], q0[1], q0[2], q0[3]);
// std::printf("Eaagles Q: (%6.3f, %6.3f, %6.3f, %6.3f)\n", eq[0], eq[1], eq[2], eq[3]);
// std::printf("JSBSim Q: (%6.3f, %6.3f, %6.3f, %6.3f)\n", fq[0], fq[1], fq[2], fq[3]);
// std::printf("Eaagles*mm: (%6.3f, %6.3f, %6.3f, %6.3f)\n", m0(0,0), m0(0,1), m0(0,2), m0(0,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m0(1,0), m0(1,1), m0(1,2), m0(1,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m0(2,0), m0(2,1), m0(2,2), m0(2,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m0(3,0), m0(3,1), m0(3,2), m0(3,3));
// std::printf("Eaagles mm: (%6.3f, %6.3f, %6.3f, %6.3f)\n", m1(0,0), m1(0,1), m1(0,2), m1(0,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m1(1,0), m1(1,1), m1(1,2), m1(1,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m1(2,0), m1(2,1), m1(2,2), m1(2,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m1(3,0), m1(3,1), m1(3,2), m1(3,3));
// std::printf("JSBSim mm: (%6.3f, %6.3f, %6.3f, %6.3f)\n", m2(0,0), m2(0,1), m2(0,2), m2(0,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m2(1,0), m2(1,1), m2(1,2), m2(1,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m2(2,0), m2(2,1), m2(2,2), m2(2,3));
// std::printf(" (%6.3f, %6.3f, %6.3f, %6.3f)\n", m2(3,0), m2(3,1), m2(3,2), m2(3,3));
//}
// CGB Set Autopilot Properties directly for now
JSBSim::FGPropertyManager* propMgr = fdmex->GetPropertyManager();
if (propMgr != 0) {
JSBSim::FGPropertyNode* propNode = propMgr->GetNode();
if (propNode != 0) {
if (hasHeadingHold) {
propNode->SetBool("ap/heading_hold", isHeadingHoldOn());
propNode->SetDouble("ap/heading_setpoint", getCommandedHeadingD());
}
if (hasVelocityHold) {
propNode->SetBool("ap/airspeed_hold", isVelocityHoldOn());
propNode->SetDouble("ap/airspeed_setpoint", getCommandedVelocityKts());
}
if (hasAltitudeHold) {
propNode->SetBool("ap/altitude_hold", isAltitudeHoldOn());
propNode->SetDouble("ap/altitude_setpoint", (getCommandedAltitude() * Basic::Distance::M2FT) );
}
}
}
BaseClass::dynamics(dt);
}
void GrabCardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *) {
if(!isFrozen())
emit grabbed();
goBack();
}
UnicodeSet& UnicodeSet::closeOver(int32_t attribute) {
if (isFrozen() || isBogus()) {
return *this;
}
if (attribute & (USET_CASE_INSENSITIVE | USET_ADD_CASE_MAPPINGS)) {
const UCaseProps *csp = ucase_getSingleton();
{
UnicodeSet foldSet(*this);
UnicodeString str;
USetAdder sa = {
foldSet.toUSet(),
_set_add,
_set_addRange,
_set_addString,
NULL, // don't need remove()
NULL // don't need removeRange()
};
// start with input set to guarantee inclusion
// USET_CASE: remove strings because the strings will actually be reduced (folded);
// therefore, start with no strings and add only those needed
if (attribute & USET_CASE_INSENSITIVE) {
foldSet.strings->removeAllElements();
}
int32_t n = getRangeCount();
UChar32 result;
const UChar *full;
int32_t locCache = 0;
for (int32_t i=0; i<n; ++i) {
UChar32 start = getRangeStart(i);
UChar32 end = getRangeEnd(i);
if (attribute & USET_CASE_INSENSITIVE) {
// full case closure
for (UChar32 cp=start; cp<=end; ++cp) {
ucase_addCaseClosure(csp, cp, &sa);
}
} else {
// add case mappings
// (does not add long s for regular s, or Kelvin for k, for example)
for (UChar32 cp=start; cp<=end; ++cp) {
result = ucase_toFullLower(csp, cp, NULL, NULL, &full, "", &locCache);
addCaseMapping(foldSet, result, full, str);
result = ucase_toFullTitle(csp, cp, NULL, NULL, &full, "", &locCache);
addCaseMapping(foldSet, result, full, str);
result = ucase_toFullUpper(csp, cp, NULL, NULL, &full, "", &locCache);
addCaseMapping(foldSet, result, full, str);
result = ucase_toFullFolding(csp, cp, &full, 0);
addCaseMapping(foldSet, result, full, str);
}
}
}
if (strings != NULL && strings->size() > 0) {
if (attribute & USET_CASE_INSENSITIVE) {
for (int32_t j=0; j<strings->size(); ++j) {
str = *(const UnicodeString *) strings->elementAt(j);
str.foldCase();
if(!ucase_addStringCaseClosure(csp, str.getBuffer(), str.length(), &sa)) {
foldSet.add(str); // does not map to code points: add the folded string itself
}
}
} else {
Locale root("");
#if !UCONFIG_NO_BREAK_ITERATION
UErrorCode status = U_ZERO_ERROR;
BreakIterator *bi = BreakIterator::createWordInstance(root, status);
if (U_SUCCESS(status)) {
#endif
const UnicodeString *pStr;
for (int32_t j=0; j<strings->size(); ++j) {
pStr = (const UnicodeString *) strings->elementAt(j);
(str = *pStr).toLower(root);
foldSet.add(str);
#if !UCONFIG_NO_BREAK_ITERATION
(str = *pStr).toTitle(bi, root);
foldSet.add(str);
#endif
(str = *pStr).toUpper(root);
foldSet.add(str);
(str = *pStr).foldCase();
foldSet.add(str);
}
#if !UCONFIG_NO_BREAK_ITERATION
}
delete bi;
#endif
}
}
*this = foldSet;
}
}
return *this;
}
bool Component::isNotFrozen() const
{
return !isFrozen();
}
UnicodeSet&
UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
const UnicodeString& value,
UErrorCode& ec) {
if (U_FAILURE(ec) || isFrozen()) return *this;
// prop and value used to be converted to char * using the default
// converter instead of the invariant conversion.
// This should not be necessary because all Unicode property and value
// names use only invariant characters.
// If there are any variant characters, then we won't find them anyway.
// Checking first avoids assertion failures in the conversion.
if( !uprv_isInvariantUString(prop.getBuffer(), prop.length()) ||
!uprv_isInvariantUString(value.getBuffer(), value.length())
) {
FAIL(ec);
}
CharString pname, vname;
pname.appendInvariantChars(prop, ec);
vname.appendInvariantChars(value, ec);
if (U_FAILURE(ec)) return *this;
UProperty p;
int32_t v;
UBool mustNotBeEmpty = FALSE, invert = FALSE;
if (value.length() > 0) {
p = u_getPropertyEnum(pname.data());
if (p == UCHAR_INVALID_CODE) FAIL(ec);
// Treat gc as gcm
if (p == UCHAR_GENERAL_CATEGORY) {
p = UCHAR_GENERAL_CATEGORY_MASK;
}
if ((p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) ||
(p >= UCHAR_INT_START && p < UCHAR_INT_LIMIT) ||
(p >= UCHAR_MASK_START && p < UCHAR_MASK_LIMIT)) {
v = u_getPropertyValueEnum(p, vname.data());
if (v == UCHAR_INVALID_CODE) {
// Handle numeric CCC
if (p == UCHAR_CANONICAL_COMBINING_CLASS ||
p == UCHAR_TRAIL_CANONICAL_COMBINING_CLASS ||
p == UCHAR_LEAD_CANONICAL_COMBINING_CLASS) {
char* end;
double value = uprv_strtod(vname.data(), &end);
v = (int32_t) value;
if (v != value || v < 0 || *end != 0) {
// non-integral or negative value, or trailing junk
FAIL(ec);
}
// If the resultant set is empty then the numeric value
// was invalid.
mustNotBeEmpty = TRUE;
} else {
FAIL(ec);
}
}
}
else {
switch (p) {
case UCHAR_NUMERIC_VALUE:
{
char* end;
double value = uprv_strtod(vname.data(), &end);
if (*end != 0) {
FAIL(ec);
}
applyFilter(numericValueFilter, &value, UPROPS_SRC_CHAR, ec);
return *this;
}
case UCHAR_NAME:
{
// Must munge name, since u_charFromName() does not do
// 'loose' matching.
char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength
if (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec);
UChar32 ch = u_charFromName(U_EXTENDED_CHAR_NAME, buf, &ec);
if (U_SUCCESS(ec)) {
clear();
add(ch);
return *this;
} else {
FAIL(ec);
}
}
case UCHAR_UNICODE_1_NAME:
// ICU 49 deprecates the Unicode_1_Name property APIs.
FAIL(ec);
case UCHAR_AGE:
{
// Must munge name, since u_versionFromString() does not do
// 'loose' matching.
char buf[128];
if (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec);
UVersionInfo version;
u_versionFromString(version, buf);
applyFilter(versionFilter, &version, UPROPS_SRC_PROPSVEC, ec);
return *this;
}
case UCHAR_SCRIPT_EXTENSIONS:
v = u_getPropertyValueEnum(UCHAR_SCRIPT, vname.data());
if (v == UCHAR_INVALID_CODE) {
FAIL(ec);
}
// fall through to calling applyIntPropertyValue()
break;
default:
// p is a non-binary, non-enumerated property that we
// don't support (yet).
FAIL(ec);
}
}
}
else {
// value is empty. Interpret as General Category, Script, or
// Binary property.
p = UCHAR_GENERAL_CATEGORY_MASK;
v = u_getPropertyValueEnum(p, pname.data());
if (v == UCHAR_INVALID_CODE) {
p = UCHAR_SCRIPT;
v = u_getPropertyValueEnum(p, pname.data());
if (v == UCHAR_INVALID_CODE) {
p = u_getPropertyEnum(pname.data());
if (p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) {
v = 1;
} else if (0 == uprv_comparePropertyNames(ANY, pname.data())) {
set(MIN_VALUE, MAX_VALUE);
return *this;
} else if (0 == uprv_comparePropertyNames(ASCII, pname.data())) {
set(0, 0x7F);
return *this;
} else if (0 == uprv_comparePropertyNames(ASSIGNED, pname.data())) {
// [:Assigned:]=[:^Cn:]
p = UCHAR_GENERAL_CATEGORY_MASK;
v = U_GC_CN_MASK;
invert = TRUE;
} else {
FAIL(ec);
}
}
}
}
applyIntPropertyValue(p, v, ec);
if(invert) {
complement();
}
if (U_SUCCESS(ec) && (mustNotBeEmpty && isEmpty())) {
// mustNotBeEmpty is set to true if an empty set indicates
// invalid input.
ec = U_ILLEGAL_ARGUMENT_ERROR;
}
if (isBogus() && U_SUCCESS(ec)) {
// We likely ran out of memory. AHHH!
ec = U_MEMORY_ALLOCATION_ERROR;
}
return *this;
}
