int main()
{
int n, m;
while(cin >> n >> m, n)
{
int s, g; cin >> s >> g; s--; g--;
vector<vector<road> > roads(n);
for(int i = 0; i < m; i++)
{
int x, y, d, c; cin >> x >> y >> d >> c; x--; y--;
roads[x].push_back(road(y, d, c));
roads[y].push_back(road(x, d, c));
}
priority_queue<state> Q;
Q.push(state(s, s, 0, 0.0));
double ans = -1;
bool done[32][32][32] = {};
while(!Q.empty())
{
state cur = Q.top(); Q.pop();
int pos = cur.pos, speed = cur.speed, from = cur.from;
double time = cur.time;
//cout << pos << "," << speed << "," << time << endl;
if(done[pos][speed][from])
continue;
done[pos][speed][from] = true;
if(pos == g && speed == 1)
{
ans = time;
break;
}
for(size_t i = 0; i < roads[pos].size(); i++)
{
int npos = roads[pos][i].to;
if(from == npos)
continue;
for(int ds = -1; ds <= 1; ds++)
{
int nspeed = speed + ds;
if(nspeed >= 1 && nspeed <= roads[pos][i].lim && !done[npos][nspeed][pos])
{
double ntime = time + (double)roads[pos][i].d / nspeed;
state nstate = state(npos, pos, nspeed, ntime);
Q.push(nstate);
}
}
}
}
if(ans == -1)
cout << "unreachable" << endl;
else
printf("%.4f\n", ans);
}
return 0;
}
void add_road(char letter, std::string replace, int id)
{
// emplace_back
// - constructs the element
// - where we want it to be built
roads.emplace_back(road(letter, replace, id));
}
std::vector<Road> Algorithm::findShortestPath(MultiGraph<double, Station>* graph, Station* start, Station* end ,double &lenght)
{
DynamicArray<Station> *stations = graph->getVertexs();
std::vector<Road> result;
if (stations->getIndex(start) != -1 && stations->getIndex(end) != -1)
{
DynamicArray<Station> *vertexs = graph->getVertexs();
int size = vertexs->getSize();
double* arr = new double[size*size];
Graph g;
g.resize(size);
for (int i = 0; i < size; i++)
{
Station*startTemp= vertexs->get(i);
for (int j = 0; j < size; j++)
{
Station*endTemp = vertexs->get(j);
DynamicArray<double>* values = graph->getLenghtsByStation(startTemp, endTemp);
if (values != 0 && values->getSize() > 0)
{
double value = Algorithm::findMin(values);
arr[j*size + i] = value;
g[i].push_back(std::make_pair(j, value));
}
}
}
std::vector<int> path;
int startIndex = vertexs->getIndex(start);
int endIndex = vertexs->getIndex(end);
dijkstra(g, startIndex, endIndex, path);
double sum = 0;
for (int i = path.size() - 1; i >= 0; i--)
{
if (i - 1 >= 0)
{
Station * resultStart = vertexs->get(path[i]);
Station * resultEnd = vertexs->get(path[i - 1]);
Road road(resultStart, resultEnd);
result.push_back(road);
sum += arr[path[i - 1] * size + path[i]];
}
//std::cout << path[i] << "->";
}
//cout << "\n";
//cout << sum;
lenght = sum;
delete[] arr;
}
return result;
}
template<> void OldLoadSavePolicy<RoadChunkTableSync,MainRoadChunk>::Load(
MainRoadChunk* object,
const db::DBResultSPtr& rows,
Env& env,
LinkLevel linkLevel
){
// Rank in road
int rankInRoad (rows->getInt (RoadChunkTableSync::COL_RANKINPATH));
object->setRankInPath(rankInRoad);
// Metric offset
object->setMetricOffset(rows->getDouble (RoadChunkTableSync::COL_METRICOFFSET));
// Geometry
string viaPointsStr(rows->getText (TABLE_COL_GEOMETRY));
if(viaPointsStr.empty())
{
object->setGeometry(boost::shared_ptr<LineString>());
}
else
{
object->setGeometry(
dynamic_pointer_cast<LineString,Geometry>(rows->getGeometryFromWKT(TABLE_COL_GEOMETRY))
);
}
if (linkLevel > FIELDS_ONLY_LOAD_LEVEL)
{
bool noMotorVehicles(false);
try
{
boost::shared_ptr<MainRoadPart> road(RoadTableSync::GetEditable(rows->getLongLong(RoadChunkTableSync::COL_ROADID), env, linkLevel));
object->setRoad(road.get());
object->setFromCrossing(
CrossingTableSync::GetEditable(
rows->getLongLong(RoadChunkTableSync::COL_CROSSING_ID),
env,
linkLevel
).get()
);
road->addRoadChunk(*object);
/*
TODO Backward compatibility.
Useless for OpenStreetMap datas since non_drivable field in database (r8381)
and after a fresh OSM import.
Now the OSM importer check those fields (and some more) and save it into DB.
Should be useless soon for OSM graph, might be still usefull for pure road
journey planning on NAVTEQ graph (must be pretty rare).
*/
switch(road->getType())
{
case Road::ROAD_TYPE_PEDESTRIANSTREET:
case Road::ROAD_TYPE_PEDESTRIANPATH:
case Road::ROAD_TYPE_STEPS:
case Road::ROAD_TYPE_PRIVATEWAY:
noMotorVehicles = true;
break;
default:
noMotorVehicles = false;
break;
}
}
catch (ObjectNotFoundException<Road>& e)
{
throw LinkException<RoadChunkTableSync>(rows, RoadChunkTableSync::COL_ROADID, e);
}
catch (ObjectNotFoundException<Crossing>& e)
{
throw LinkException<RoadChunkTableSync>(rows, RoadChunkTableSync::COL_CROSSING_ID, e);
}
// Left house number bounds
if( !rows->getText(RoadChunkTableSync::COL_LEFT_START_HOUSE_NUMBER).empty() &&
!rows->getText(RoadChunkTableSync::COL_LEFT_END_HOUSE_NUMBER).empty()
){
object->setLeftHouseNumberBounds(
MainRoadChunk::HouseNumberBounds(MainRoadChunk::HouseNumberBounds::value_type(
rows->getInt(RoadChunkTableSync::COL_LEFT_START_HOUSE_NUMBER),
rows->getInt(RoadChunkTableSync::COL_LEFT_END_HOUSE_NUMBER)
) ));
// Left House numbering policy
object->setLeftHouseNumberingPolicy(
static_cast<MainRoadChunk::HouseNumberingPolicy>(rows->getInt(RoadChunkTableSync::COL_LEFT_HOUSE_NUMBERING_POLICY))
);
}
// Right house number bounds
if( !rows->getText(RoadChunkTableSync::COL_RIGHT_START_HOUSE_NUMBER).empty() &&
!rows->getText(RoadChunkTableSync::COL_RIGHT_END_HOUSE_NUMBER).empty()
){
object->setRightHouseNumberBounds(
MainRoadChunk::HouseNumberBounds(MainRoadChunk::HouseNumberBounds::value_type(
rows->getInt(RoadChunkTableSync::COL_RIGHT_START_HOUSE_NUMBER),
rows->getInt(RoadChunkTableSync::COL_RIGHT_END_HOUSE_NUMBER)
) ));
// Right House numbering policy
object->setRightHouseNumberingPolicy(
static_cast<MainRoadChunk::HouseNumberingPolicy>(rows->getInt(RoadChunkTableSync::COL_RIGHT_HOUSE_NUMBERING_POLICY))
);
}
RuleUser::Rules rules(RuleUser::GetEmptyRules());
rules[USER_PEDESTRIAN - USER_CLASS_CODE_OFFSET] = AllowedUseRule::INSTANCE.get();
rules[USER_HANDICAPPED - USER_CLASS_CODE_OFFSET] = AllowedUseRule::INSTANCE.get();
rules[USER_BIKE - USER_CLASS_CODE_OFFSET] = AllowedUseRule::INSTANCE.get();
rules[USER_CAR - USER_CLASS_CODE_OFFSET] = AllowedUseRule::INSTANCE.get();
if(rows->getBool(RoadChunkTableSync::COL_NON_WALKABLE))
{
rules[USER_PEDESTRIAN - USER_CLASS_CODE_OFFSET] = ForbiddenUseRule::INSTANCE.get();
rules[USER_HANDICAPPED - USER_CLASS_CODE_OFFSET] = ForbiddenUseRule::INSTANCE.get();
}
if(rows->getBool(RoadChunkTableSync::COL_NON_BIKABLE))
{
rules[USER_BIKE - USER_CLASS_CODE_OFFSET] = ForbiddenUseRule::INSTANCE.get();
}
int oneWay = rows->getInt(RoadChunkTableSync::COL_ONE_WAY);
if(rows->getBool(RoadChunkTableSync::COL_NON_DRIVABLE) || noMotorVehicles)
{
rules[USER_CAR - USER_CLASS_CODE_OFFSET] = ForbiddenUseRule::INSTANCE.get();
object->getReverseRoadChunk()->setRules(rules);
object->setRules(rules);
}
else if(oneWay == 1)
{
object->setRules(rules);
rules[USER_CAR - USER_CLASS_CODE_OFFSET] = ForbiddenUseRule::INSTANCE.get();
object->getReverseRoadChunk()->setRules(rules);
}
else if(oneWay == -1)
{
object->getReverseRoadChunk()->setRules(rules);
rules[USER_CAR - USER_CLASS_CODE_OFFSET] = ForbiddenUseRule::INSTANCE.get();
object->setRules(rules);
}
else
{
object->getReverseRoadChunk()->setRules(rules);
object->setRules(rules);
}
double maxSpeed = rows->getDouble(RoadChunkTableSync::COL_CAR_SPEED);
object->setCarSpeed(maxSpeed);
object->getReverseRoadChunk()->setCarSpeed(maxSpeed);
if(linkLevel > FIELDS_ONLY_LOAD_LEVEL)
{
// Useful transfer calculation
object->getHub()->clearAndPropagateUsefulTransfer(RoadModule::GRAPH_ID);
}
}
}
void OsmAnd::ObfRoutingSectionReader_P::readSubsectionData(
const std::unique_ptr<ObfReader_P>& reader, const std::shared_ptr<const ObfRoutingSubsectionInfo>& subsection,
QList< std::shared_ptr<const Model::Road> >* resultOut /*= nullptr*/,
QMap< uint64_t, std::shared_ptr<const Model::Road> >* resultMapOut /*= nullptr*/,
IQueryFilter* filter /*= nullptr*/,
std::function<bool (const std::shared_ptr<const Model::Road>&)> visitor /*= nullptr*/ )
{
QStringList roadNamesTable;
QList<uint64_t> roadsIdsTable;
QMap< uint32_t, std::shared_ptr<Model::Road> > resultsByInternalId;
auto cis = reader->_codedInputStream.get();
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
{
for(const auto& road : constOf(resultsByInternalId))
{
// Fill names of roads from stringtable
for(auto& encodedId : road->_names)
{
const uint32_t stringId = ObfReaderUtilities::decodeIntegerFromString(encodedId);
encodedId = roadNamesTable[stringId];
}
if(!visitor || visitor(road))
{
if(resultOut)
resultOut->push_back(road);
if(resultMapOut)
resultMapOut->insert(road->_id, road);
}
}
}
return;
case OBF::OsmAndRoutingIndex_RouteDataBlock::kIdTableFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
readSubsectionRoadsIds(reader, subsection, roadsIdsTable);
cis->PopLimit(oldLimit);
}
break;
case OBF::OsmAndRoutingIndex_RouteDataBlock::kDataObjectsFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
std::shared_ptr<Model::Road> road(new Model::Road(subsection));
uint32_t internalId;
readRoad(reader, subsection, roadsIdsTable, internalId, road);
resultsByInternalId.insert(internalId, road);
cis->PopLimit(oldLimit);
}
break;
case OBF::OsmAndRoutingIndex_RouteDataBlock::kRestrictionsFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
readSubsectionRestriction(reader, subsection, resultsByInternalId, roadsIdsTable);
cis->PopLimit(oldLimit);
}
break;
case OBF::OsmAndRoutingIndex_RouteDataBlock::kStringTableFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
ObfReaderUtilities::readStringTable(cis, roadNamesTable);
cis->PopLimit(oldLimit);
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
// Clears the window and draws the torus.
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef(rotate_x, 1.0, 0.0, 0.0);
glRotatef(rotate_y, 0.0, 1.0, 0.0);
glScaled(zoom, zoom, zoom);
// Draw a red x-axis, a green y-axis, and a blue z-axis. Each of the
// axes are ten units long.
glBegin(GL_LINES);
glColor3f(1, 0, 0); glVertex3f(0, 0, 0); glVertex3f(10, 0, 0);
glColor3f(0, 1, 0); glVertex3f(0, 0, 0); glVertex3f(0, 10, 0);
glColor3f(0, 0, 1); glVertex3f(0, 0, 0); glVertex3f(0, 0, 10);
glEnd();
// Road
cube road(point(),2);
road.scale(1.0,0.0,10.0);
// road.rotate(point(0.0,0.0,0.0), point(1.0,0.0,0.0), 90.0);
road.render();
// Home
cube home(point(),4);
home.translate(point(5.0,2,5.0));
home.setColor (1.0,0.0,0.0);
home.render();
/* cube door(point(),2);
door.translate(point(5.0,1,7.0));
door.scale(0.25,1,0.25);
door.setColor (0.0,0.0,0.0);
door.render(); */
// Tree
cube trunk(point(0.0,2,0.0),4);
trunk.scale(0.25,1,0.25);
sphere tree(point(0.0,5.0,0.0),2.0);
tree.translate(point(-2.0,0,0));
trunk.translate(point(-2.0,0,0));
tree.setColor (0.0f, 1.0f, 0.0);
tree.render();
trunk.render();
// Body
sphere tummy(point(),1.0);
sphere head(point(0.0,1.0,0.0),0.25);
tummy.scale(0.25,1.0,0.25);
tummy.translate(point(3.0,0.75,-3.0));
head.translate(point(3.0,0.5,-3.0));
tummy.setColor (0,0,0); // black
head.setColor (1,0,0); // red
tummy.render();
head.render();
// hands
cube hand(point(),0.4);
hand.scale(1.0,0.0,1.0);
hand.translate(point(3.0,0.75,-3.0));
hand.setColor (0.0,1.0,1.0);
hand.render();
// legs
cube legs(point(),0.4);
// legs.scale(1.0,0.0,0.25);
legs.translate(point(3.0,-0.2,-3.0));
legs.setColor (0.0,1.0,1.0);
legs.render();
glFlush();
glutSwapBuffers();
}
void display3()
{
glClear(GL_COLOR_BUFFER_BIT);
road();
mountain();
//brown
glBegin(GL_POLYGON);
glColor3f(0.9,0.3,0.0);
glVertex2i(-10,300);
glVertex2i(645,310);
glVertex2i(940,100);
glVertex2i(-10,100);
glEnd();
building();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(0.0,30.0);
glVertex2f(0.0,55.0);
glVertex2f(135.0,55.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(135.0,40.0);
glVertex2f(160.0,40.0);
glVertex2f(160.0,37.0);
glVertex2f(145.0,30.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(0.0,55.0);
glVertex2f(0.0,80.0);
glVertex2f(10.0,80.0);
glVertex2f(40.0,55.0);
//glVertex2f(165.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(65.0,55.0);
glVertex2f(50.0,70.0);
glVertex2f(75.0,70.0);
glVertex2f(90.0,55.0);
//glVertex2f(165.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(70.0,40.0);
glVertex2f(100.0,40.0);
glVertex2f(80.0,15.0);
glVertex2f(50.0,15.0);
glEnd();
glPopMatrix();
glutSwapBuffers();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
if(flag==0)
{
glRasterPos3f(58,58,0);
for(i=0;s[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s[i]);
glRasterPos3f(45,450,0);
for(i=0;s1[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s1[i]);
glRasterPos3f(90,358,0);
for(i=0;s2[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s2[i]);
glRasterPos3f(70,338,0);
for(i=0;s3[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s3[i]);
glRasterPos3f(218,218,0);
for(i=0;s4[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s4[i]);
glRasterPos3f(350,218,0);
for(i=0;s5[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s5[i]);
glRasterPos3f(250,150,0);
for(i=0;s6[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s6[i]);
glColor3f(1.0,1.0,0.0);
glRasterPos3f(250,130,0);
for(i=0;s7[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s7[i]);
glRasterPos3f(250,100,0);
for(i=0;s8[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s8[i]);
glRasterPos3f(58,28,0);
for(i=0;s9[i]!='\0';i++)
glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24,s9[i]);
}
else
{
road();
mountain();
//green
glBegin(GL_POLYGON);
glColor3f(0.0,1.0,0.0);
glVertex2i(-10,300);
glVertex2i(645,310);
glVertex2i(940,100);
glVertex2i(-10,100);
glEnd();
trees();
//plane construction
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1,1,1);
glBegin(GL_POLYGON);//rectangular body
glVertex2f(0.0,30.0);
glVertex2f(0.0,55.0);
glVertex2f(135.0,55.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);//upper triangle construction plane
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);//outline of upper triangle plane
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//lower triangle
glVertex2f(135.0,40.0);
glVertex2f(160.0,40.0);
glVertex2f(160.0,37.0);
glVertex2f(145.0,30.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//back wing
glVertex2f(0.0,55.0);
glVertex2f(0.0,80.0);
glVertex2f(10.0,80.0);
glVertex2f(40.0,55.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//left side wing
glVertex2f(65.0,55.0);
glVertex2f(50.0,70.0);
glVertex2f(75.0,70.0);
glVertex2f(90.0,55.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//rightside wing
glVertex2f(70.0,40.0);
glVertex2f(100.0,40.0);
glVertex2f(80.0,15.0);
glVertex2f(50.0,15.0);
glEnd();
glPopMatrix();
if(c>390) //timer to jump to next display
{
display2();
d+=5;//plane takeoff on x in 2nd display
}
if(a>500.0)//window position during take off
{
a=0.0;
b=0.0;
}
if(c>800)//timer to jump to 3rd display
{
display3();
e+=5;//plane takeoff on x in 3rd display
if(e>250)//timer to call blast function
{
blast();
e=250;
}
}
}
glFlush();
glutSwapBuffers();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
GLfloat ambientLight[] = {1.0f, 1.0f, 1.0f, 1.0f};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight);
GLfloat directedLight[] = {0.0f, 1.0f, 1.0f, 1.0f};
GLfloat directedLightPos[] = {1.0f, 0.3f, 0.9f, 1.0f};
glLightfv(GL_LIGHT0, GL_DIFFUSE, directedLight);
glLightfv(GL_LIGHT0, GL_POSITION, directedLightPos);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, _textureId);
//Bottom
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glColor3f(1.0f, 1.0f,1.0f);
glBegin(GL_QUADS);
glNormal3f(0.0, 0.0f, -1.0f);
glTexCoord2f(0.0f, 0.5f);
glVertex3f(-99355.5f, 50.5f, -100.9f);
glTexCoord2f(280.0f, 0.5f);
glVertex3f(100000.5f, 50.5f, -100.9f);
glTexCoord2f(280.0f, 1.0f);
glVertex3f(100000.5f, 200.5f, -100.9f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-99355.5f, 200.5f, -100.9f);
glEnd();
//glDisable(GL_TEXTURE_ID);
gluLookAt(-25+front,15+up,0,0+front,0,0,0,1,0);
if(flag==1)
{
changelookat();
}
//object();
drawObject();
grid();
road();
ball();
if(keyPressed==1)
{
glutTimerFunc(1000,idle,1);
}
else if(keyPressed==-1)
{
glutTimerFunc(4,idle,1);
}
else
{
// Do Nothing
}
/*if(lrKeyPressed==1)
{
//specialKeys(GLUT_KEY_UP,mouseX,mouseY);
lrKeyPressed=0;
specialKeys(GLUT_KEY_REPEAT_DEFAULT,mouseX,mouseY);
}*/
glutTimerFunc(40,movingObject,1);
glutSwapBuffers();
}
