speed-dreams/speed-dreams-code
speed-dreams/speed-dreams-code
6
2
Fork 3
Code Issues 8 Pull requests Projects Releases 1 Packages Wiki Activity Actions

change car.cpp collide.cpp differential.cpp sim.h simu.cpp of simuv3

Browse source 
git-svn-id: https://svn.code.sf.net/p/speed-dreams/code/trunk@586 30fe4595-0a0c-4342-8851-515496e4dcbd

Former-commit-id: f52aece8ca4165c8d9c60cd3dda0c013ccc1fe01
Former-commit-id: 46a11bb67998e4399062bfcc4bc333ffc4dd9459
This commit is contained in:
torcs-ng 2009-01-07 13:02:24 +00:00
parent c39f6e9030
commit 22aa5a78e7
5 changed files with 168 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

172
src/modules/simu/simuv3/car.cpp
View file

@ -4,7 +4,7 @@
created : Sun Mar 19 00:05:43 CET 2000 created : Sun Mar 19 00:05:43 CET 2000
copyright : (C) 2000 by Eric Espie copyright : (C) 2000 by Eric Espie
email : torcs@free.fr email : torcs@free.fr
version : $Id: car.cpp,v 1.31 2007/12/14 12:45:43 olethros Exp $ version : $Id: car.cpp,v 1.28 2007/12/01 11:52:15 olethros Exp $
***************************************************************************/ ***************************************************************************/
@ -19,11 +19,15 @@
#include <cstring> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include "sim.h" #include "sim.h"
#undef TEST_ROTATION
const tdble aMax = 0.35; /* */
void void
SimCarConfig(tCar *car) SimCarConfig(tCar *car)
{ {
@ -51,17 +55,17 @@ SimCarConfig(tCar *car)
car->carElt->priv.collision_state.force[0] = 0.0; car->carElt->priv.collision_state.force[0] = 0.0;
} }
car->dimension.x = GfParmGetNum(hdle, SECT_CAR, PRM_LEN, (char*)NULL, 4.7f); car->dimension.x = GfParmGetNum(hdle, SECT_CAR, PRM_LEN, (char*)NULL, 4.7);
car->dimension.y = GfParmGetNum(hdle, SECT_CAR, PRM_WIDTH, (char*)NULL, 1.9f); car->dimension.y = GfParmGetNum(hdle, SECT_CAR, PRM_WIDTH, (char*)NULL, 1.9);
overallwidth = GfParmGetNum(hdle, SECT_CAR, PRM_OVERALLWIDTH, (char*)NULL, car->dimension.y); overallwidth = GfParmGetNum(hdle, SECT_CAR, PRM_OVERALLWIDTH, (char*)NULL, car->dimension.y);
car->dimension.z = GfParmGetNum(hdle, SECT_CAR, PRM_HEIGHT, (char*)NULL, 1.2f); car->dimension.z = GfParmGetNum(hdle, SECT_CAR, PRM_HEIGHT, (char*)NULL, 1.2);
car->mass = GfParmGetNum(hdle, SECT_CAR, PRM_MASS, (char*)NULL, 1500); car->mass = GfParmGetNum(hdle, SECT_CAR, PRM_MASS, (char*)NULL, 1500);
car->Minv = 1.0 / car->mass; car->Minv = 1.0 / car->mass;
gcfr = GfParmGetNum(hdle, SECT_CAR, PRM_FRWEIGHTREP, (char*)NULL, .5f); gcfr = GfParmGetNum(hdle, SECT_CAR, PRM_FRWEIGHTREP, (char*)NULL, .5);
gcfrl = GfParmGetNum(hdle, SECT_CAR, PRM_FRLWEIGHTREP, (char*)NULL, .5f); gcfrl = GfParmGetNum(hdle, SECT_CAR, PRM_FRLWEIGHTREP, (char*)NULL, .5);
gcrrl = GfParmGetNum(hdle, SECT_CAR, PRM_RRLWEIGHTREP, (char*)NULL, .5f); gcrrl = GfParmGetNum(hdle, SECT_CAR, PRM_RRLWEIGHTREP, (char*)NULL, .5);
car->statGC.y = - (gcfr * gcfrl + (1 - gcfr) * gcrrl) * car->dimension.y + car->dimension.y / 2.0; car->statGC.y = - (gcfr * gcfrl + (1 - gcfr) * gcrrl) * car->dimension.y + car->dimension.y / 2.0;
car->statGC.z = GfParmGetNum(hdle, SECT_CAR, PRM_GCHEIGHT, (char*)NULL, .5f); car->statGC.z = GfParmGetNum(hdle, SECT_CAR, PRM_GCHEIGHT, (char*)NULL, .5);
car->tank = GfParmGetNum(hdle, SECT_CAR, PRM_TANK, (char*)NULL, 80); car->tank = GfParmGetNum(hdle, SECT_CAR, PRM_TANK, (char*)NULL, 80);
car->fuel = GfParmGetNum(hdle, SECT_CAR, PRM_FUEL, (char*)NULL, 80); car->fuel = GfParmGetNum(hdle, SECT_CAR, PRM_FUEL, (char*)NULL, 80);
@ -77,9 +81,9 @@ SimCarConfig(tCar *car)
car->fuel = car->tank; car->fuel = car->tank;
} }
car->fuel_prev = car->fuel; car->fuel_prev = car->fuel;
k = k * k; k = k * k;
car->Iinv.x = 12.0 / (car->mass * (car->dimension.y * car->dimension.y + k *car->dimension.z * car->dimension.z)); car->Iinv.x = 12.0 / (car->mass * (car->dimension.y * car->dimension.y + car->dimension.z * car->dimension.z));
car->Iinv.y = 12.0 / (car->mass * (car->dimension.x * car->dimension.x + k * car->dimension.z * car->dimension.z)); car->Iinv.y = 12.0 / (car->mass * (car->dimension.x * car->dimension.x + car->dimension.z * car->dimension.z));
car->Iinv.z = 12.0 / (car->mass * (car->dimension.y * car->dimension.y + k * car->dimension.x * car->dimension.x)); car->Iinv.z = 12.0 / (car->mass * (car->dimension.y * car->dimension.y + k * car->dimension.x * car->dimension.x));
// initialise rotational momentum // initialise rotational momentum
@ -87,7 +91,6 @@ SimCarConfig(tCar *car)
car->rot_mom[i] = 0.0; car->rot_mom[i] = 0.0;
} }
car->rot_mom[SG_W] = 1.0; car->rot_mom[SG_W] = 1.0;
/* configure components */ /* configure components */
w = car->mass * G; w = car->mass * G;
@ -173,12 +176,28 @@ SimCarUpdateForces(tCar *car)
minv = 1.0 / m; minv = 1.0 / m;
w = -m * G; w = -m * G;
/* Weight - Bring weight vector to the car's frame of reference */ /* Weight - Bring weight vector to the car's frame of reference*/
sgVec3 pos = {0.0f, 0.0f, w}; if (0) {
sgRotateVecQuat (pos, car->posQuat); t3Dd original;
F.F.x = pos[SG_X]; t3Dd updated;
F.F.y = pos[SG_Y]; t3Dd angles;
F.F.z = pos[SG_Z]; original.x = 0.0;
original.y = 0.0;
original.z = w;
angles.x = car->DynGCg.pos.ax;
angles.y = car->DynGCg.pos.ay;
angles.z = car->DynGCg.pos.az;
NaiveRotate (original, angles, &updated);
F.F.x = updated.x;
F.F.y = updated.y;
F.F.z = updated.z;
} else {
sgVec3 pos = {0.0f, 0.0f, w};
sgRotateVecQuat (pos, car->posQuat);
F.F.x = pos[SG_X];
F.F.y = pos[SG_Y];
F.F.z = pos[SG_Z];
}
// initial torque 0. // initial torque 0.
F.M.x = F.M.y = F.M.z = 0; F.M.x = F.M.y = F.M.z = 0;
@ -300,12 +319,13 @@ SimCarUpdateSpeed(tCar *car)
t3Dd original; t3Dd original;
t3Dd updated; t3Dd updated;
t3Dd angles; t3Dd angles;
int i;
tdble mass; tdble mass;
tdble vel, Rr, Rm; /* Rolling Resistance */
mass = car->mass + car->fuel; mass = car->mass + car->fuel;
{ {
// fuel consumption
tdble delta_fuel = car->fuel_prev - car->fuel; tdble delta_fuel = car->fuel_prev - car->fuel;
car->fuel_prev = car->fuel; car->fuel_prev = car->fuel;
if (delta_fuel > 0) { if (delta_fuel > 0) {
@ -314,28 +334,51 @@ SimCarUpdateSpeed(tCar *car)
tdble fi; tdble fi;
tdble as = sqrt(car->airSpeed2); tdble as = sqrt(car->airSpeed2);
if (as<0.1) { if (as<0.1) {
fi = 99.9f; fi = 99.9;
} else { } else {
fi = 100000 * delta_fuel / (as*SimDeltaTime); fi = 100000 * delta_fuel / (as*SimDeltaTime);
} }
tdble alpha = 0.1f; tdble alpha = 0.1;
car->carElt->_fuelInstant = (1.0-alpha)*car->carElt->_fuelInstant + alpha*fi; car->carElt->_fuelInstant = (1.0-alpha)*car->carElt->_fuelInstant + alpha*fi;
} }
// update angles
angles.x = car->DynGCg.pos.ax; angles.x = car->DynGCg.pos.ax;
angles.y = car->DynGCg.pos.ay; angles.y = car->DynGCg.pos.ay;
angles.z = car->DynGCg.pos.az; angles.z = car->DynGCg.pos.az;
// update linear velocity
car->DynGCg.vel.x += car->DynGCg.acc.x * SimDeltaTime; car->DynGCg.vel.x += car->DynGCg.acc.x * SimDeltaTime;
car->DynGCg.vel.y += car->DynGCg.acc.y * SimDeltaTime; car->DynGCg.vel.y += car->DynGCg.acc.y * SimDeltaTime;
car->DynGCg.vel.z += car->DynGCg.acc.z * SimDeltaTime; car->DynGCg.vel.z += car->DynGCg.acc.z * SimDeltaTime;
if (0) {
Rr = 0;
for (i = 0; i < 4; i++) {
Rr += car->wheel[i].rollRes;
}
Rm = Rr * car->wheelbase /* / 2.0 */ * car->Iinv.z * SimDeltaTime;
Rr = 2.0 * Rr / mass * SimDeltaTime;
vel = sqrt(car->DynGCg.vel.x * car->DynGCg.vel.x + car->DynGCg.vel.y * car->DynGCg.vel.y + car->DynGCg.vel.z * car->DynGCg.vel.z);
if (Rr > vel) {
Rr = vel;
}
if (vel > 0.00001) {
car->DynGCg.vel.x -= (car->DynGCg.vel.x) * Rr / vel;
car->DynGCg.vel.y -= (car->DynGCg.vel.y) * Rr / vel;
car->DynGCg.vel.z -= (car->DynGCg.vel.z) * Rr / vel;
} else {
car->DynGCg.vel.x -= (car->DynGCg.vel.x) * Rr; // vel;
car->DynGCg.vel.y -= (car->DynGCg.vel.y) * Rr; // vel;
car->DynGCg.vel.z -= (car->DynGCg.vel.z) * Rr; // vel;
}
}
/* We need to get the speed on the actual frame of reference /* We need to get the speed on the actual frame of reference
for the car. Now we don't need to worry about the world's for the car. Now we don't need to worry about the world's
coordinates anymore when we calculate stuff. I.E check coordinates anymore when we calculate stuff. I.E check
aero.cpp*/ aero.cpp*/
original.x = car->DynGCg.vel.x; original.x = car->DynGCg.vel.x;
original.y = car->DynGCg.vel.y; original.y = car->DynGCg.vel.y;
original.z = car->DynGCg.vel.z; original.z = car->DynGCg.vel.z;
@ -345,25 +388,25 @@ SimCarUpdateSpeed(tCar *car)
car->DynGC.vel.z = updated.z; car->DynGC.vel.z = updated.z;
// Update angular momentum
// ANGULAR VELOCITIES
car->rot_mom[SG_X] -= car->rot_acc[0] * SimDeltaTime; car->rot_mom[SG_X] -= car->rot_acc[0] * SimDeltaTime;
car->rot_mom[SG_Y] -= car->rot_acc[1] * SimDeltaTime; car->rot_mom[SG_Y] -= car->rot_acc[1] * SimDeltaTime;
car->rot_mom[SG_Z] -= car->rot_acc[2] * SimDeltaTime; car->rot_mom[SG_Z] -= car->rot_acc[2] * SimDeltaTime;
#if 0 #if 0
// spin limitation
if (Rm > fabs(car->rot_mom[SG_Z])) { if (Rm > fabs(car->rot_mom[SG_Z])) {
Rm = fabs(car->rot_mom[SG_Z]); Rm = fabs(car->rot_mom[SG_Z]);
} }
car->rot_mom[SG_Z] -= Rm * SIGN(car->rot_mom[SG_Z]); car->rot_mom[SG_Z] -= Rm * SIGN(car->rot_mom[SG_Z]);
#endif #endif
// Translate angular momentum to angular velocity
// NOTE: This translation is done again in SimCarAddAngularVelocity()
car->DynGCg.vel.ax = car->DynGC.vel.ax = -2.0f*car->rot_mom[SG_X] * car->Iinv.x; car->DynGCg.vel.ax = car->DynGC.vel.ax = -2.0f*car->rot_mom[SG_X] * car->Iinv.x;
car->DynGCg.vel.ay = car->DynGC.vel.ay = -2.0f*car->rot_mom[SG_Y] * car->Iinv.y; car->DynGCg.vel.ay = car->DynGC.vel.ay = -2.0f*car->rot_mom[SG_Y] * car->Iinv.y;
car->DynGCg.vel.az = car->DynGC.vel.az = -2.0f*car->rot_mom[SG_Z] * car->Iinv.z; car->DynGCg.vel.az = car->DynGC.vel.az = -2.0f*car->rot_mom[SG_Z] * car->Iinv.z;
//printf ("%f %f\n", car->DynGC.vel.az, -2.0f * car->rot_mom[SG_Z] * car->Iinv.z);
} }
void void
@ -372,6 +415,7 @@ SimCarUpdateWheelPos(tCar *car)
tdble vx = car->DynGC.vel.x; tdble vx = car->DynGC.vel.x;
tdble vy = car->DynGC.vel.y; tdble vy = car->DynGC.vel.y;
tdble vz = car->DynGC.vel.z; tdble vz = car->DynGC.vel.z;
//sgQuat* Q = &car->posQuat;
/* Wheels data */ /* Wheels data */
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
@ -388,13 +432,24 @@ SimCarUpdateWheelPos(tCar *car)
pos3[SG_Y] = wheel->staticPos.y; pos3[SG_Y] = wheel->staticPos.y;
pos3[SG_Z] = -car->statGC.z; pos3[SG_Z] = -car->statGC.z;
#if 0
angles.x = car->DynGCg.pos.ax;
angles.y = car->DynGCg.pos.ay;
angles.z = car->DynGCg.pos.az;
NaiveInverseRotate (pos, angles, &wheel->pos);
wheel->pos.x += car->DynGC.pos.x;
wheel->pos.y += car->DynGC.pos.y;
wheel->pos.z += car->DynGC.pos.z;
#else
sgRotateCoordQuat (pos3, car->posQuat); sgRotateCoordQuat (pos3, car->posQuat);
wheel->pos.x = pos3[SG_X] + car->DynGC.pos.x; wheel->pos.x = pos3[SG_X] + car->DynGC.pos.x;
wheel->pos.y = pos3[SG_Y] + car->DynGC.pos.y; wheel->pos.y = pos3[SG_Y] + car->DynGC.pos.y;
wheel->pos.z = pos3[SG_Z] + car->DynGC.pos.z; wheel->pos.z = pos3[SG_Z] + car->DynGC.pos.z;
#endif
// these will be taken into account in wheel.cpp
// these two will be taken into account in wheel.cpp
// angles.x += wheel->relPos.ax; // angles.x += wheel->relPos.ax;
// angles.z += wheel->steer + wheel->staticPos.az; // angles.z += wheel->steer + wheel->staticPos.az;
@ -415,26 +470,33 @@ SimCarUpdateWheelPos(tCar *car)
static void static void
SimCarUpdatePos(tCar *car) SimCarUpdatePos(tCar *car)
{ {
tdble vx, vy, vz; tdble vx, vy;
tdble accx, accy;
vx = car->DynGCg.vel.x; vx = car->DynGCg.vel.x;
vy = car->DynGCg.vel.y; vy = car->DynGCg.vel.y;
vz = car->DynGCg.vel.z;
accx = car->DynGCg.acc.x;
accy = car->DynGCg.acc.y;
car->DynGCg.pos.x = car->DynGC.pos.x; car->DynGCg.pos.x = car->DynGC.pos.x;
car->DynGCg.pos.y = car->DynGC.pos.y; car->DynGCg.pos.y = car->DynGC.pos.y;
car->DynGCg.pos.z = car->DynGC.pos.z; car->DynGCg.pos.z = car->DynGC.pos.z;
car->DynGCg.pos.x += vx * SimDeltaTime; car->DynGCg.pos.x += vx * SimDeltaTime;
car->DynGCg.pos.y += vy * SimDeltaTime; car->DynGCg.pos.y += vy * SimDeltaTime;
car->DynGCg.pos.z += vz * SimDeltaTime; car->DynGCg.pos.z += car->DynGCg.vel.z * SimDeltaTime;
car->DynGC.pos.x = car->DynGCg.pos.x; car->DynGC.pos.x = car->DynGCg.pos.x;
car->DynGC.pos.y = car->DynGCg.pos.y; car->DynGC.pos.y = car->DynGCg.pos.y;
car->DynGC.pos.z = car->DynGCg.pos.z; car->DynGC.pos.z = car->DynGCg.pos.z;
//zyx works ok for x rotation
SimCarAddAngularVelocity(car); SimCarAddAngularVelocity(car);
NORM_PI_PI(car->DynGC.pos.ax); NORM_PI_PI(car->DynGC.pos.ax);
NORM_PI_PI(car->DynGC.pos.ay); NORM_PI_PI(car->DynGC.pos.ay);
NORM_PI_PI(car->DynGC.pos.az); NORM_PI_PI(car->DynGC.pos.az);
@ -454,16 +516,31 @@ SimCarUpdateCornerPos(tCar *car)
tdble vz = car->DynGC.vel.z; tdble vz = car->DynGC.vel.z;
int i; int i;
#if 0
t3Dd angles;
angles.x = car->DynGCg.pos.ax;
angles.y = car->DynGCg.pos.ay;
angles.z = car->DynGCg.pos.az;
#endif
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
tDynPt *corner = &(car->corner[i]); tDynPt *corner = &(car->corner[i]);
#if 0
pos.x = corner->pos.x;
pos.y = corner->pos.y;
pos.z = -car->statGC.z;
NaiveInverseRotate (pos, angles, &pos);
corner->pos.ax = car->DynGCg.pos.x + pos.x;
corner->pos.ay = car->DynGCg.pos.y + pos.y;
corner->pos.az = car->DynGCg.pos.z + pos.z;
#else
sgVec3 v = {corner->pos.x, corner->pos.y, -car->statGC.z}; sgVec3 v = {corner->pos.x, corner->pos.y, -car->statGC.z};
sgRotateCoordQuat (v, car->posQuat); sgRotateCoordQuat (v, car->posQuat);
corner->pos.ax = car->DynGCg.pos.x + v[SG_X]; corner->pos.ax = car->DynGCg.pos.x + v[SG_X];
corner->pos.ay = car->DynGCg.pos.y + v[SG_Y]; corner->pos.ay = car->DynGCg.pos.y + v[SG_Y];
corner->pos.az = car->DynGCg.pos.z + v[SG_Z]; corner->pos.az = car->DynGCg.pos.z + v[SG_Z];
#endif
// the following is local - confusing a bit.. vel local is // the following is local - confusing a bit.. vel local is
// .ax, global is .x contrary to pos [was like that in previous code, // .ax, global is .x contrary to pos [was like that in previous code,
// might redo it when I have time to look through all // might redo it when I have time to look through all
@ -475,11 +552,22 @@ SimCarUpdateCornerPos(tCar *car)
// calculate global frame velocity. // calculate global frame velocity.
#if 0
t3Dd vel;
vel.x = corner->vel.ax;
vel.y = corner->vel.ay;
vel.z = corner->vel.az;
NaiveInverseRotate (vel, angles, &vel);
corner->vel.x = car->DynGCg.vel.x + vel.x;
corner->vel.y = car->DynGCg.vel.y + vel.y;
corner->vel.z = car->DynGCg.vel.z + vel.z;
#else
sgVec3 vel = {corner->vel.ax, corner->vel.ay, corner->vel.az}; sgVec3 vel = {corner->vel.ax, corner->vel.ay, corner->vel.az};
sgRotateCoordQuat (vel, car->posQuat); sgRotateCoordQuat (vel, car->posQuat);
corner->vel.x = car->DynGCg.vel.x + vel[SG_X]; corner->vel.x = car->DynGCg.vel.x + vel[SG_X];
corner->vel.y = car->DynGCg.vel.y + vel[SG_Y]; corner->vel.y = car->DynGCg.vel.y + vel[SG_Y];
corner->vel.z = car->DynGCg.vel.z + vel[SG_Z]; corner->vel.z = car->DynGCg.vel.z + vel[SG_Z];
#endif
// don't forget to add local frame velocity. // don't forget to add local frame velocity.
corner->vel.ax += vx; corner->vel.ax += vx;
@ -492,8 +580,9 @@ SimCarUpdateCornerPos(tCar *car)
void void
SimTelemetryOut(tCar *car) SimTelemetryOut(tCar *car)
{ {
tdble Fzf, Fzr;
int i; int i;
tdble Fzf, Fzr;
#if 0
printf("-----------------------------\nCar: %d %s ---\n", car->carElt->index, car->carElt->_name); printf("-----------------------------\nCar: %d %s ---\n", car->carElt->index, car->carElt->_name);
printf("Seg: %d (%s) Ts:%f Tr:%f\n", printf("Seg: %d (%s) Ts:%f Tr:%f\n",
car->trkPos.seg->id, car->trkPos.seg->name, car->trkPos.toStart, car->trkPos.toRight); car->trkPos.seg->id, car->trkPos.seg->name, car->trkPos.toStart, car->trkPos.toRight);
@ -515,6 +604,7 @@ SimTelemetryOut(tCar *car)
Fzr = (car->aero.lift[1] + car->wing[1].forces.z) / 9.81; Fzr = (car->aero.lift[1] + car->wing[1].forces.z) / 9.81;
printf("%f %f %f %f %f\n", car->aero.drag / 9.81, Fzf + Fzr, printf("%f %f %f %f %f\n", car->aero.drag / 9.81, Fzf + Fzr,
Fzf, Fzr, (Fzf + Fzr) / (car->aero.drag + 0.1) * 9.81); Fzf, Fzr, (Fzf + Fzr) / (car->aero.drag + 0.1) * 9.81);
#endif
// for (i=0; i<4; i++) { // for (i=0; i<4; i++) {
// printf ("%f ", car->wheel[i].spinVel); // printf ("%f ", car->wheel[i].spinVel);
//} //}
@ -542,11 +632,9 @@ SimCarUpdate(tCar *car, tSituation * /* s */)
void void
SimCarUpdate2(tCar *car, tSituation * /* s */) SimCarUpdate2(tCar *car, tSituation * /* s */)
{ {
#if 0
if (SimTelemetry == car->carElt->index) SimTelemetryOut(car);
static int cnt = 10; static int cnt = 10;
if (SimTelemetry == car->carElt->index) SimTelemetryOut(car);
#if 0
cnt--; cnt--;
if (cnt<=0) { if (cnt<=0) {

6
src/modules/simu/simuv3/collide.cpp
View file

@ -224,9 +224,9 @@ SimCarCollideZ(tCar *car)
car->rot_mom[i] = 2.0*car->mass * SIGN(car->rot_mom[i]); car->rot_mom[i] = 2.0*car->mass * SIGN(car->rot_mom[i]);
} }
} }
car->rot_mom[SG_X]*=.999f; car->rot_mom[SG_X]*=.999;
car->rot_mom[SG_Y]*=.999f; car->rot_mom[SG_Y]*=.999;
car->rot_mom[SG_Z]*=.999f; car->rot_mom[SG_Z]*=.999;
car->DynGC.vel.ax = car->DynGCg.vel.ax = -2.0f*car->rot_mom[SG_X] * car->Iinv.x; car->DynGC.vel.ax = car->DynGCg.vel.ax = -2.0f*car->rot_mom[SG_X] * car->Iinv.x;
car->DynGC.vel.ay = car->DynGCg.vel.ay = -2.0f*car->rot_mom[SG_Y] * car->Iinv.y; car->DynGC.vel.ay = car->DynGCg.vel.ay = -2.0f*car->rot_mom[SG_Y] * car->Iinv.y;
car->DynGC.vel.az = car->DynGCg.vel.az = -2.0f*car->rot_mom[SG_Z] * car->Iinv.z; car->DynGC.vel.az = car->DynGCg.vel.az = -2.0f*car->rot_mom[SG_Z] * car->Iinv.z;

22
src/modules/simu/simuv3/differential.cpp
View file

@ -20,19 +20,19 @@
#include "sim.h" #include "sim.h"
void void
SimDifferentialConfig(void *hdle, const char *section, tDifferential *differential) SimDifferentialConfig(void *hdle, char *section, tDifferential *differential)
{ {
const char *type; char *type;
differential->I = GfParmGetNum(hdle, section, PRM_INERTIA, (char*)NULL, 0.1f); differential->I = GfParmGetNum(hdle, section, PRM_INERTIA, (char*)NULL, 0.1);
differential->efficiency = GfParmGetNum(hdle, section, PRM_EFFICIENCY, (char*)NULL, 1.0f); differential->efficiency = GfParmGetNum(hdle, section, PRM_EFFICIENCY, (char*)NULL, 1.0);
differential->ratio = GfParmGetNum(hdle, section, PRM_RATIO, (char*)NULL, 1.0f); differential->ratio = GfParmGetNum(hdle, section, PRM_RATIO, (char*)NULL, 1.0);
differential->bias = GfParmGetNum(hdle, section, PRM_BIAS, (char*)NULL, 0.1f); differential->bias = GfParmGetNum(hdle, section, PRM_BIAS, (char*)NULL, 0.1);
differential->dTqMin = GfParmGetNum(hdle, section, PRM_MIN_TQ_BIAS, (char*)NULL, 0.05f); differential->dTqMin = GfParmGetNum(hdle, section, PRM_MIN_TQ_BIAS, (char*)NULL, 0.05);
differential->dTqMax = GfParmGetNum(hdle, section, PRM_MAX_TQ_BIAS, (char*)NULL, 0.80f) - differential->dTqMin; differential->dTqMax = GfParmGetNum(hdle, section, PRM_MAX_TQ_BIAS, (char*)NULL, 0.80) - differential->dTqMin;
differential->dSlipMax = GfParmGetNum(hdle, section, PRM_MAX_SLIP_BIAS, (char*)NULL, 0.75f); differential->dSlipMax = GfParmGetNum(hdle, section, PRM_MAX_SLIP_BIAS, (char*)NULL, 0.75);
differential->lockInputTq = GfParmGetNum(hdle, section, PRM_LOCKING_TQ, (char*)NULL, 300.0f); differential->lockInputTq = GfParmGetNum(hdle, section, PRM_LOCKING_TQ, (char*)NULL, 300.0);
differential->viscosity = GfParmGetNum(hdle, section, PRM_VISCOSITY_FACTOR, (char*)NULL, 2.0f); differential->viscosity = GfParmGetNum(hdle, section, PRM_VISCOSITY_FACTOR, (char*)NULL, 2.0);
differential->viscomax = 1 - exp(-differential->viscosity); differential->viscomax = 1 - exp(-differential->viscosity);
type = GfParmGetStr(hdle, section, PRM_TYPE, VAL_DIFF_NONE); type = GfParmGetStr(hdle, section, PRM_TYPE, VAL_DIFF_NONE);

2
src/modules/simu/simuv3/sim.h
View file

@ -22,7 +22,7 @@
#include <math.h> #include <math.h>
#include <stdio.h> #include <stdio.h>
#include <cstring> #include <string>
#ifdef WIN32 #ifdef WIN32
#include <float.h> #include <float.h>
#define isnan _isnan #define isnan _isnan

46
src/modules/simu/simuv3/simu.cpp
View file

@ -84,22 +84,22 @@ ctrlCheck(tCar *car)
/* When the car is broken try to send it on the track side */ /* When the car is broken try to send it on the track side */
if (car->carElt->_state & RM_CAR_STATE_BROKEN) { if (car->carElt->_state & RM_CAR_STATE_BROKEN) {
car->ctrl->accelCmd = 0.0f; car->ctrl->accelCmd = 0.0;
car->ctrl->brakeCmd = 0.1f; car->ctrl->brakeCmd = 0.1;
car->ctrl->gear = 0; car->ctrl->gear = 0;
if (car->trkPos.toRight > car->trkPos.seg->width / 2.0) { if (car->trkPos.toRight > car->trkPos.seg->width / 2.0) {
car->ctrl->steer = 0.1f; car->ctrl->steer = 0.1;
} else { } else {
car->ctrl->steer = -0.1f; car->ctrl->steer = -0.1;
} }
} else if (car->carElt->_state & RM_CAR_STATE_ELIMINATED) { } else if (car->carElt->_state & RM_CAR_STATE_ELIMINATED) {
car->ctrl->accelCmd = 0.0f; car->ctrl->accelCmd = 0.0;
car->ctrl->brakeCmd = 0.1f; car->ctrl->brakeCmd = 0.1;
car->ctrl->gear = 0; car->ctrl->gear = 0;
if (car->trkPos.toRight > car->trkPos.seg->width / 2.0) { if (car->trkPos.toRight > car->trkPos.seg->width / 2.0) {
car->ctrl->steer = 0.1f; car->ctrl->steer = 0.1;
} else { } else {
car->ctrl->steer = -0.1f; car->ctrl->steer = -0.1;
} }
} else if (car->carElt->_state & RM_CAR_STATE_FINISH) { } else if (car->carElt->_state & RM_CAR_STATE_FINISH) {
/* when the finish line is passed, continue at "slow" pace */ /* when the finish line is passed, continue at "slow" pace */
@ -111,24 +111,24 @@ ctrlCheck(tCar *car)
/* check boundaries */ /* check boundaries */
if (car->ctrl->accelCmd > 1.0) { if (car->ctrl->accelCmd > 1.0) {
car->ctrl->accelCmd = 1.0f; car->ctrl->accelCmd = 1.0;
} else if (car->ctrl->accelCmd < 0.0) { } else if (car->ctrl->accelCmd < 0.0) {
car->ctrl->accelCmd = 0.0f; car->ctrl->accelCmd = 0.0;
} }
if (car->ctrl->brakeCmd > 1.0) { if (car->ctrl->brakeCmd > 1.0) {
car->ctrl->brakeCmd = 1.0f; car->ctrl->brakeCmd = 1.0;
} else if (car->ctrl->brakeCmd < 0.0) { } else if (car->ctrl->brakeCmd < 0.0) {
car->ctrl->brakeCmd = 0.0; car->ctrl->brakeCmd = 0.0;
} }
if (car->ctrl->clutchCmd > 1.0) { if (car->ctrl->clutchCmd > 1.0) {
car->ctrl->clutchCmd = 1.0f; car->ctrl->clutchCmd = 1.0;
} else if (car->ctrl->clutchCmd < 0.0) { } else if (car->ctrl->clutchCmd < 0.0) {
car->ctrl->clutchCmd = 0.0f; car->ctrl->clutchCmd = 0.0;
} }
if (car->ctrl->steer > 1.0) { if (car->ctrl->steer > 1.0) {
car->ctrl->steer = 1.0f; car->ctrl->steer = 1.0;
} else if (car->ctrl->steer < -1.0) { } else if (car->ctrl->steer < -1.0) {
car->ctrl->steer = -1.0f; car->ctrl->steer = -1.0;
} }
clutch->transferValue = 1.0 - car->ctrl->clutchCmd; clutch->transferValue = 1.0 - car->ctrl->clutchCmd;
@ -175,15 +175,15 @@ SimReConfig(tCarElt *carElt)
} }
if (carElt->pitcmd.repair > 0) { if (carElt->pitcmd.repair > 0) {
for (int i=0; i<4; i++) { for (int i=0; i<4; i++) {
carElt->_tyreCondition(i) = 1.01f; carElt->_tyreCondition(i) = 1.01;
carElt->_tyreT_in(i) = 50.0f; carElt->_tyreT_in(i) = 50.0;
carElt->_tyreT_mid(i) = 50.0f; carElt->_tyreT_mid(i) = 50.0;
carElt->_tyreT_out(i) = 50.0f; carElt->_tyreT_out(i) = 50.0;
car->wheel[i].bent_damage_x = urandom(); car->wheel[i].bent_damage_x = urandom();
car->wheel[i].bent_damage_z = urandom(); car->wheel[i].bent_damage_z = urandom();
car->wheel[i].rotational_damage_x = 0.0f; car->wheel[i].rotational_damage_x = 0.0;
car->wheel[i].rotational_damage_z = 0.0f; car->wheel[i].rotational_damage_z = 0.0;
car->wheel[i].susp.damper.efficiency = 1.0f; car->wheel[i].susp.damper.efficiency = 1.0;
} }
// (no need to repair wings because effect depends on damage). // (no need to repair wings because effect depends on damage).
@ -479,8 +479,8 @@ SimShutdown(void)
{ {
tCar *car; tCar *car;
int ncar; int ncar;
#if 0
double elapsed_time = GfTimeClock() - simu_init_time; double elapsed_time = GfTimeClock() - simu_init_time;
#if 0
printf ("delta_time: %f\n", SimDeltaTime); printf ("delta_time: %f\n", SimDeltaTime);
printf ("simu time: %fs (%f%% of %fs)\n", simu_total_time, printf ("simu time: %fs (%f%% of %fs)\n", simu_total_time,
100.0f * simu_total_time/elapsed_time, elapsed_time); 100.0f * simu_total_time/elapsed_time, elapsed_time);