iceflower/speed-dreams-code
1
0
Fork 0
forked from speed-dreams/speed-dreams-code
Code Pull requests Activity

- improved Sky OSG

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

Former-commit-id: ad7afe174b92e9a6508c72b1c0bf46b3ade2f3ac
Former-commit-id: 5d5ad1cb1512ac69b19c661daefeb725a477e328
This commit is contained in:
torcs-ng 2019-01-20 01:02:20 +00:00
parent 94f084b961
commit 38567b55fb
6 changed files with 411 additions and 225 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

344
src/drivers/usr/src/cardata.cpp
View file

@ -22,168 +22,284 @@
void SingleCardata::update()
{
trackangle = RtTrackSideTgAngleL(&(car->_trkPos));
speed = getSpeed(car, trackangle);
evalTrueSpeed();
angle = trackangle - car->_yaw;
FLOAT_NORM_PI_PI(angle);
width = MAX(car->_dimension_y, fabs(car->_dimension_x*sin(angle) + car->_dimension_y*cos(angle))) + 0.1f;
length = MAX(car->_dimension_x, fabs(car->_dimension_y*sin(angle) + car->_dimension_x*cos(angle))) + 0.1f;
trackangle = RtTrackSideTgAngleL(&(car->_trkPos));
speed = getSpeed(car, trackangle);
//evalTrueSpeed();
angle = trackangle - car->_yaw;
FLOAT_NORM_PI_PI(angle);
width = MAX(car->_dimension_y, fabs(car->_dimension_x*sin(angle) + car->_dimension_y*cos(angle))) + 0.1f;
length = MAX(car->_dimension_x, fabs(car->_dimension_y*sin(angle) + car->_dimension_x*cos(angle))) + 0.1f;
for (int i=0; i<4; i++)
{
corner2[i].ax = corner1[i].ax;
corner2[i].ay = corner1[i].ay;
corner1[i].ax = car->_corner_x(i);
corner1[i].ay = car->_corner_y(i);
}
for (int i=0; i<4; i++)
{
corner2[i].ax = corner1[i].ax;
corner2[i].ay = corner1[i].ay;
corner1[i].ax = car->_corner_x(i);
corner1[i].ay = car->_corner_y(i);
}
lastspeed[2].ax = lastspeed[1].ax;
lastspeed[2].ay = lastspeed[1].ay;
lastspeed[1].ax = lastspeed[0].ax;
lastspeed[1].ay = lastspeed[0].ay;
lastspeed[0].ax = car->_speed_X;
lastspeed[0].ay = car->_speed_Y;
t_m_f = MIN(car->priv.wheel[0].condition, car->priv.wheel[1].condition);
t_m_r = MIN(car->priv.wheel[2].condition, car->priv.wheel[3].condition);
TyreMu = MIN(t_m * t_m_f, t_m * t_m_r);
evalTrueSpeed();
lastspeed[2].ax = lastspeed[1].ax;
lastspeed[2].ay = lastspeed[1].ay;
lastspeed[1].ax = lastspeed[0].ax;
lastspeed[1].ay = lastspeed[0].ay;
lastspeed[0].ax = car->_speed_X;
lastspeed[0].ay = car->_speed_Y;
}
void SingleCardata::updateWalls()
{
tolftwall = torgtwall = 1000.0f;
tolftwall = torgtwall = 1000.0f;
tTrackSeg *lseg = car->_trkPos.seg->lside;
tTrackSeg *rseg = car->_trkPos.seg->rside;
// get wall/fence segments on each side
if (lseg)
while (lseg->style == TR_PLAN || lseg->style == TR_CURB)
{
if (!lseg->lside) break;
lseg = lseg->lside;
}
tTrackSeg *lseg = car->_trkPos.seg->lside;
tTrackSeg *rseg = car->_trkPos.seg->rside;
if (rseg)
while (rseg->style == TR_PLAN && rseg->style == TR_CURB)
{
if (!rseg->rside) break;
rseg = rseg->rside;
}
// get wall/fence segments on each side
if (lseg)
while (lseg->style == TR_PLAN || lseg->style == TR_CURB)
{
if (!lseg->lside) break;
lseg = lseg->lside;
}
if (lseg && rseg)
{
// make a line along the wall
straight2f lftWallLine( lseg->vertex[TR_SL].x, lseg->vertex[TR_SL].y,
lseg->vertex[TR_EL].x - lseg->vertex[TR_SL].x,
lseg->vertex[TR_EL].y - lseg->vertex[TR_SL].y);
straight2f rgtWallLine( rseg->vertex[TR_SR].x, rseg->vertex[TR_SR].y,
rseg->vertex[TR_EL].x - rseg->vertex[TR_SL].x,
rseg->vertex[TR_EL].y - rseg->vertex[TR_SL].y);
if (rseg)
while (rseg->style == TR_PLAN && rseg->style == TR_CURB)
{
if (!rseg->rside) break;
rseg = rseg->rside;
}
for (int i=0; i<4; i++)
{
// get minimum distance to each wall
vec2f corner(car->_corner_x(i), car->_corner_y(i));
tolftwall = MIN(tolftwall, lftWallLine.dist( corner ));
torgtwall = MIN(torgtwall, rgtWallLine.dist( corner ));
}
}
else
{
tolftwall = car->_trkPos.toLeft;
torgtwall = car->_trkPos.toRight;
}
if (lseg && rseg)
{
// make a line along the wall
straight2f lftWallLine( lseg->vertex[TR_SL].x, lseg->vertex[TR_SL].y,
lseg->vertex[TR_EL].x - lseg->vertex[TR_SL].x,
lseg->vertex[TR_EL].y - lseg->vertex[TR_SL].y);
straight2f rgtWallLine( rseg->vertex[TR_SR].x, rseg->vertex[TR_SR].y,
rseg->vertex[TR_EL].x - rseg->vertex[TR_SL].x,
rseg->vertex[TR_EL].y - rseg->vertex[TR_SL].y);
for (int i=0; i<4; i++)
{
// get minimum distance to each wall
vec2f corner(car->_corner_x(i), car->_corner_y(i));
tolftwall = MIN(tolftwall, lftWallLine.dist( corner ));
torgtwall = MIN(torgtwall, rgtWallLine.dist( corner ));
}
}
else
{
tolftwall = car->_trkPos.toLeft;
torgtwall = car->_trkPos.toRight;
}
}
static double getDistance2D( double x1, double y1, double x2, double y2 )
{
double dx = x1 - x2;
double dy = y1 - y2;
double dx = x1 - x2;
double dy = y1 - y2;
return sqrt(dx*dx + dy*dy);
return sqrt(dx*dx + dy*dy);
}
void SingleCardata::evalTrueSpeed()
{
tTrackSeg *seg = car->_trkPos.seg;
truespeed = speed;
tTrackSeg *seg = car->_trkPos.seg;
truespeed = speed;
if (seg->type == TR_STR)
return;
if (seg->type == TR_STR)
return;
double lengthlft = getDistance2D( seg->vertex[TR_SL].x, seg->vertex[TR_SL].y, seg->vertex[TR_EL].x, seg->vertex[TR_EL].y );
double lengthrgt = getDistance2D( seg->vertex[TR_SR].x, seg->vertex[TR_SR].y, seg->vertex[TR_ER].x, seg->vertex[TR_ER].y );
double lengthlft = getDistance2D( seg->vertex[TR_SL].x, seg->vertex[TR_SL].y, seg->vertex[TR_EL].x, seg->vertex[TR_EL].y );
double lengthrgt = getDistance2D( seg->vertex[TR_SR].x, seg->vertex[TR_SR].y, seg->vertex[TR_ER].x, seg->vertex[TR_ER].y );
double ratio;
if (seg->type == TR_LFT)
ratio = MAX(0.0, MIN(1.0, car->_trkPos.toLeft / (seg->width-3.0)));
else
ratio = MAX(0.0, MIN(1.0, (1.0 - car->_trkPos.toRight / (seg->width-3.0))));
double ratio;
if (seg->type == TR_LFT)
ratio = MAX(0.0, MIN(1.0, car->_trkPos.toLeft / (seg->width-3.0)));
else
ratio = MAX(0.0, MIN(1.0, (1.0 - car->_trkPos.toRight / (seg->width-3.0))));
double ourlength = lengthlft * ratio + lengthrgt * (1.0-ratio);
double avglength = lengthlft/2 + lengthrgt/2;
double change = MIN(1.0, MAX(0.85, ourlength / avglength));
double ourlength = lengthlft * ratio + lengthrgt * (1.0-ratio);
double avglength = lengthlft/2 + lengthrgt/2;
double change = MIN(1.0, MAX(0.85, ourlength / avglength));
truespeed *= (tdble) change;
truespeed *= (tdble) change;
truespeed *= TyreMu;
}
// compute speed component parallel to the track.
float SingleCardata::getSpeed(tCarElt *car, float ltrackangle)
{
v2d speed, dir;
speed.x = car->_speed_X;
speed.y = car->_speed_Y;
dir.x = cos(ltrackangle);
dir.y = sin(ltrackangle);
return (tdble) (speed*dir);
v2d speed, dir;
speed.x = car->_speed_X;
speed.y = car->_speed_Y;
dir.x = cos(ltrackangle);
dir.y = sin(ltrackangle);
return (tdble) (speed*dir);
}
void SingleCardata::init( CarElt *pcar )
{
car = pcar;
for (int i=0; i<4; i++)
{
corner1[i].ax = corner2[i].ax = car->_corner_x(i);
corner1[i].ay = corner2[i].ay = car->_corner_y(i);
}
lastspeed[0].ax = lastspeed[1].ax = lastspeed[2].ax = car->_speed_X;
lastspeed[0].ay = lastspeed[1].ay = lastspeed[2].ay = car->_speed_Y;
car = pcar;
for (int i=0; i<4; i++)
{
corner1[i].ax = corner2[i].ax = car->_corner_x(i);
corner1[i].ay = corner2[i].ay = car->_corner_y(i);
}
lastspeed[0].ax = lastspeed[1].ax = lastspeed[2].ax = car->_speed_X;
lastspeed[0].ay = lastspeed[1].ay = lastspeed[2].ay = car->_speed_Y;
t_m = t_m_f = t_m_r = 9999999.0f;
//lTT = GfParmGetNum(car->_carHandle, SECT_PRIVATE, PRV_WTT, (char *)NULL, BT_ATT_WT);
//hTT = GfParmGetNum(car->_carHandle, SECT_PRIVATE, PRV_HTT, (char *)NULL, iT() + (iT() - lTT)*0.80);
fuelMassFactor = GfParmGetNum(car->_carHandle, SECT_PRIVATE, PRV_FUEL_MASS_FACTOR, (char *)NULL, 1.0f);
RH = 0.0f;
for (int i=0; i<4; i++)
{
static const char *WheelSect[4] = {SECT_FRNTRGTWHEEL, SECT_FRNTLFTWHEEL,
SECT_REARRGTWHEEL, SECT_REARLFTWHEEL};
double mu = GfParmGetNum(car->_carHandle, WheelSect[i], PRM_MU, (char *)NULL, 1.0);
t_m = MIN(t_m, mu);
RH += GfParmGetNum(car->_carHandle, WheelSect[i], (char *)PRM_RIDEHEIGHT, (char *)NULL, 0.20f);
}
t_m_f = MIN(car->priv.wheel[0].condition, car->priv.wheel[1].condition);
t_m_r = MIN(car->priv.wheel[2].condition, car->priv.wheel[3].condition);
TyreMu = MIN(t_m * t_m_f, t_m * t_m_r);
// Aerodynamics
RH *= 1.5f; RH = RH*RH; RH = 2.0 * exp(-3.0 * RH);
tdble CL = GfParmGetNum(car->_carHandle, SECT_AERODYNAMICS, PRM_FCL, (char *)NULL, 0.0f) +
GfParmGetNum(car->_carHandle, SECT_AERODYNAMICS, PRM_RCL, (char *)NULL, 0.0f);
float fwingarea = GfParmGetNum(car->_carHandle, SECT_FRNTWING, PRM_WINGAREA, (char*) NULL, 0.0f);
float fwingangle = GfParmGetNum(car->_carHandle, SECT_FRNTWING, PRM_WINGANGLE, (char*) NULL, 0.0f);
float rwingarea = GfParmGetNum(car->_carHandle, SECT_REARWING, PRM_WINGAREA, (char*) NULL, 0.0f);
float rwingangle = GfParmGetNum(car->_carHandle, SECT_REARWING, PRM_WINGANGLE, (char*) NULL, 0.0f);
float rwingArea = rwingarea * sin(rwingangle);
float fwingArea = fwingarea * sin(fwingangle);
float wingCA = 1.23f * (fwingArea + rwingArea);
CA = RH * CL + 4.0f * wingCA;
CA_FW = 4 * 1.23f * fwingArea;
CA_RW = 4 * 1.23f * rwingArea;
CA_GE = RH * CL;
baseMass = GfParmGetNum(car->_carHandle, SECT_CAR, PRM_MASS, NULL, 1000.0f);
fuel = 0.0f;
//mFTT = 0.0f;
//aFTT = 0.0f;
//aTT = 0.0f;
carMu = fuelCarMu = offlineFuelCarMu = 1.0f;
lmTT = rmTT = 0.0;
baseCarMu = (CA_FW * t_m_f + CA_RW * t_m_r + CA_GE * t_m) / baseMass;
CTFactor = GfParmGetNum(car->_carHandle, SECT_PRIVATE, PRV_CTFACTOR, NULL, 1.0f);
}
void SingleCardata::updateModel()
{
//aTT = 0.0f; aFTT = 0.0f; mFTT = 0.0f;
float mLTT = 0.0f, mRTT = 0.0f;
tdble mG = 0.0f;
int i;
/*for (i=0; i<4; i++)
{
double ct = car->priv.wheel[i].condition;
aTT += ct;
mG = MAX(mG, ct);
if (i < 2)
{
aFTT += ct;
mFTT = MAX(mFTT, ct);
if (i == FRNT_LFT || i == REAR_LFT)
mLTT = MAX(mLTT, ct);
else
mRTT = MAX(mRTT, ct);
}
}*/
//aTT /= 4;
//aFTT /= 2;
fuel = car->_fuel;
damage = car->_dammage;
tdble cTM = t_m, cTMF = t_m_f, cTMR = t_m_r;
for (i=0; i<4; i++)
{
double ct = car->priv.wheel[i].condition;
tdble gF = 1.0f - /*mG/10;*/ct;
//if (ct > hTT)
// gF -= MIN(0.20f, ((ct - hTT) / 15.0f) / 5.0f);
/*if (ct < lTT)
gF -= MIN(0.75f, ((lTT - ct) / (45.0f*CTFactor)) / 15.0f);*/
if (i < 2)
cTMF = MIN(cTMF, t_m_f * ct);
else
cTMR = MIN(cTMR, t_m_r * ct);
}
//lftOH = MAX(0.0, MAX(lmTT, mLTT) - hTT);
//rgtOH = MAX(0.0, MAX(rmTT, mRTT) - hTT);
lmTT = rmTT = 0.0;
cTM = MIN(cTMF, cTMR);
fuelCarMu = ((CA_FW * t_m_f + CA_RW * t_m_r + CA_GE * t_m) / (baseMass+fuel * fuelMassFactor)) / baseCarMu;
offlineFuelCarMu = ((CA_FW * t_m_f + CA_RW * t_m_r + CA_GE * t_m) / (baseMass+fuel)) / baseCarMu;
carMu = ((CA_FW * cTMF + CA_RW * cTMR + CA_GE * cTM) / (baseMass+fuel * fuelMassFactor)) / baseCarMu;
}
Cardata::Cardata(tSituation *s)
{
ncars = s->_ncars;
data = new SingleCardata[ncars];
int i;
for (i = 0; i < ncars; i++)
{
data[i].init(s->cars[i]);
}
ncars = s->_ncars;
data = new SingleCardata[ncars];
int i;
for (i = 0; i < ncars; i++)
{
data[i].init(s->cars[i]);
}
}
Cardata::~Cardata()
{
delete [] data;
delete [] data;
}
void Cardata::update()
{
int i;
for (i = 0; i < ncars; i++)
{
data[i].update();
}
int i;
for (i = 0; i < ncars; i++)
{
data[i].update();
}
}
SingleCardata *Cardata::findCar(tCarElt *car)
{
int i;
for (i = 0; i < ncars; i++)
{
if (data[i].thisCar(car))
{
return &data[i];
}
}
return NULL;
int i;
for (i = 0; i < ncars; i++)
{
if (data[i].thisCar(car))
{
return &data[i];
}
}
return NULL;
}

