forked from speed-dreams/speed-dreams-code
optimizations
git-svn-id: https://svn.code.sf.net/p/speed-dreams/code/trunk@2540 30fe4595-0a0c-4342-8851-515496e4dcbd Former-commit-id: 22deb98729cfc8d6786c5ae3cd7ebb2fd23b88dd Former-commit-id: 80ac2937411fedad8f2fd49ad29dfe0b5742a2e0
This commit is contained in:
wdbee
parent
cac8ebb73a
commit
712f5b5b81
8 changed files with 125 additions and 66 deletions
|
|
@ -23,6 +23,7 @@
|
|||
#include <stdio.h>
|
||||
|
||||
#include "sim.h"
|
||||
#include "timeanalysis.h"
|
||||
|
||||
#undef ONLY_GRAVITY_FORCE
|
||||
|
||||
|
|
@ -59,11 +60,11 @@ SimCarConfig(tCar *car)
|
|||
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->mass = GfParmGetNum(hdle, SECT_CAR, PRM_MASS, (char*)NULL, 1500);
|
||||
car->Minv = 1.0 / car->mass;
|
||||
car->Minv = (tdble) (1.0 / car->mass);
|
||||
gcfr = GfParmGetNum(hdle, SECT_CAR, PRM_FRWEIGHTREP, (char*)NULL, .5f);
|
||||
gcfrl = GfParmGetNum(hdle, SECT_CAR, PRM_FRLWEIGHTREP, (char*)NULL, .5f);
|
||||
gcrrl = GfParmGetNum(hdle, SECT_CAR, PRM_RRLWEIGHTREP, (char*)NULL, .5f);
|
||||
car->statGC.y = - (gcfr * gcfrl + (1 - gcfr) * gcrrl) * car->dimension.y + car->dimension.y / 2.0;
|
||||
car->statGC.y = (tdble)(- (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->tank = GfParmGetNum(hdle, SECT_CAR, PRM_TANK, (char*)NULL, 80);
|
||||
|
|
@ -81,9 +82,9 @@ SimCarConfig(tCar *car)
|
|||
}
|
||||
car->fuel_prev = car->fuel;
|
||||
k = k * k; // this constant affects front-to-back
|
||||
car->Iinv.x = 12.0 / (car->mass * k * (car->dimension.y * car->dimension.y + car->dimension.z * car->dimension.z));
|
||||
car->Iinv.y = 12.0 / (car->mass * k * (car->dimension.x * car->dimension.x + car->dimension.z * car->dimension.z));
|
||||
car->Iinv.z = 12.0 / (car->mass * k * (car->dimension.y * car->dimension.y + car->dimension.x * car->dimension.x));
|
||||
car->Iinv.x = (tdble)(12.0 / (car->mass * k * (car->dimension.y * car->dimension.y + car->dimension.z * car->dimension.z)));
|
||||
car->Iinv.y = (tdble)(12.0 / (car->mass * k * (car->dimension.x * car->dimension.x + car->dimension.z * car->dimension.z)));
|
||||
car->Iinv.z = (tdble)(12.0 / (car->mass * k * (car->dimension.y * car->dimension.y + car->dimension.x * car->dimension.x)));
|
||||
|
||||
// initialise rotational momentum
|
||||
for (i=0; i<4; i++) {
|
||||
|
|
@ -136,27 +137,27 @@ SimCarConfig(tCar *car)
|
|||
car->wheel[i].staticPos.x -= car->statGC.x;
|
||||
car->wheel[i].staticPos.y -= car->statGC.y;
|
||||
}
|
||||
car->wheelbase = (car->wheel[FRNT_RGT].staticPos.x
|
||||
car->wheelbase = (tdble)((car->wheel[FRNT_RGT].staticPos.x
|
||||
+ car->wheel[FRNT_LFT].staticPos.x
|
||||
- car->wheel[REAR_RGT].staticPos.x
|
||||
- car->wheel[REAR_LFT].staticPos.x) / 2.0;
|
||||
car->wheeltrack = (-car->wheel[REAR_LFT].staticPos.y
|
||||
- car->wheel[REAR_LFT].staticPos.x) / 2.0);
|
||||
car->wheeltrack = (tdble)((-car->wheel[REAR_LFT].staticPos.y
|
||||
- car->wheel[FRNT_LFT].staticPos.y
|
||||
+ car->wheel[FRNT_RGT].staticPos.y
|
||||
+ car->wheel[REAR_RGT].staticPos.y) / 2.0;
|
||||
+ car->wheel[REAR_RGT].staticPos.y) / 2.0);
|
||||
|
||||
/* set corners pos */
|
||||
car->corner[FRNT_RGT].pos.x = car->dimension.x * .5 - car->statGC.x;
|
||||
car->corner[FRNT_RGT].pos.y = - overallwidth * .5 - car->statGC.y;
|
||||
car->corner[FRNT_RGT].pos.x = (tdble)(car->dimension.x * .5 - car->statGC.x);
|
||||
car->corner[FRNT_RGT].pos.y = (tdble)(- overallwidth * .5 - car->statGC.y);
|
||||
car->corner[FRNT_RGT].pos.z = 0;
|
||||
car->corner[FRNT_LFT].pos.x = car->dimension.x * .5 - car->statGC.x;
|
||||
car->corner[FRNT_LFT].pos.y = overallwidth * .5 - car->statGC.y;
|
||||
car->corner[FRNT_LFT].pos.x = (tdble)(car->dimension.x * .5 - car->statGC.x);
|
||||
car->corner[FRNT_LFT].pos.y = (tdble)(overallwidth * .5 - car->statGC.y);
|
||||
car->corner[FRNT_LFT].pos.z = 0;
|
||||
car->corner[REAR_RGT].pos.x = - car->dimension.x * .5 - car->statGC.x;
|
||||
car->corner[REAR_RGT].pos.y = - overallwidth * .5 - car->statGC.y;
|
||||
car->corner[REAR_RGT].pos.x = (tdble)(- car->dimension.x * .5 - car->statGC.x);
|
||||
car->corner[REAR_RGT].pos.y = (tdble)(- overallwidth * .5 - car->statGC.y);
|
||||
car->corner[REAR_RGT].pos.z = 0;
|
||||
car->corner[REAR_LFT].pos.x = - car->dimension.x * .5 - car->statGC.x;
|
||||
car->corner[REAR_LFT].pos.y = overallwidth * .5 - car->statGC.y;
|
||||
car->corner[REAR_LFT].pos.x = (tdble)(- car->dimension.x * .5 - car->statGC.x);
|
||||
car->corner[REAR_LFT].pos.y = (tdble)(overallwidth * .5 - car->statGC.y);
|
||||
car->corner[REAR_LFT].pos.z = 0;
|
||||
car->upside_down_timer = 0.0f;
|
||||
}
|
||||
|
|
@ -174,7 +175,7 @@ SimCarUpdateForces(tCar *car)
|
|||
|
||||
/* total mass */
|
||||
m = car->mass + car->fuel;
|
||||
minv = 1.0 / m;
|
||||
minv = (tdble)(1.0 / m);
|
||||
w = -m * G;
|
||||
|
||||
/* Weight - Bring weight vector to the car's frame of reference */
|
||||
|
|
@ -208,8 +209,10 @@ SimCarUpdateForces(tCar *car)
|
|||
t3Dd car_normal;
|
||||
t3Dd rel_car_normal;
|
||||
// Get normal N
|
||||
RtTrackSurfaceNormalL(&(car->trkPos), &car_normal);
|
||||
|
||||
|
||||
RtTrackSurfaceNormalL(&(car->trkPos), &car_normal);
|
||||
car->normal = car_normal; // Use precalculated values
|
||||
|
||||
// Get normal N_q in local coordinate system
|
||||
QuatInverseRotate(car_normal, car->posQuat, rel_car_normal);
|
||||
|
||||
|
|
@ -220,7 +223,7 @@ SimCarUpdateForces(tCar *car)
|
|||
for (i = 0; i < 4; i++) {
|
||||
tWheel* wheel = &(car->wheel[i]);
|
||||
/* forces */
|
||||
tdble susp_pos_y = wheel->staticPos.y - sin(wheel->staticPos.ax)*SIGN(wheel->staticPos.y);
|
||||
tdble susp_pos_y = (tdble)(wheel->staticPos.y - sin(wheel->staticPos.ax)*SIGN(wheel->staticPos.y));
|
||||
//printf ("%f %f\n", wheel->staticPos.y, sin(wheel->staticPos.ax)*SIGN(wheel->staticPos.y));
|
||||
F.F.x += wheel->forces.x;
|
||||
F.F.y += wheel->forces.y;
|
||||
|
|
@ -301,7 +304,7 @@ SimCarUpdateForces(tCar *car)
|
|||
//Rm = -car->rot_mom[SG_Z];//car->DynGCg.vel.az / car->Iinv.z;
|
||||
Rm = car->rot_mom[SG_Z];//car->DynGCg.vel.az / car->Iinv.z;
|
||||
} else {
|
||||
Rm = SIGN(car->rot_mom[SG_Z]) * R * car->wheelbase / 2.0;
|
||||
Rm = (tdble)(SIGN(car->rot_mom[SG_Z]) * R * car->wheelbase / 2.0);
|
||||
}
|
||||
} else {
|
||||
Rx = Ry = Rz = 0.0f;
|
||||
|
|
@ -359,7 +362,7 @@ SimCarUpdateSpeed(tCar *car)
|
|||
fi = 100000 * delta_fuel / (as*SimDeltaTime);
|
||||
}
|
||||
tdble alpha = 0.1f;
|
||||
car->carElt->_fuelInstant = (1.0-alpha)*car->carElt->_fuelInstant + alpha*fi;
|
||||
car->carElt->_fuelInstant = (tdble)((1.0-alpha)*car->carElt->_fuelInstant + alpha*fi);
|
||||
}
|
||||
|
||||
if (isnan(car->DynGCg.acc.x)
|
||||
|
|
@ -367,7 +370,7 @@ SimCarUpdateSpeed(tCar *car)
|
|||
|| isnan(car->DynGCg.acc.z)) {
|
||||
car->DynGCg.acc.x = car->DynGCg.acc.y =car->DynGCg.acc.z =
|
||||
car->DynGC.acc.x = car->DynGC.acc.y =car->DynGC.acc.z = 0.0;;
|
||||
car->DynGCg.acc.z = -9.81;
|
||||
car->DynGCg.acc.z = -9.81f;
|
||||
}
|
||||
|
||||
// update linear velocity
|
||||
|
|
@ -505,9 +508,9 @@ SimCarUpdatePos(tCar *car)
|
|||
|
||||
SimCarAddAngularVelocity(car);
|
||||
|
||||
NORM_PI_PI(car->DynGC.pos.ax);
|
||||
NORM_PI_PI(car->DynGC.pos.ay);
|
||||
NORM_PI_PI(car->DynGC.pos.az);
|
||||
FLOAT_NORM_PI_PI(car->DynGC.pos.ax);
|
||||
FLOAT_NORM_PI_PI(car->DynGC.pos.ay);
|
||||
FLOAT_NORM_PI_PI(car->DynGC.pos.az);
|
||||
|
||||
car->DynGCg.pos.ax = car->DynGC.pos.ax;
|
||||
car->DynGCg.pos.ay = car->DynGC.pos.ay;
|
||||
|
|
@ -613,8 +616,8 @@ SimTelemetryOut(tCar *car)
|
|||
printf("fx:%f fy:%f fz:%f\n", car->wheel[i].forces.x, car->wheel[i].forces.y, car->wheel[i].forces.z);
|
||||
}
|
||||
|
||||
Fzf = (car->aero.lift[0] + car->wing[0].forces.z) / 9.81;
|
||||
Fzr = (car->aero.lift[1] + car->wing[1].forces.z) / 9.81;
|
||||
Fzf = (float)((car->aero.lift[0] + car->wing[0].forces.z) / 9.81);
|
||||
Fzr = (float)((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,
|
||||
Fzf, Fzr, (Fzf + Fzr) / (car->aero.drag + 0.1) * 9.81);
|
||||
// for (i=0; i<4; i++) {
|
||||
|
|
@ -754,12 +757,12 @@ void NaiveInverseRotate (t3Dd v, t3Dd u, t3Dd* v0)
|
|||
|
||||
void EulerToQuat (sgQuat quat, tdble h, tdble p, tdble r)
|
||||
{
|
||||
tdble c1=cos(h/2.0);
|
||||
tdble s1=sin(h/2.0);
|
||||
tdble c2=cos(p/2.0);
|
||||
tdble s2=sin(p/2.0);
|
||||
tdble c3=cos(r/2.0);
|
||||
tdble s3=sin(r/2.0);
|
||||
tdble c1=(tdble)(cos(h/2.0));
|
||||
tdble s1=(tdble)(sin(h/2.0));
|
||||
tdble c2=(tdble)(cos(p/2.0));
|
||||
tdble s2=(tdble)(sin(p/2.0));
|
||||
tdble c3=(tdble)(cos(r/2.0));
|
||||
tdble s3=(tdble)(sin(r/2.0));
|
||||
tdble c1c2 = c1*c2;
|
||||
tdble s1s2 = s1*s2;
|
||||
tdble c1s2 = c1*s2;
|
||||
|
|
@ -782,7 +785,7 @@ void QuatToEuler (sgVec3 hpr, const sgQuat quat )
|
|||
(tdble)(sqx - sqy - sqz + sqw));
|
||||
hpr[1] = atan2((tdble)(2.0*(quat[SG_Y]*quat[SG_Z] + quat[SG_X]*quat[SG_W])),
|
||||
(tdble)(- sqx - sqy + sqz + sqw));
|
||||
hpr[2] = asin(2.0*(quat[SG_X]*quat[SG_Z] - quat[SG_Y]*quat[SG_W]));
|
||||
hpr[2] = (tdble)(asin(2.0*(quat[SG_X]*quat[SG_Z] - quat[SG_Y]*quat[SG_W])));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -831,24 +834,24 @@ void SimCarAddAngularVelocity (tCar* car)
|
|||
sgInvertQuat (tmpQ, car->posQuat);
|
||||
sgNormaliseQuat(tmpQ);
|
||||
sgQuatToEuler (new_position, tmpQ);
|
||||
car->DynGC.pos.ax = DEG2RAD(new_position[0]);
|
||||
car->DynGC.pos.ay = DEG2RAD(new_position[1]);
|
||||
car->DynGC.pos.az = DEG2RAD(new_position[2]);
|
||||
car->DynGC.pos.ax = FLOAT_DEG2RAD(new_position[0]);
|
||||
car->DynGC.pos.ay = FLOAT_DEG2RAD(new_position[1]);
|
||||
car->DynGC.pos.az = FLOAT_DEG2RAD(new_position[2]);
|
||||
}
|
||||
|
||||
// this is only an upper bound on the energy
|
||||
tdble SimCarDynamicEnergy(tCar* car)
|
||||
{
|
||||
tdble E_kinetic = 0.5 * car->mass *
|
||||
tdble E_kinetic = (tdble)(0.5 * car->mass *
|
||||
(car->DynGCg.vel.x*car->DynGCg.vel.x
|
||||
+ car->DynGCg.vel.y*car->DynGCg.vel.y
|
||||
+ car->DynGCg.vel.z*car->DynGCg.vel.z);
|
||||
+ car->DynGCg.vel.z*car->DynGCg.vel.z));
|
||||
tdble wx = car->rot_mom[SG_X] * car->Iinv.x;
|
||||
tdble wy = car->rot_mom[SG_Y] * car->Iinv.y;
|
||||
tdble wz = car->rot_mom[SG_Z] * car->Iinv.z;
|
||||
tdble E_rotational = 0.5 * (wx*wx/car->Iinv.x
|
||||
tdble E_rotational = (tdble)(0.5 * (wx*wx/car->Iinv.x
|
||||
+ wy*wy/car->Iinv.y
|
||||
+ wz*wz/car->Iinv.z);
|
||||
+ wz*wz/car->Iinv.z));
|
||||
return E_kinetic + E_rotational;
|
||||
}
|
||||
|
||||
|
|
@ -875,7 +878,7 @@ void SimCarLimitDynamicEnergy(tCar* car, tdble E_limit)
|
|||
// this is only an upper bound on the energy
|
||||
tdble SimCarEnergy(tCar* car)
|
||||
{
|
||||
return SimCarDynamicEnergy(car) + car->mass * 9.81 * car->DynGCg.pos.z;
|
||||
return (tdble)(SimCarDynamicEnergy(car) + car->mass * 9.81 * car->DynGCg.pos.z);
|
||||
}
|
||||
|
||||
/// Makes the car's dynamic energy stay under some limit
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@
|
|||
***************************************************************************/
|
||||
|
||||
#include "sim.h"
|
||||
#include "timeanalysis.h"
|
||||
|
||||
extern tRmInfo ReInfo;
|
||||
|
||||
#define CAR_DAMMAGE 0.1
|
||||
|
|
@ -56,7 +58,8 @@ void SimCarCollideZ(tCar *car)
|
|||
wheel = &(car->wheel[i]);
|
||||
if (wheel->state & SIM_SUSP_COMP) {
|
||||
car->DynGCg.pos.z += wheel->susp.spring.packers - wheel->rideHeight;
|
||||
RtTrackSurfaceNormalL(&(wheel->trkPos), &normal);
|
||||
//RtTrackSurfaceNormalL(&(wheel->trkPos), &normal);
|
||||
normal = wheelNormal[i];
|
||||
dotProd = (car->DynGCg.vel.x * normal.x + car->DynGCg.vel.y * normal.y + car->DynGCg.vel.z * normal.z) * wheel->trkPos.seg->surface->kRebound;
|
||||
if (dotProd < 0) {
|
||||
if (dotProd < CRASH_THRESHOLD) {
|
||||
|
|
@ -98,8 +101,9 @@ SimCarCollideZ(tCar *car)
|
|||
tdble E_prev = SimCarEnergy(car);
|
||||
bool collide = false;
|
||||
// Get normal N
|
||||
RtTrackSurfaceNormalL(&(car->trkPos), &car_normal);
|
||||
|
||||
//RtTrackSurfaceNormalL(&(car->trkPos), &car_normal);
|
||||
car_normal = car->normal; // Use precalculated values
|
||||
|
||||
// Get normal N_q in local coordinate system
|
||||
QuatInverseRotate(car_normal, car->posQuat, rel_car_normal);
|
||||
|
||||
|
|
@ -170,7 +174,9 @@ SimCarCollideZ(tCar *car)
|
|||
|
||||
|
||||
// get the track normal n_g for the wheel
|
||||
RtTrackSurfaceNormalL(&(wheel->trkPos), &normal);
|
||||
//RtTrackSurfaceNormalL(&(wheel->trkPos), &normal);
|
||||
normal = wheel->normal;
|
||||
|
||||
// transform it to local coordinates: n = q' n_g q
|
||||
QuatInverseRotate (normal, car->posQuat, rel_normal);
|
||||
|
||||
|
|
|
|||
|
|
@ -233,7 +233,7 @@ SimDifferentialUpdate(tCar *car, tDifferential *differential, int first)
|
|||
float bias = differential->dTqMax * 0.5f* t_spin;
|
||||
if (fabs(2.0*bias) < differential->dTqMin)
|
||||
{
|
||||
bias = SIGN(bias) * 0.5f * differential->dTqMin;
|
||||
bias = (float)(SIGN(bias) * 0.5f * differential->dTqMin);
|
||||
}
|
||||
float open = 1.0f - fabs(pressure);
|
||||
//DrTq0 = DrTq*(0.5f + bias) + spiderTq;
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
|
||||
tdble CalculateTorque (tEngine* engine, tdble rads)
|
||||
{
|
||||
//double StartTimeStamp = RtTimeStamp();
|
||||
double StartTimeStamp = RtTimeStamp(); // Profiling test
|
||||
|
||||
tEngineCurve *curve = &(engine->curve);
|
||||
tdble Tq = curve->data[0].Tq;
|
||||
|
|
@ -44,14 +44,54 @@ tdble CalculateTorque (tEngine* engine, tdble rads)
|
|||
alpha = (rads - rpm_min) / (rpm_max - rpm_min);
|
||||
Tq = (float)((1.0-alpha) * Tmin + alpha * Tmax);
|
||||
|
||||
//SimTicks += RtDuration(StartTimeStamp);
|
||||
SimTicks += RtDuration(StartTimeStamp); // Profiling test
|
||||
|
||||
return Tq;
|
||||
}
|
||||
|
||||
tdble CalculateTorque2 (tEngine* engine, tdble rads)
|
||||
{
|
||||
//double StartTimeStamp = RtTimeStamp();
|
||||
tEngineCurve *curve = &(engine->curve);
|
||||
|
||||
int i = engine->lastInterval;
|
||||
|
||||
tdble rpm_min = curve->data[i].rads;
|
||||
tdble rpm_max = curve->data[i+1].rads;
|
||||
|
||||
if (rads > rpm_max) {
|
||||
if (i < curve->nbPts) {
|
||||
rpm_min = rpm_max;
|
||||
engine->lastInterval = ++i;
|
||||
rpm_max = curve->data[i+1].rads;
|
||||
}
|
||||
}
|
||||
else if (rads < rpm_min) {
|
||||
if (i > 0) {
|
||||
rpm_max = rpm_min;
|
||||
engine->lastInterval = --i;
|
||||
rpm_min = curve->data[i].rads;
|
||||
}
|
||||
}
|
||||
|
||||
// In case of large changes of rads
|
||||
if ((rads < rpm_min) || (rads > rpm_max))
|
||||
return CalculateTorque2 (engine, rads);
|
||||
else {
|
||||
tdble alpha = (rads - rpm_min) / (rpm_max - rpm_min);
|
||||
return (float)((1.0-alpha) * curve->data[i].Tq + alpha * curve->data[i+1].Tq);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
For profiling tests:
|
||||
|
||||
Call CalculateTorque3 instead of CalculateTorque2
|
||||
to get the times without overlapping
|
||||
caused by recursive calls to CalculateTorque2 */
|
||||
|
||||
tdble CalculateTorque3 (tEngine* engine, tdble rads)
|
||||
{
|
||||
double StartTimeStamp = RtTimeStamp(); // Profiling test
|
||||
|
||||
tEngineCurve *curve = &(engine->curve);
|
||||
|
||||
|
|
@ -77,15 +117,15 @@ tdble CalculateTorque2 (tEngine* engine, tdble rads)
|
|||
|
||||
tdble Tq;
|
||||
|
||||
// To make Christos happy:
|
||||
// In case of large changes of rads
|
||||
if ((rads < rpm_min) || (rads > rpm_max))
|
||||
Tq = CalculateTorque (engine, rads);
|
||||
else
|
||||
{
|
||||
Tq = CalculateTorque2 (engine, rads);
|
||||
else {
|
||||
tdble alpha = (rads - rpm_min) / (rpm_max - rpm_min);
|
||||
Tq = (float)((1.0-alpha) * curve->data[i].Tq + alpha * curve->data[i+1].Tq);
|
||||
}
|
||||
//SimTicks2 += RtDuration(StartTimeStamp);
|
||||
|
||||
SimTicks2 += RtDuration(StartTimeStamp); // Profiling test
|
||||
|
||||
return Tq;
|
||||
}
|
||||
|
|
@ -173,7 +213,7 @@ SimEngineConfig(tCar *car)
|
|||
for (float rads=1.0; rads<car->engine.revsMax; rads+=1.0) {
|
||||
float Tq = CalculateTorque(&(car->engine), rads);
|
||||
float Tq2 = CalculateTorque2(&(car->engine), rads);
|
||||
printf ("%f %f %f %d #TORQUE\n", 30.0*rads/M_PI, Tq, Tq2, SimLastInterval);
|
||||
printf ("%f %f %f %d #TORQUE\n", 30.0*rads/M_PI, Tq, Tq2, engine->lastInterval);
|
||||
}
|
||||
#endif
|
||||
free(edesc);
|
||||
|
|
@ -211,7 +251,8 @@ SimEngineUpdateTq(tCar *car)
|
|||
engine->Tq = 0.0f;
|
||||
engine->rads = engine->tickover;
|
||||
} else {
|
||||
tdble Tq_max = CalculateTorque2(engine, engine->rads);
|
||||
// tdble Tq_max = CalculateTorque2(engine, engine->rads); // Use this for release
|
||||
tdble Tq_max = CalculateTorque3(engine, engine->rads); // Use this for profiling tests
|
||||
tdble alpha = car->ctrl->accelCmd;
|
||||
if (alpha < 1) {
|
||||
//tdble da = 1 /(1 - alpha); // flow
|
||||
|
|
@ -352,5 +393,5 @@ SimEngineShutdown(tCar *car)
|
|||
{
|
||||
free(car->engine.curve.data);
|
||||
//GfOut("#Total Time CalculateTorque used: %g sec\n",SimTicks/1000.0);
|
||||
//GfOut("#Total Time CalculateTorque2 used: %g sec\n",SimTicks2/1000.0);
|
||||
GfOut("#Total Time CalculateTorque2 used: %g sec\n",SimTicks2/1000.0); // Profiling test
|
||||
}
|
||||
|
|
|
|||
|
|
@ -124,6 +124,7 @@ extern tdble simSkidFactor[];
|
|||
|
||||
extern double SimTicks;
|
||||
extern double SimTicks2;
|
||||
extern double SimTicksRtTrackSurfaceNormalL;
|
||||
|
||||
/// return a number drawn uniformly from [0,1]
|
||||
inline float urandom() {
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
#include <tgf.h>
|
||||
#include <robottools.h>
|
||||
#include "sim.h"
|
||||
#include "timeanalysis.h"
|
||||
|
||||
extern double timer_coordinate_transform;
|
||||
extern double timer_reaction;
|
||||
|
|
@ -52,6 +53,7 @@ static double simu_init_time = 0.0f;
|
|||
|
||||
double SimTicks = 0.0; // Time measurement of CalculateTorque
|
||||
double SimTicks2 = 0.0; // Time measurement of CalculateTorque2
|
||||
double SimTicksRtTrackSurfaceNormalL = 0.0; // Time measurement of RtTrackSurfaceNormalL
|
||||
|
||||
t3Dd vectStart[16];
|
||||
t3Dd vectEnd[16];
|
||||
|
|
@ -141,6 +143,8 @@ ctrlCheck(tCar *car)
|
|||
void
|
||||
SimConfig(tCarElt *carElt, tRmInfo* ReInfo)
|
||||
{
|
||||
RtInitTimer();
|
||||
|
||||
tCar *car = &(SimCarTable[carElt->index]);
|
||||
|
||||
memset(car, 0, sizeof(tCar));
|
||||
|
|
@ -367,9 +371,6 @@ SimUpdate(tSituation *s, double deltaTime, int telemetry)
|
|||
car->ctrl->gear = 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
CHECK(car);
|
||||
ctrlCheck(car);
|
||||
CHECK(car);
|
||||
|
|
@ -385,7 +386,8 @@ SimUpdate(tSituation *s, double deltaTime, int telemetry)
|
|||
|
||||
SimCarUpdateWheelPos(car);
|
||||
CHECK(car);
|
||||
SimBrakeSystemUpdate(car);
|
||||
|
||||
SimBrakeSystemUpdate(car);
|
||||
CHECK(car);
|
||||
SimAeroUpdate(car, s);
|
||||
CHECK(car);
|
||||
|
|
@ -544,5 +546,6 @@ SimShutdown(void)
|
|||
free(SimCarTable);
|
||||
SimCarTable = 0;
|
||||
}
|
||||
GfOut("#Total Time RtTrackSurfaceNormalL used: %g sec\n",SimTicksRtTrackSurfaceNormalL/1000.0); // Profiling test
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -181,6 +181,7 @@ SimWheelUpdateRide(tCar *car, int index)
|
|||
t3Dd rel_normal;
|
||||
// Find normal of track.
|
||||
RtTrackSurfaceNormalL(&(wheel->trkPos), &normal);
|
||||
wheel->normal = normal;
|
||||
{
|
||||
sgQuat Q;
|
||||
sgCopyQuat (Q, car->posQuat);
|
||||
|
|
@ -303,7 +304,9 @@ SimWheelUpdateForce(tCar *car, int index)
|
|||
|
||||
BEGIN_PROFILE(timer_coordinate_transform);
|
||||
|
||||
RtTrackSurfaceNormalL(&(wheel->trkPos), &normal);
|
||||
//RtTrackSurfaceNormalL(&(wheel->trkPos), &normal);
|
||||
normal = wheel->normal;
|
||||
|
||||
|
||||
// now rel_normal.x is the effective camber angle
|
||||
if (USE_QUATERNIONS==0) {
|
||||
|
|
@ -491,7 +494,8 @@ SimWheelUpdateForce(tCar *car, int index)
|
|||
mu = wheel->mu * (wheel->lfMin + (wheel->lfMax - wheel->lfMin) * exp(wheel->lfK * reaction_force / wheel->opLoad));
|
||||
//mu = wheel->mu;
|
||||
|
||||
tdble static_grip = wheel->condition * reaction_force * mu * wheel->trkPos.seg->surface->kFriction/0.7f;
|
||||
tdble static_grip = wheel->condition * reaction_force * mu * wheel->trkPos.seg->surface->kFriction;
|
||||
//tdble static_grip = wheel->condition * reaction_force * mu * wheel->trkPos.seg->surface->kFriction/0.7f;
|
||||
|
||||
F = dynamic_grip * static_grip;
|
||||
// This is the steering torque
|
||||
|
|
|
|||
|
|
@ -114,6 +114,7 @@ typedef struct
|
|||
tdble s_old;
|
||||
tdble F_old;
|
||||
|
||||
t3Dd normal;
|
||||
|
||||
} tWheel;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue