void Camera::dragMouse( int x, int y )
{
Vec3f mouseDelta = Vec3f(x,y,0.0f) - mLastMousePosition;
mLastMousePosition = Vec3f(x,y,0.0f);
switch(mCurrentMouseAction)
{
case kActionTranslate:
{
calculateViewingTransformParameters();
double xTrack = -mouseDelta[0] * kMouseTranslationXSensitivity;
double yTrack = mouseDelta[1] * kMouseTranslationYSensitivity;
Vec3f transXAxis = mUpVector ^ (mPosition - mLookAt);
transXAxis /= sqrt((transXAxis*transXAxis));
Vec3f transYAxis = (mPosition - mLookAt) ^ transXAxis;
transYAxis /= sqrt((transYAxis*transYAxis));
setLookAt(getLookAt() + transXAxis*xTrack + transYAxis*yTrack);
break;
}
case kActionRotate:
{
float dAzimuth = -mouseDelta[0] * kMouseRotationSensitivity;
float dElevation = mouseDelta[1] * kMouseRotationSensitivity;
setAzimuth(getAzimuth() + dAzimuth);
setElevation(getElevation() + dElevation);
if (getAzimuth() > M_PI)
mAzimuth -= 2.0*M_PI;
if (getElevation() > M_PI)
mElevation -= 2.0*M_PI;
fprintf(stderr, "az %f, elev %f\n", mAzimuth, mElevation);
break;
}
case kActionZoom:
{
float dDolly = -mouseDelta[1] * kMouseZoomSensitivity;
setDolly(getDolly() + dDolly);
break;
}
case kActionTwist:
// Not implemented
default:
break;
}
}
int GlobalPosition::compareTo(const GlobalPosition &other) const {
int retval = GlobalCoordinates::compareTo(other);
if (retval == 0) {
if (getElevation() < other.getElevation()) {
retval = -1;
} else if (getElevation() > other.getElevation()) {
retval = +1;
}
}
return retval;
}
static void display(void) {
char s[20];
static long fps;
/* Draw the scene */
scene_redraw();
glDisable(GL_LIGHTING);
/* Draw the displays */
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(-1.0, 1.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(-1.0, -1.0, 0.0);
glScalef(0.5, 0.5, 1.0);
drawAEGraph(getAzimuth(), getElevation());
glTranslatef(1.2, 0.0, 0.0);
drawCompass(getRoll());
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
/* Display fps */
sprintf(s, "%.2f", fps);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(-1.0, 1.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glColor3f(1.0, 1.0, 1.0);
glTranslatef(0.75, 0.9, 0.0);
glScalef(0.02, 0.02, 0.02);
draw_text(s);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
/* Re-enable lighting */
glEnable(GL_LIGHTING);
/* Use glFinish() so we don't spin the cube faster than we redraw */
glFinish();
glutSwapBuffers();
}
inet::PlayerState Player::getState()
{
inet::PlayerState p;
p.dir[0] = *(getDir());
p.dir[1] = *(getDir()+1);
p.flyingdir = _state.flyingdir;
p.left = getLeft();
p.depth = getDepth();
p.elevation = getElevation();
p.velocity[0] = *(getVelocity());
p.velocity[1] = *(getVelocity()+1);
p.hp = getHP();
p.mana = getMana();
p.state = _state.state;
p.defence = getDefence();
p.dead = getDead();
strcpy(p.attackid, _state.attackid);
return p;
}
bool Tile::hasElevation(int elevation)
{
return getElevation() >= elevation;
}
void Baro::reset(const StateVector& state)
{
setElevation(state(POSITION_Z) + getElevation());
}
//------------------------------------------------------------------------------
// irRequestSignature() -- Send an IR query packet at all active players to request an IR signature
//------------------------------------------------------------------------------
void IrSeeker::irRequestSignature(IrQueryMsg* const irQuery)
{
// Need something to store the required data for the IR signatures and someone to send to
Tdb* tdb0 = getCurrentTDB();
Player* ownship = getOwnship();
if (irQuery == 0 || tdb0 == 0 || ownship == 0) {
// Clean up and leave
if (tdb0 != 0) tdb0->unref();
return;
}
// ---
// Compute gimbal boresight data for our targets
// ---
// FAB - cannot use ownHdgOnly
unsigned int ntgts = tdb0->computeBoresightData();
if (ntgts > MAX_PLAYERS) ntgts = MAX_PLAYERS;
// ---
// If we have targets
// ---
const osg::Vec3d* losG = tdb0->getGimbalLosVectors();
if (ntgts > 0 && losG != 0) {
// Fetch the required data arrays from the TargetDataBlock
const double* ranges = tdb0->getTargetRanges();
const double* rngRates = tdb0->getTargetRangeRates();
const double* anglesOffBoresight = tdb0->getBoresightErrorAngles();
const osg::Vec3d* losO2T = tdb0->getLosVectors();
const osg::Vec3d* losT2O = tdb0->getTargetLosVectors();
Player** targets = tdb0->getTargets();
LCreal maximumRange = irQuery->getMaxRangeNM()*Basic::Distance::NM2M;
// ---
// Send query packets to the targets
// ---
for (unsigned int i = 0; i < ntgts; i++) {
// filter on sensor max range
// can't filter on sensor range in processPlayers - different sensors can have different max range
if (maximumRange > 0.0 && ranges[i] > maximumRange)
continue;
// Get a free query packet
lcLock(freeQueryLock);
IrQueryMsg* query = freeQueryStack.pop();
lcUnlock(freeQueryLock);
if (query == 0) {
query = new IrQueryMsg();
//if (ownship->getID() != 1) {
// static tcnt = 0;
// tcnt++;
//if (isMessageEnabled(MSG_INFO)) {
// std::cout << "new IrQueryMsg(" << this << "): " << tcnt << ", inused: " << inUseEmQueue.entries() << ", em = " << em << std::endl;
//}
//}
}
// Send the IR query message to the other player
if (query != 0) {
// a) Copy the template query msg
*query = *irQuery;
// b) Set target unique data
query->setGimbal(this);
query->setOwnship(ownship);
query->setRange( LCreal(ranges[i]) );
query->setLosVec( losO2T[i] );
query->setTgtLosVec( losT2O[i] );
query->setRangeRate( LCreal(rngRates[i]) );
query->setTarget(targets[i]);
query->setAngleOffBoresight( LCreal(anglesOffBoresight[i]) );
query->setGimbalAzimuth( LCreal(getAzimuth()) );
query->setGimbalElevation( LCreal(getElevation()) );
// c) Send the query to the target
targets[i]->event(IR_QUERY, query);
// d) Dispose of the query
if (query->getRefCount() <= 1) {
// Recycle the query packet
query->clear();
lcLock(freeQueryLock);
if (freeQueryStack.isNotFull()) {
freeQueryStack.push(query);
}
else {
query->unref();
}
lcUnlock(freeQueryLock);
}
else {
// Store for future reference
lcLock(inUseQueryLock);
if (inUseQueryQueue.isNotFull()) {
inUseQueryQueue.put(query);
}
else {
// Just forget it
query->unref();
}
lcUnlock(inUseQueryLock);
}
}
else {
// When we couldn't get a free query packet
if (isMessageEnabled(MSG_WARNING)) {
std::cerr << "Iw Seeker: OUT OF Query messages!" << std::endl;
}
}
}
}
// Unref() the TDB
tdb0->unref();
}
std::string ElevatedCoordinate::toString() const
{
std::stringstream ss;
ss << getLatitude() << "," << getLongitude() << "," << getElevation();
return ss.str();
}
//------------------------------------------------------------------------------
// rfTransmit() -- Transmit a RF emission packet at all active players.
//------------------------------------------------------------------------------
void Antenna::rfTransmit(Emission* const xmit)
{
// Need something to transmit and someone to send to
Tdb* tdb = getCurrentTDB();
Player* ownship = getOwnship();
if (xmit == 0 || tdb == 0 || ownship == 0) {
// Clean up and leave
if (tdb != 0) tdb->unref();
return;
}
// ---
// Compute gimbal boresight data for our targets
// ---
unsigned int ntgts = tdb->computeBoresightData();
if (ntgts > MAX_PLAYERS) ntgts = MAX_PLAYERS;
// ---
// If we have targets
// ---
const osg::Vec3d* losG = tdb->getGimbalLosVectors();
if (ntgts > 0 && losG != 0) {
// ---
// Lookup gain from antenna gain pattern, compute antenna
// effective gain and effective radiated power.
// ---
bool haveGainTgt = false;
double gainTgt[MAX_PLAYERS];
if (gainPattern != 0) {
Basic::Func1* gainFunc1 = dynamic_cast<Basic::Func1*>(gainPattern);
Basic::Func2* gainFunc2 = dynamic_cast<Basic::Func2*>(gainPattern);
if (gainFunc2 != 0) {
// ---
// Antenna pattern: 2D table (az & el off antenna boresight)
// ---
// Compute azimuth off boresight (radians)
const double* aazr = tdb->getBoresightAzimuthErrors();
// Compute elevation off boresight (radians)
const double* aelr = tdb->getBoresightElevationErrors();
// Lookup gain in 2D table and convert from dB
double gainTgt0[MAX_PLAYERS];
if (gainPatternDeg) {
for (unsigned int i1 = 0; i1 < ntgts; i1++) {
gainTgt0[i1] = gainFunc2->f( (aazr[i1] * Basic::Angle::R2DCC), (aelr[i1] * Basic::Angle::R2DCC) )/10.0;
}
}
else {
for (unsigned int i1 = 0; i1 < ntgts; i1++) {
gainTgt0[i1] = gainFunc2->f( aazr[i1], aelr[i1] )/10.0f;
}
}
pow10Array(gainTgt0, gainTgt, ntgts);
haveGainTgt = true;
}
else if (gainFunc1 != 0) {
// ---
// Antenna Pattern: 1D table (off antenna boresight only
// ---
// Compute angles off antenna boresight (radians)
const double* aar = tdb->getBoresightErrorAngles();
// Lookup gain in 1D table and convert from dB
double gainTgt0[MAX_PLAYERS];
if (gainPatternDeg) {
for (unsigned int i2 = 0; i2 < ntgts; i2++) {
gainTgt0[i2] = gainFunc1->f( aar[i2]*Basic::Angle::R2DCC )/10.0;
}
}
else {
for (unsigned int i2 = 0; i2 < ntgts; i2++) {
gainTgt0[i2] = gainFunc1->f( aar[i2] )/10.0f;
}
}
pow10Array(gainTgt0, gainTgt, ntgts);
haveGainTgt = true;
}
}
if (!haveGainTgt) {
// ---
// No antenna pattern table
// ---
for (unsigned int i = 0; i < ntgts; i++) {
gainTgt[i] = 1.0f;
}
}
// Compute antenna effective gain
double aeGain[MAX_PLAYERS];
multArrayConst(gainTgt, getGain(), aeGain, ntgts);
// Compute Effective Radiated Power (watts) (Equation 2-1)
double erp[MAX_PLAYERS];
multArrayConst(aeGain, xmit->getPower(), erp, ntgts);
// Fetch the required data arrays from the TargetDataBlock
const double* ranges = tdb->getTargetRanges();
const double* rngRates = tdb->getTargetRangeRates();
const osg::Vec3d* losO2T = tdb->getLosVectors();
const osg::Vec3d* losT2O = tdb->getTargetLosVectors();
Player** targets = tdb->getTargets();
// ---
// Send emission packets to the targets
// ---
for (unsigned int i = 0; i < ntgts; i++) {
// Only of power exceeds an optional threshold
if (erp[i] > threshold) {
// Get a free emission packet
Emission* em(0);
if (recycle) {
lcLock(freeEmLock);
em = freeEmStack.pop();
lcUnlock(freeEmLock);
}
bool cloned = false;
if (em == 0) {
// Otherwise, clone a new one
em = xmit->clone();
cloned = true;
}
// Send the emission to the other player
if (em != 0) {
// a) Copy the template emission
if (!cloned) *em = *xmit;
// b) Set target unique data
em->setGimbal(this);
em->setOwnship(ownship);
em->setRange( LCreal(ranges[i]) );
em->setLosVec(losO2T[i]);
em->setTgtLosVec(losT2O[i]);
em->setRangeRate( LCreal(rngRates[i]) );
em->setTarget(targets[i]);
em->setGimbalAzimuth( LCreal(getAzimuth()) );
em->setGimbalElevation( LCreal(getElevation()) );
em->setPower( LCreal(erp[i]) );
em->setGain( LCreal(aeGain[i]) );
em->setPolarization(getPolarization());
em->setLocalPlayersOnly( isLocalPlayersOfInterestOnly() );
// c) Send the emission to the target
targets[i]->event(RF_EMISSION, em);
// d) Recycle the emission
bool recycled = false;
if (recycle) {
lcLock(inUseEmLock);
if (inUseEmQueue.isNotFull()) {
// Store for future reference
inUseEmQueue.put(em);
recycled = true;
}
lcUnlock(inUseEmLock);
}
// or just forget it
else {
em->unref();
}
}
else {
// When we couldn't get a free emission packet
if (isMessageEnabled(MSG_ERROR)) {
std::cerr << "Antenna: OUT OF EMISSIONS!" << std::endl;
}
}
}
}
}
// Unref() the TDB
tdb->unref();
}