125
src/drivers/usr/src/cardata.h
View file

@ -18,8 +18,8 @@
***************************************************************************/
/*
This class holds global facts about cars, therefore no data relative to
each other (for that is the class Opponents/Opponent responsible).
This class holds global facts about cars, therefore no data relative to
each other (for that is the class Opponents/Opponent responsible).
*/
#ifndef _BT_CARDATA_H_
@ -33,68 +33,99 @@
#include <raceman.h>
#include "linalg.h"
#include "globaldefs.h"
class SingleCardata
{
public:
void init(CarElt *car);
public:
void init(CarElt *car);
inline float getSpeedInTrackDirection() { return speed; }
inline float getWidthOnTrack() { return width; }
inline float getLengthOnTrack() { return length; }
inline float getTrackangle() { return trackangle; }
inline float getCarAngle() { return angle; }
inline float getTrueSpeed() { return truespeed; }
inline float getSpeedInTrackDirection() { return speed; }
inline float getWidthOnTrack() { return width; }
inline float getLengthOnTrack() { return length; }
inline float getTrackangle() { return trackangle; }
inline float getCarAngle() { return angle; }
inline float getTrueSpeed() { return truespeed; }
inline double getTyreMu() { return TyreMu; }
inline bool thisCar(tCarElt *car) { return (car == this->car); }
inline tPosd *getCorner1() { return corner1; }
inline tPosd *getCorner2() { return corner2; }
inline tPosd *getLastSpeed() { return lastspeed; }
inline double getSpeedDeltaX() { return (car->_speed_X - lastspeed[1].ax)*0.7 + (lastspeed[1].ax-lastspeed[2].ax)/4; }
inline double getSpeedDeltaY() { return (car->_speed_Y - lastspeed[1].ay)*0.7 + (lastspeed[1].ay-lastspeed[2].ay)/4; }
inline float toLftWall() { return tolftwall; }
inline float toRgtWall() { return torgtwall; }
inline float getDistFromStart() { return car->_distFromStartLine; }
inline bool thisCar(tCarElt *car) { return (car == this->car); }
inline tPosd *getCorner1() { return corner1; }
inline tPosd *getCorner2() { return corner2; }
inline tPosd *getLastSpeed() { return lastspeed; }
inline double getSpeedDeltaX() { return (car->_speed_X - lastspeed[1].ax)*0.7 + (lastspeed[1].ax-lastspeed[2].ax)/4; }
inline double getSpeedDeltaY() { return (car->_speed_Y - lastspeed[1].ay)*0.7 + (lastspeed[1].ay-lastspeed[2].ay)/4; }
inline float toLftWall() { return tolftwall; }
inline float toRgtWall() { return torgtwall; }
inline float getDistFromStart() { return car->_distFromStartLine; }
void update();
void updateWalls();
void evalTrueSpeed();
void update();
void updateModel();
void updateWalls();
void evalTrueSpeed();
protected:
static float getSpeed(tCarElt *car, float trackangle);
protected:
static float getSpeed(tCarElt *car, float trackangle);
float speed; // speed in direction of the track.
float truespeed; // speed accounting for bends
float width; // the cars needed width on the track.
float length; // the cars needed length on the track.
float trackangle; // Track angle at the opponents position.
float angle; // The angle of the car relative to the track tangent.
float tolftwall; // how far to the nearest left barrier
float torgtwall; // how far to the nearest Right barrier
float speed; // speed in direction of the track.
float truespeed; // speed accounting for bends
float width; // the cars needed width on the track.
float length; // the cars needed length on the track.
float trackangle; // Track angle at the opponents position.
float angle; // The angle of the car relative to the track tangent.
float fuelMassFactor;
float tolftwall; // how far to the nearest left barrier
float torgtwall; // how far to the nearest Right barrier
tPosd corner1[4];
tPosd corner2[4];
tPosd lastspeed[3];
tPosd corner1[4];
tPosd corner2[4];
tPosd lastspeed[3];
tdble TyreMu;
tdble t_m;
tdble t_m_f;
tdble t_m_r;
tdble currentMass;
double hTT;
tCarElt *car; // For identification.
double CTFactor;
tdble carMu;
tdble fuelCarMu;
tdble offlineFuelCarMu;
tdble baseCarMu;
tdble fuel;
tdble damage;
tdble RH;
tdble CA;
tdble CA_RW;
tdble CA_FW;
tdble CA_GE;
double lmTT;
double rmTT;
tdble baseMass;
tCarElt *car; // For identification.
};
// TODO: use singleton pattern.
class Cardata {
public:
Cardata(tSituation *s);
~Cardata();
class Cardata
{
public:
Cardata(tSituation *s);
~Cardata();
void update();
SingleCardata *findCar(tCarElt *car);
int getNCars() { return ncars; }
SingleCardata *getCarData(int i) { return data + i; }
void update();
SingleCardata *findCar(tCarElt *car);
int getNCars() { return ncars; }
SingleCardata *getCarData(int i) { return data + i; }
protected:
SingleCardata *data; // Array with car data.
int ncars; // # of elements in data.
protected:
SingleCardata *data; // Array with car data.
int ncars; // # of elements in data.
};

2
src/drivers/usr/src/globaldefs.h
View file

@ -101,6 +101,8 @@ static const int MAX_NBBOTS = 100; // Number of drivers/robots
#define PRV_OFFTRACK_ALLOWED "offtrack allowed"
#define PRV_OFFTRACK_RLIMIT "rough limit"
#define PRV_AVOID_OFFSET "avoid offset"
#define PRV_CTFACTOR "ct factor"
#define PRV_FUEL_MASS_FACTOR "fuel mass factor"
// driver values
#define PRV_PIT_DAMAGE "pit damage"

104
src/modules/graphic/osggraph/Render/OsgRender.cpp
View file

@ -286,8 +286,8 @@ void SDRender::Init(tTrack *track)
GfLogInfo(" domeSizeRation : %d\n", domeSizeRatio);
thesky->build(datapath, SDSkyDomeDistance, SDSkyDomeDistance, 800,
40000, 800, 30000, NPlanets,
thesky->build(datapath, SDSkyDomeDistance, SDSkyDomeDistance, 2000 * domeSizeRatio,
SDSkyDomeDistance, 2000 * domeSizeRatio, SDSkyDomeDistance, NPlanets,
APlanetsData, NStars, AStarsData );
GfOut("Build SKY\n");
GLfloat sunAscension = SDTrack->local.sunascension;
@ -842,6 +842,8 @@ void SDRender::weather(void)
std::string datapath = GetDataDir();
double domeSizeRatio = SDSkyDomeDistance / 80000.0;
// Cloud layers.
SDNbCloudLayers =
(unsigned)(GfParmGetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_CLOUDLAYER, 0, 0) + 0.5);
@ -862,7 +864,7 @@ void SDRender::weather(void)
SDRain = 1;
break;
case TR_RAIN_MEDIUM:
SDVisibility = 400.0;
SDVisibility = 300.0;
SDRain = 2;
break;
case TR_RAIN_HEAVY:
@ -885,19 +887,43 @@ void SDRender::weather(void)
layer->setElevation_m(1000);
layer->setThickness_m(400 / domeSizeRatio);
layer->setTransition_m(400 / domeSizeRatio);
layer->setSpan_m(SDSkyDomeDistance / 2);
layer->setSpan_m(SDSkyDomeDistance);
thesky->add_cloud_layer(layer);
}
else if (SDNbCloudLayers == 1)
{
SDCloudLayer *layer = new SDCloudLayer(datapath);
layer->setCoverage(layer->SD_CLOUD_CIRRUS);
switch (cloudsTextureIndex)
{
case 0:
layer->setCoverage(layer->SD_CLOUD_CLEAR);
break;
case 1:
layer->setCoverage(layer->SD_CLOUD_CIRRUS);
break;
case 2:
case 3:
layer->setCoverage(layer->SD_CLOUD_FEW);
break;
case 4:
case 5:
layer->setCoverage(layer->SD_CLOUD_MANY);
break;
case 6:
case 7:
layer->setCoverage(layer->SD_CLOUD_BROKEN);
break;
default:
layer->setCoverage(layer->SD_CLOUD_OVERCAST);
break;
}
layer->setSpeed(30);
layer->setDirection(20);
layer->setElevation_m(8000);
layer->setElevation_m(2550);
layer->setThickness_m(400 / domeSizeRatio);
layer->setTransition_m(400 / domeSizeRatio);
layer->setSpan_m(SDSkyDomeDistance / 2);
layer->setSpan_m(SDSkyDomeDistance);
thesky->add_cloud_layer(layer);
}
else if (SDNbCloudLayers == 2)
@ -906,20 +932,42 @@ void SDRender::weather(void)
layer->setCoverage(layer->SD_CLOUD_CIRRUS);
layer->setSpeed(30);
layer->setDirection(50);
layer->setElevation_m(8000);
layer->setElevation_m(6000);
layer->setThickness_m(400 / domeSizeRatio);
layer->setTransition_m(400 / domeSizeRatio);
layer->setSpan_m(SDSkyDomeDistance / 2);
layer->setSpan_m(SDSkyDomeDistance);
thesky->add_cloud_layer(layer);
SDCloudLayer *layer2 = new SDCloudLayer(datapath);
layer2->setCoverage(layer2->SD_CLOUD_FEW);
switch (cloudsTextureIndex)
{
case 0:
case 1:
layer->setCoverage(layer->SD_CLOUD_CIRRUS);
break;
case 2:
case 3:
layer->setCoverage(layer->SD_CLOUD_FEW);
break;
case 4:
case 5:
layer->setCoverage(layer->SD_CLOUD_MANY);
break;
case 6:
case 7:
layer->setCoverage(layer->SD_CLOUD_BROKEN);
break;
default:
layer->setCoverage(layer->SD_CLOUD_OVERCAST);
break;
}
layer2->setSpeed(80);
layer2->setDirection(50);
layer2->setElevation_m(3500);
layer2->setThickness_m(400 / domeSizeRatio);
layer2->setTransition_m(400 / domeSizeRatio);
layer2->setSpan_m(SDSkyDomeDistance / 2);
layer2->setSpan_m(SDSkyDomeDistance);
thesky->add_cloud_layer(layer2);
}
else if (SDNbCloudLayers == 3)
@ -928,30 +976,50 @@ void SDRender::weather(void)
layer->setCoverage(layer->SD_CLOUD_CIRRUS);
layer->setSpeed(30);
layer->setDirection(20);
layer->setElevation_m(8000);
layer->setElevation_m(6000);
layer->setThickness_m(400 / domeSizeRatio);
layer->setTransition_m(400 / domeSizeRatio);
layer->setSpan_m(SDSkyDomeDistance / 2);
layer->setSpan_m(SDSkyDomeDistance);
thesky->add_cloud_layer(layer);
SDCloudLayer *layer2 = new SDCloudLayer(datapath);
layer2->setCoverage(layer2->SD_CLOUD_SCATTERED);
layer2->setCoverage(layer2->SD_CLOUD_FEW);
layer2->setSpeed(60);
layer2->setDirection(20);
layer2->setElevation_m(3500);
layer2->setElevation_m(4500);
layer2->setThickness_m(400 / domeSizeRatio);
layer2->setTransition_m(400 / domeSizeRatio);
layer2->setSpan_m(SDSkyDomeDistance / 2);
layer2->setSpan_m(SDSkyDomeDistance);
thesky->add_cloud_layer(layer2);
SDCloudLayer *layer3 = new SDCloudLayer(datapath);
layer3->setCoverage(layer2->SD_CLOUD_FEW);
switch (cloudsTextureIndex)
{
case 0:
case 1:
case 2:
case 3:
layer->setCoverage(layer->SD_CLOUD_FEW);
break;
case 4:
case 5:
layer->setCoverage(layer->SD_CLOUD_MANY);
break;
case 6:
case 7:
layer->setCoverage(layer->SD_CLOUD_BROKEN);
break;
default:
layer->setCoverage(layer->SD_CLOUD_OVERCAST);
break;
}
layer3->setSpeed(90);
layer3->setDirection(20);
layer3->setElevation_m(2500);
layer3->setThickness_m(400 / domeSizeRatio);
layer3->setTransition_m(400 / domeSizeRatio);
layer3->setSpan_m(SDSkyDomeDistance / 2);
layer3->setSpan_m(SDSkyDomeDistance);
thesky->add_cloud_layer(layer3);
}
}

