+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
#include "Atmosphere.hpp"
#include "ControlMap.hpp"
#include "Gear.hpp"
#include "RigidBody.hpp"
#include "Surface.hpp"
#include "Rotorpart.hpp"
-#include "Rotorblade.hpp"
#include "Thruster.hpp"
+#include "Hitch.hpp"
#include "Airplane.hpp"
namespace yasim {
_cruiseT = 0;
_cruiseSpeed = 0;
_cruiseWeight = 0;
+ _cruiseGlideAngle = 0;
_approachP = 0;
_approachT = 0;
_approachSpeed = 0;
_approachAoA = 0;
_approachWeight = 0;
+ _approachGlideAngle = 0;
_dragFactor = 1;
_liftRatio = 1;
_cruiseAoA = 0;
_tailIncidence = 0;
+
+ _failureMsg = 0;
}
Airplane::~Airplane()
delete (Tank*)_tanks.get(i);
for(i=0; i<_thrusters.size(); i++)
delete (ThrustRec*)_thrusters.get(i);
- for(i=0; i<_gears.size(); i++)
- delete (GearRec*)_gears.get(i);
+ for(i=0; i<_gears.size(); i++) {
+ GearRec* g = (GearRec*)_gears.get(i);
+ delete g->gear;
+ delete g;
+ }
for(i=0; i<_surfs.size(); i++)
delete (Surface*)_surfs.get(i);
- for(i=0; i<_contacts.size(); i++)
- delete[] (float*)_contacts.get(i);
+ for(i=0; i<_contacts.size(); i++) {
+ ContactRec* c = (ContactRec*)_contacts.get(i);
+ delete c->gear;
+ delete c;
+ }
for(i=0; i<_solveWeights.size(); i++)
- delete[] (SolveWeight*)_solveWeights.get(i);
+ delete (SolveWeight*)_solveWeights.get(i);
+ for(i=0; i<_cruiseControls.size(); i++)
+ delete (Control*)_cruiseControls.get(i);
+ for(i=0; i<_approachControls.size(); i++) {
+ Control* c = (Control*)_approachControls.get(i);
+ if(c != &_approachElevator)
+ delete c;
+ }
+ delete _wing;
+ delete _tail;
+ for(i=0; i<_vstabs.size(); i++)
+ delete (Wing*)_vstabs.get(i);
+ for(i=0; i<_weights.size(); i++)
+ delete (WeightRec*)_weights.get(i);
}
void Airplane::iterate(float dt)
_model.iterate();
}
-void Airplane::consumeFuel(float dt)
+void Airplane::calcFuelWeights()
{
- // This is a really simple implementation that assumes all engines
- // draw equally from all tanks in proportion to the amount of fuel
- // stored there. Needs to be fixed, but that has to wait for a
- // decision as to what the property interface will look like.
- int i, outOfFuel = 0;
- float fuelFlow = 0, totalFuel = 0.00001; // <-- overflow protection
- for(i=0; i<_thrusters.size(); i++)
- fuelFlow += ((ThrustRec*)_thrusters.get(i))->thruster->getFuelFlow();
- for(i=0; i<_tanks.size(); i++)
- totalFuel += ((Tank*)_tanks.get(i))->fill;
- for(i=0; i<_tanks.size(); i++) {
- Tank* t = (Tank*)_tanks.get(i);
- t->fill -= dt * fuelFlow * (t->fill/totalFuel);
- if(t->fill <= 0) {
- t->fill = 0;
- outOfFuel = 1;
- }
- }
- if(outOfFuel)
- for(int i=0; i<_thrusters.size(); i++)
- ((ThrustRec*)_thrusters.get(i))->thruster->setFuelState(false);
-
- // Set the tank masses on the RigidBody
- for(i=0; i<_tanks.size(); i++) {
+ for(int i=0; i<_tanks.size(); i++) {
Tank* t = (Tank*)_tanks.get(i);
_model.getBody()->setMass(t->handle, t->fill);
}
// Gravity
Glue::geodUp(s->pos, out);
Math::mul3(-9.8f, out, out);
+ Math::vmul33(s->orient, out, out);
+ out[0] = -out[0];
// The regular acceleration
float tmp[3];
- Math::mul3(-1, s->acc, tmp);
- Math::add3(tmp, out, out);
-
// Convert to aircraft coordinates
- Math::vmul33(s->orient, out, out);
+ Math::vmul33(s->orient, s->acc, tmp);
+ tmp[1] = -tmp[1];
+ tmp[2] = -tmp[2];
+
+ Math::add3(tmp, out, out);
// FIXME: rotational & centripetal acceleration needed
}
return ((GearRec*)_gears.get(g))->gear;
}
+Hook* Airplane::getHook()
+{
+ return _model.getHook();
+}
+
+Launchbar* Airplane::getLaunchbar()
+{
+ return _model.getLaunchbar();
+}
+
+Rotorgear* Airplane::getRotorgear()
+{
+ return _model.getRotorgear();
+}
+
void Airplane::updateGearState()
{
for(int i=0; i<_gears.size(); i++) {
}
}
-void Airplane::setApproach(float speed, float altitude, float aoa, float fuel)
+void Airplane::setApproach(float speed, float altitude, float aoa, float fuel, float gla)
{
_approachSpeed = speed;
_approachP = Atmosphere::getStdPressure(altitude);
_approachT = Atmosphere::getStdTemperature(altitude);
_approachAoA = aoa;
_approachFuel = fuel;
+ _approachGlideAngle = gla;
}
-void Airplane::setCruise(float speed, float altitude, float fuel)
+void Airplane::setCruise(float speed, float altitude, float fuel, float gla)
{
_cruiseSpeed = speed;
_cruiseP = Atmosphere::getStdPressure(altitude);
_cruiseAoA = 0;
_tailIncidence = 0;
_cruiseFuel = fuel;
+ _cruiseGlideAngle = gla;
}
void Airplane::setElevatorControl(int control)
return ((Tank*)_tanks.get(tank))->fill;
}
+float Airplane::setFuel(int tank, float fuel)
+{
+ return ((Tank*)_tanks.get(tank))->fill = fuel;
+}
+
float Airplane::getFuelDensity(int tank)
{
return ((Tank*)_tanks.get(tank))->density;
_vstabs.add(vstab);
}
-void Airplane::addRotor(Rotor* rotor)
-{
- _rotors.add(rotor);
-}
-
void Airplane::addFuselage(float* front, float* back, float width,
- float taper, float mid)
+ float taper, float mid,
+ float cx, float cy, float cz, float idrag)
{
Fuselage* f = new Fuselage();
int i;
f->width = width;
f->taper = taper;
f->mid = mid;
+ f->_cx=cx;
+ f->_cy=cy;
+ f->_cz=cz;
+ f->_idrag=idrag;
_fuselages.add(f);
}
_gears.add(g);
}
+void Airplane::addHook(Hook* hook)
+{
+ _model.addHook(hook);
+}
+
+void Airplane::addHitch(Hitch* hitch)
+{
+ _model.addHitch(hitch);
+}
+
+void Airplane::addLaunchbar(Launchbar* launchbar)
+{
+ _model.addLaunchbar(launchbar);
+}
+
void Airplane::addThruster(Thruster* thruster, float mass, float* cg)
{
ThrustRec* t = new ThrustRec();
return _tailIncidence;
}
-char* Airplane::getFailureMsg()
+const char* Airplane::getFailureMsg()
{
return _failureMsg;
}
return _solutionIterations;
}
-void Airplane::setupState(float aoa, float speed, State* s)
+void Airplane::setupState(float aoa, float speed, float gla, State* s)
{
float cosAoA = Math::cos(aoa);
float sinAoA = Math::sin(aoa);
s->orient[3] = 0; s->orient[4] = 1; s->orient[5] = 0;
s->orient[6] = -sinAoA; s->orient[7] = 0; s->orient[8] = cosAoA;
- s->v[0] = speed; s->v[1] = 0; s->v[2] = 0;
+ s->v[0] = speed*Math::cos(gla); s->v[1] = -speed*Math::sin(gla); s->v[2] = 0;
int i;
for(i=0; i<3; i++)
void Airplane::addContactPoint(float* pos)
{
- float* cp = new float[3];
- cp[0] = pos[0];
- cp[1] = pos[1];
- cp[2] = pos[2];
- _contacts.add(cp);
+ ContactRec* c = new ContactRec;
+ c->gear = 0;
+ c->p[0] = pos[0];
+ c->p[1] = pos[1];
+ c->p[2] = pos[2];
+ _contacts.add(c);
}
float Airplane::compileWing(Wing* w)
return wgt;
}
-float Airplane::compileRotor(Rotor* r)
+void Airplane::compileRotorgear()
{
- // Todo: add rotor to model!!!
- // Todo: calc and add mass!!!
- r->compile();
- _model.addRotor(r);
-
- float wgt = 0;
- int i;
- for(i=0; i<r->numRotorparts(); i++) {
- Rotorpart* s = (Rotorpart*)r->getRotorpart(i);
-
- _model.addRotorpart(s);
-
- float mass = s->getWeight();
- mass = mass * Math::sqrt(mass);
- float pos[3];
- s->getPosition(pos);
- _model.getBody()->addMass(mass, pos);
- wgt += mass;
- }
-
- for(i=0; i<r->numRotorblades(); i++) {
- Rotorblade* b = (Rotorblade*)r->getRotorblade(i);
-
- _model.addRotorblade(b);
-
- float mass = b->getWeight();
- mass = mass * Math::sqrt(mass);
- float pos[3];
- b->getPosition(pos);
- _model.getBody()->addMass(mass, pos);
- wgt += mass;
- }
- return wgt;
+ getRotorgear()->compile();
}
float Airplane::compileFuselage(Fuselage* f)
float fwd[3];
Math::sub3(f->front, f->back, fwd);
float len = Math::mag3(fwd);
+ if (len == 0) {
+ _failureMsg = "Zero length fuselage";
+ return 0;
+ }
float wid = f->width;
int segs = (int)Math::ceil(len/wid);
float segWgt = len*wid/segs;
Surface* s = new Surface();
s->setPosition(pos);
float sideDrag = len/wid;
- s->setYDrag(sideDrag);
- s->setZDrag(sideDrag);
- s->setTotalDrag(scale*segWgt);
+ s->setYDrag(sideDrag*f->_cy);
+ s->setZDrag(sideDrag*f->_cz);
+ s->setTotalDrag(scale*segWgt*f->_cx);
+ s->setInducedDrag(f->_idrag);
// FIXME: fails for fuselages aligned along the Y axis
float o[9];
int i;
for(i=0; i<_contacts.size(); i++) {
- float *cp = (float*)_contacts.get(i);
+ ContactRec* c = (ContactRec*)_contacts.get(i);
Gear* g = new Gear();
- g->setPosition(cp);
+ c->gear = g;
+ g->setPosition(c->p);
g->setCompression(comp);
g->setSpring(spring);
// I made these up
g->setStaticFriction(0.6f);
g->setDynamicFriction(0.5f);
+ g->setContactPoint(1);
_model.addGear(g);
}
void Airplane::compile()
{
- double ground[3];
- ground[0] = 0; ground[1] = 0; ground[2] = 1;
- _model.setGroundPlane(ground, -100000);
-
RigidBody* body = _model.getBody();
int firstMass = body->numMasses();
int i;
for(i=0; i<_vstabs.size(); i++)
aeroWgt += compileWing((Wing*)_vstabs.get(i));
- for(i=0; i<_rotors.size(); i++)
- aeroWgt += compileRotor((Rotor*)_rotors.get(i));
-
+
+
// The fuselage(s)
for(i=0; i<_fuselages.size(); i++)
aeroWgt += compileFuselage((Fuselage*)_fuselages.get(i));
t->handle = body->addMass(0, t->pos);
totalFuel += t->cap;
}
- _cruiseWeight = _emptyWeight + totalFuel*0.5f;
- _approachWeight = _emptyWeight + totalFuel*0.2f;
+ _cruiseWeight = _emptyWeight + totalFuel*_cruiseFuel;
+ _approachWeight = _emptyWeight + totalFuel*_approachFuel;
body->recalc();
}
// Ground effect
- float gepos[3];
- float gespan = 0;
- if(_wing)
- gespan = _wing->getGroundEffect(gepos);
- _model.setGroundEffect(gepos, gespan, 0.15f);
+ if(_wing) {
+ float gepos[3];
+ float gespan = 0;
+ gespan = _wing->getGroundEffect(gepos);
+ _model.setGroundEffect(gepos, gespan, 0.15f);
+ }
+
+ // solve function below resets failure message
+ // so check if we have any problems and abort here
+ if (_failureMsg) return;
solveGear();
if(_wing && _tail) solve();
- else solveHelicopter();
+ else
+ {
+ // The rotor(s) mass:
+ compileRotorgear();
+ solveHelicopter();
+ }
// Do this after solveGear, because it creates "gear" objects that
// we don't want to affect.
g->getPosition(pos);
Math::sub3(cg, pos, pos);
gr->wgt = 1.0f/(0.5f+Math::sqrt(pos[0]*pos[0] + pos[1]*pos[1]));
- total += gr->wgt;
+ if (!g->getIgnoreWhileSolving())
+ total += gr->wgt;
}
// Renormalize so they sum to 1
float e = energy * gr->wgt;
float comp[3];
gr->gear->getCompression(comp);
- float len = Math::mag3(comp);
+ float len = Math::mag3(comp)*(1+2*gr->gear->getInitialLoad());
// Energy in a spring: e = 0.5 * k * len^2
float k = 2 * e / (len*len);
// Critically damped (too damped, too!)
gr->gear->setDamping(2*Math::sqrt(k*_approachWeight*gr->wgt)
* gr->gear->getDamping());
-
- // These are pretty generic
- gr->gear->setStaticFriction(0.8f);
- gr->gear->setDynamicFriction(0.7f);
}
}
void Airplane::runCruise()
{
- setupState(_cruiseAoA, _cruiseSpeed, &_cruiseState);
+ setupState(_cruiseAoA, _cruiseSpeed,_cruiseGlideAngle, &_cruiseState);
_model.setState(&_cruiseState);
_model.setAir(_cruiseP, _cruiseT,
Atmosphere::calcStdDensity(_cruiseP, _cruiseT));
void Airplane::runApproach()
{
- setupState(_approachAoA, _approachSpeed, &_approachState);
+ setupState(_approachAoA, _approachSpeed,_approachGlideAngle, &_approachState);
_model.setState(&_approachState);
_model.setAir(_approachP, _approachT,
Atmosphere::calcStdDensity(_approachP, _approachT));
runCruise();
_model.getThrust(tmp);
- float thrust = tmp[0];
+ float thrust = tmp[0] + _cruiseWeight * Math::sin(_cruiseGlideAngle) * 9.81;
_model.getBody()->getAccel(tmp);
Math::tmul33(_cruiseState.orient, tmp, tmp);
{
_solutionIterations = 0;
_failureMsg = 0;
-
- applyDragFactor(Math::pow(15.7/1000, 1/SOLVE_TWEAK));
- applyLiftRatio(Math::pow(104, 1/SOLVE_TWEAK));
- setupState(0,0, &_cruiseState);
+ if (getRotorgear()!=0)
+ {
+ Rotorgear* rg = getRotorgear();
+ applyDragFactor(Math::pow(rg->getYasimDragFactor()/1000,
+ 1/SOLVE_TWEAK));
+ applyLiftRatio(Math::pow(rg->getYasimLiftFactor(),
+ 1/SOLVE_TWEAK));
+ }
+ else
+ //huh, no wing and no rotor? (_rotorgear is constructed,
+ //if a rotor is defined
+ {
+ applyDragFactor(Math::pow(15.7/1000, 1/SOLVE_TWEAK));
+ applyLiftRatio(Math::pow(104, 1/SOLVE_TWEAK));
+ }
+ setupState(0,0,0, &_cruiseState);
_model.setState(&_cruiseState);
+ setupWeights(true);
_controls.reset();
_model.getBody()->reset();
+ _model.setAir(_cruiseP, _cruiseT,
+ Atmosphere::calcStdDensity(_cruiseP, _cruiseT));
+
}
}; // namespace yasim
projects / flightgear.git / blobdiff