43
src/modules/graphic/osggraph/Sky/OsgCloud.cpp
View file

@ -65,8 +65,8 @@ SDMakeState(const std::string &path, const char* colorTexture, const char* norma
stateSet->setTextureAttributeAndModes(0, texture.get());
stateSet->setTextureMode(0, GL_TEXTURE_2D, osg::StateAttribute::ON);
TmpPath = path+"data/sky/"+normalTexture;
GfLogInfo("Path Sky cloud normal texture = %s\n", TmpPath.c_str());
TmpPath = path+"data/sky/"+normalTexture;
GfLogInfo("Path Sky cloud normal texture = %s\n", TmpPath.c_str());
osg::ref_ptr<osg::Image> image2 = osgDB::readImageFile(TmpPath);
osg::ref_ptr<osg::Texture2D> texture2 = new osg::Texture2D(image2.get());
texture2->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
@ -90,12 +90,12 @@ SDMakeState(const std::string &path, const char* colorTexture, const char* norma
StandardBlendFunc->setSource(BlendFunc::SRC_ALPHA);
StandardBlendFunc->setDestination(BlendFunc::ONE_MINUS_SRC_ALPHA);
StandardBlendFunc->setDataVariance(Object::STATIC);
stateSet->setAttributeAndModes(StandardBlendFunc.get());
stateSet->setMode(GL_FOG, osg::StateAttribute::OFF);
stateSet->setAttributeAndModes(StandardBlendFunc.get());
stateSet->setMode(GL_FOG, osg::StateAttribute::OFF);
stateSet->setMode(GL_DEPTH_TEST, osg::StateAttribute::ON);
stateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON);
stateSet->setMode(GL_LIGHT0, osg::StateAttribute::OFF);
stateSet->setMode(GL_LIGHT0, osg::StateAttribute::OFF);
return stateSet;
}
@ -301,51 +301,26 @@ void SDCloudLayer::rebuild()
state = SDMakeState(texture_path, "overcast_top.png", "overcast_top_n.png");
layer_states2[SD_CLOUD_OVERCAST] = state;
state = SDMakeState(texture_path, "overcast2.png", "overcast2_n.png");
layer_states[SD_CLOUD_OVERCAST2] = state;
state = SDMakeState(texture_path, "overcast2_top.png", "overcast2_top_n.png");
layer_states2[SD_CLOUD_OVERCAST2] = state;
state = SDMakeState(texture_path, "broken.png", "broken_n.png");
layer_states[SD_CLOUD_BROKEN] = state;
layer_states2[SD_CLOUD_BROKEN] = state;
state = SDMakeState(texture_path, "broken2.png", "broken2_n.png");
layer_states[SD_CLOUD_BROKEN2] = state;
layer_states2[SD_CLOUD_BROKEN2] = state;
state = SDMakeState(texture_path, "scattered.png", "scattered_n.png" );
layer_states[SD_CLOUD_SCATTERED] = state;
layer_states2[SD_CLOUD_SCATTERED] = state;
state = SDMakeState(texture_path, "scattered2.png", "scattered2_n.png" );
layer_states[SD_CLOUD_SCATTERED2] = state;
layer_states2[SD_CLOUD_SCATTERED2] = state;
state = SDMakeState(texture_path, "many.png", "many_n.png");
layer_states[SD_CLOUD_MANY] = state;
layer_states2[SD_CLOUD_MANY] = state;
state = SDMakeState(texture_path, "many2.png", "many2_n.png" );
layer_states[SD_CLOUD_MANY2] = state;
layer_states2[SD_CLOUD_MANY2] = state;
state = SDMakeState(texture_path, "few.png", "few_n.png");
layer_states[SD_CLOUD_FEW] = state;
layer_states2[SD_CLOUD_FEW] = state;
state = SDMakeState(texture_path, "few2.png", "few2_n.png");
layer_states[SD_CLOUD_FEW2] = state;
layer_states2[SD_CLOUD_FEW2] = state;
state = SDMakeState(texture_path, "cirrus.png", "cirrus_n.png");
layer_states[SD_CLOUD_CIRRUS] = state;
layer_states2[SD_CLOUD_CIRRUS] = state;
state = SDMakeState(texture_path, "cirrus2.png", "cirrus2_n.png");
layer_states[SD_CLOUD_CIRRUS2] = state;
layer_states2[SD_CLOUD_CIRRUS2] = state;
layer_states[SD_CLOUD_CLEAR] = 0;
layer_states2[SD_CLOUD_CLEAR] = 0;
@ -472,7 +447,7 @@ bool SDCloudLayer::repaint( const osg::Vec3f &fog_color )
= dynamic_cast<osg::TexEnvCombine*>(layer_root->getStateSet()
->getTextureAttribute(1, osg::StateAttribute::TEXENV));
combiner->setConstantColor(combineColor);
return true;
}
@ -515,7 +490,7 @@ bool SDCloudLayer::reposition(const osg::Vec3f &p, double dt )
}
double sp_dist = speed * dt;
if ( p._v[0] != last_x || p._v[1] != last_y || sp_dist != 0 )
{
double ax = 0.0, ay = 0.0, bx = 0.0, by = 0.0;
@ -577,4 +552,4 @@ void SDCloudLayer::set_enable3dClouds(bool enable)
//cloud_root->setChildValue(layer3D->getNode(), false);
cloud_root->setChildValue(layer_root.get(), true);
}
}
}

18
src/modules/graphic/osggraph/Sky/OsgCloud.h
View file

@ -39,19 +39,13 @@ public:
enum Coverage
{
SD_CLOUD_OVERCAST = 0,
SD_CLOUD_OVERCAST2,
SD_CLOUD_BROKEN,
SD_CLOUD_BROKEN2,
SD_CLOUD_MANY,
SD_CLOUD_MANY2,
SD_CLOUD_SCATTERED,
SD_CLOUD_SCATTERED2,
SD_CLOUD_FEW,
SD_CLOUD_FEW2,
SD_CLOUD_CLEAR = 0,
SD_CLOUD_CIRRUS,
SD_CLOUD_CIRRUS2,
SD_CLOUD_CLEAR,
SD_CLOUD_FEW,
SD_CLOUD_SCATTERED,
SD_CLOUD_MANY,
SD_CLOUD_BROKEN,
SD_CLOUD_OVERCAST,
SD_MAX_CLOUD_COVERAGES
};