#ifndef FUNKTIONEN_H_INCLUDED
#define FUNKTIONEN_H_INCLUDED
using namespace irr;
using namespace core;
using namespace video;
time_t Zeit;
struct tm *LokalZeit;
f32 fJulianischesDatum;
core::vector3df EarthPos; //Positionsvektor unserer Erde
core::vector3df MoonPos; //Positionsvektor unseres Monds
core::vector3df MercuryPos; //Positionsvektor des Merkur
core::vector3df VenusPos; //Positionsvektor der Venus
core::vector3df MarsPos; //Positionsvektor des Mars
core::vector3df JupiterPos; //Positionsvektor des Jupiter
core::vector3df SaturnPos; //Positionsvektor des Saturn
core::vector3df UranusPos; //Positionsvektor des Uranus
core::vector3df NeptunPos; //Positionsvektor des Neptun
core::vector3df PlutoPos; //Positionsvektor des Pluto
scene::IAnimatedMesh* SaturnRingMesh;
scene::ISceneNode * Saturn_Ringe;
scene::ISceneNode * Sonne;
scene::ISceneNode * Erde;
scene::ISceneNode * Mond;
scene::ISceneNode * Merkur;
scene::ISceneNode * Venus;
scene::ISceneNode * Mars;
scene::ISceneNode * Jupiter;
scene::ISceneNode * Saturn;
scene::ISceneNode * Uranus;
scene::ISceneNode * Neptun;
scene::ISceneNode * Pluto;
scene::ISceneNode * SkyBox;
scene::ISceneNode * Lightnode;
////////////////////////////////////
// Unsere Arrays zum Nachzeichnen //
// des zurückgelegten Orbits //
////////////////////////////////////
const int max_array = 50000; //Maximale Anzahl an Werten im Array
//Merkur
core::vector3df *v3dfMerkur; //Das Array mit den Orbit-Vektoren
u32 uiPosArrayMerkur = 0; //Aktuelle Position im Array
core::vector3df *v3dfVenus; u32 uiPosArrayVenus = 0;//Venus
core::vector3df *v3dfErde; u32 uiPosArrayErde = 0; //Erde
core::vector3df *v3dfMars; u32 uiPosArrayMars = 0; //Mars
core::vector3df *v3dfJupiter; u32 uiPosArrayJupiter = 0; //Jupiter
core::vector3df *v3dfSaturn; u32 uiPosArraySaturn = 0; //Saturn
core::vector3df *v3dfUranus; u32 uiPosArrayUranus = 0; //Uranus
core::vector3df *v3dfNeptun; u32 uiPosArrayNeptun = 0; //Neptun
core::vector3df *v3dfPluto; u32 uiPosArrayPluto = 0; //Pluto
void ErstellePlaneten(scene::ISceneManager* smgr, IVideoDriver* driver)
{
const f32 fTemp = 10; //Planeten um Faktor 10 i.V. zum Masstab vergrößern
//Erstellen der SceneNodes
Sonne = smgr->addSphereSceneNode(Info_Sonne.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1001); //Sonne
Erde = smgr->addSphereSceneNode(Info_Erde.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1002); //Erde
Mond = smgr->addSphereSceneNode(Info_Mond.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1003); //Mond
Merkur = smgr->addSphereSceneNode(Info_Merkur.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1004); //Merkur
Venus = smgr->addSphereSceneNode(Info_Venus.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1005); //Venus
Mars = smgr->addSphereSceneNode(Info_Venus.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1006); //Mars
Jupiter = smgr->addSphereSceneNode(Info_Jupiter.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1007); //Jupiter
Saturn = smgr->addSphereSceneNode(Info_Saturn.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1008); //Saturn
Uranus = smgr->addSphereSceneNode(Info_Uranus.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1009); //Uranus
Neptun = smgr->addSphereSceneNode(Info_Neptun.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1010); //Neptun
Pluto = smgr->addSphereSceneNode(Info_Pluto.f_Durchmesser / (fMassstab / fTemp), 32, 0, 1011); //Pluto
SaturnRingMesh = smgr->addHillPlaneMesh( "SaturnRings", //param name
core::dimension2d<f32>(2,2), //param tileSize
core::dimension2d<u32>(40,40), //param tileCount
0, //param material
0, //param hillHeight
core::dimension2d<f32>(0,0), //param countHills
core::dimension2d<f32>(1,1)); //param textureRepeatCount
Saturn_Ringe = smgr->addMeshSceneNode(
SaturnRingMesh, Saturn);
Saturn_Ringe->setMaterialTexture(0, driver->getTexture("Saturn_Rings.tga"));
Saturn_Ringe->getMaterial(0).MaterialType = EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
Saturn_Ringe->getMaterial(0).BackfaceCulling = false;
//Einstellen des Materials
Sonne->setMaterialTexture(0, driver->getTexture("Sun.png"));
Erde->setMaterialTexture(0, driver->getTexture("Earth.jpg"));
Mond->setMaterialTexture(0, driver->getTexture("Moon.jpg"));
Merkur->setMaterialTexture(0, driver->getTexture("Merkur.jpg"));
Venus->setMaterialTexture(0, driver->getTexture("Venus.jpg"));
Mars->setMaterialTexture(0, driver->getTexture("Mars.jpg"));
Jupiter->setMaterialTexture(0, driver->getTexture("Jupiter.jpg"));
Saturn->setMaterialTexture(0, driver->getTexture("Saturn.jpg"));
Uranus->setMaterialTexture(0, driver->getTexture("Uranus.jpg"));
Neptun->setMaterialTexture(0, driver->getTexture("Neptun.jpg"));
Pluto->setMaterialTexture(0, driver->getTexture("Pluto.jpg"));
//Keine Lichtberechnung für die Sonne
Sonne->setMaterialFlag(EMF_LIGHTING, false);
};
void BerechnePlanetenPositionen()
{
//Errechnen der Position des Merkur
MercuryPos = BerechnePosition_Planet(fJulianischesDatum, 1);
//Errechnen der Position der Venus
VenusPos = BerechnePosition_Planet(fJulianischesDatum, 2);
//Errechnen der Position der Erde
EarthPos = BerechnePosition_Planet(fJulianischesDatum, 3);
//Errechnen der Position des Mars
MarsPos = BerechnePosition_Planet(fJulianischesDatum, 4);
//Errechnen der Position des Jupiter
JupiterPos = BerechnePosition_Planet(fJulianischesDatum, 5);
//Errechnen der Position des Saturn
SaturnPos = BerechnePosition_Planet(fJulianischesDatum, 6);
//Errechnen der Position des Uranus
UranusPos = BerechnePosition_Planet(fJulianischesDatum, 7);
//Errechnen der Position des Neptun
NeptunPos = BerechnePosition_Planet(fJulianischesDatum, 8);
//Errechnen der Position des Pluto
PlutoPos = BerechnePosition_Planet(fJulianischesDatum, 9);
//Errechnen der Position des Monds
MoonPos = core::vector3df(
EarthPos.X + ((Info_Mond.f_Periphel / fMassstab) * sinf(fJulianischesDatum)),
0,
EarthPos.Z + ((Info_Mond.f_Aphel / fMassstab) * cosf(fJulianischesDatum))
);
};
void PositionierePlaneten()
{
Erde->setPosition(EarthPos);
Mond->setPosition(MoonPos);
Merkur->setPosition(MercuryPos);
Venus->setPosition(VenusPos);
Mars->setPosition(MarsPos);
Jupiter->setPosition(JupiterPos);
Saturn->setPosition(SaturnPos);
Uranus->setPosition(UranusPos);
Neptun->setPosition(NeptunPos);
Pluto->setPosition(PlutoPos);
};
void SpeichereZeit()
{
time(&Zeit); //Die aktuelle Systemzeit auslesen
#pragma warning(disable : 4996) //Compilerwarnung ausschalten
LokalZeit = localtime(&Zeit); //Zeitwert zerlegen
};
f32 Berechne_Julianisches_Datum(struct tm *LokalZeit)
{
f32 JulianischesDatum = 0.0f;
s32 Jahr = 0;
s32 Monat = 0;
s32 Tag = 0;
s32 Stunde = 0;
s32 Minute = 0;
s32 Sekunde = 0;
s32 Hilfswert_B = 0;
f32 fUhrzeit = 0.0f; //Die Uhrzeit als Gleitkommazahl
if (LokalZeit->tm_mon <= 1) //Monat <= Februar ?
{
Jahr = ((LokalZeit->tm_year + 1900) - 1); //Ein Jahr abziehen
Monat = ((LokalZeit->tm_mon + 1) + 12); //12 Monate hinzuaddieren
} else
{
Jahr = (LokalZeit->tm_year + 1900); //Jahr speichern
Monat = (LokalZeit->tm_mon + 1); //Monat speichern
}
Tag = LokalZeit->tm_mday; //Tag speichern
Stunde = LokalZeit->tm_hour; //Stunde speichern
Minute = LokalZeit->tm_min; //Minute speichern
Sekunde = LokalZeit->tm_sec; //Sekunde speichern
Hilfswert_B = (int(Jahr / 400) - int(Jahr / 100)); //Hilfswert B berechnen
fUhrzeit = (Stunde +
(Minute * (1.0f / 60.0f)) + //1 Min. = 60 Sek.
(Sekunde * (1.0f / 3600.0f)) //1 Min. = 3600 Sek.
); //Uhrzeit als Gleitkommazahl
JulianischesDatum = int(365.25f * Jahr) +
int(30.6001f * (Monat + 1)) +
Hilfswert_B +
1720996.5f + Tag + (fUhrzeit / 24.0f);
return JulianischesDatum;
};
void Verfolge_gewaehlten_Planeten(IrrlichtDevice *device)
{
scene::ICameraSceneNode* Kamera = device->getSceneManager()->getActiveCamera();
switch(uAktuellerPlanet)
{
case 0: Kamera->setPosition(vector3df(0.0f, 10000.0f, -10000.0f));
Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1001)->getAbsolutePosition()); //Sonne
break;
case 1: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1004)->getAbsolutePosition()); //Merkur
break;
case 2: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1005)->getAbsolutePosition()); //Venus
break;
case 3: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1002)->getAbsolutePosition()); //Erde
break;
case 4: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1006)->getAbsolutePosition()); //Mars
break;
case 5: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1007)->getAbsolutePosition()); //Jupiter
break;
case 6: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1008)->getAbsolutePosition()); //Saturn
break;
case 7: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1009)->getAbsolutePosition()); //Uranus
break;
case 8: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1010)->getAbsolutePosition()); //Neptun
break;
case 9: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1011)->getAbsolutePosition()); //Pluto
break;
case 10: Kamera->setTarget(device->getSceneManager()->getSceneNodeFromId(1012)->getAbsolutePosition()); //Eris
break;
}
};
void Erstelle_Orbit_Arrays()
{
//Erstellen des Arrays (0...max_array)
//Erde
v3dfErde = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfErde[uiPosArrayErde] = EarthPos; //Letzte Position als ersten Array-Eintrag speichern
//Merkur
v3dfMerkur = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfMerkur[uiPosArrayMerkur] = MercuryPos; //Letzte Position als ersten Array-Eintrag speichern
//Venus
v3dfVenus = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfVenus[uiPosArrayVenus] = VenusPos; //Letzte Position als ersten Array-Eintrag speichern
//Mars
v3dfMars = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfMars[uiPosArrayMars] = MarsPos; //Letzte Position als ersten Array-Eintrag speichern
//Jupiter
v3dfJupiter = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfJupiter[uiPosArrayJupiter] = JupiterPos; //Letzte Position als ersten Array-Eintrag speichern
//Saturn
v3dfSaturn = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfSaturn[uiPosArraySaturn] = SaturnPos; //Letzte Position als ersten Array-Eintrag speichern
//Uranus
v3dfUranus = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfUranus[uiPosArrayUranus] = UranusPos; //Letzte Position als ersten Array-Eintrag speichern
//Neptun
v3dfNeptun = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfNeptun[uiPosArrayNeptun] = NeptunPos; //Letzte Position als ersten Array-Eintrag speichern
//Pluto
v3dfPluto = (core::vector3df *)malloc(max_array*sizeof(core::vector3df));
v3dfPluto[uiPosArrayPluto] = PlutoPos; //Letzte Position als ersten Array-Eintrag speichern
};
void Pruefe_Orbit_Pos()
{
//Hat sich die Erde bewegt ?
if ((v3dfErde[uiPosArrayErde].X != EarthPos.X) &&
(v3dfErde[uiPosArrayErde].Y != EarthPos.Y) &&
(v3dfErde[uiPosArrayErde].Z != EarthPos.Z))
{
if (uiPosArrayErde <= max_array) uiPosArrayErde++; //Nächsten Array-Eintrag
v3dfErde[uiPosArrayErde] = EarthPos;
}
//Hat sich der Merkur bewegt ?
if ((v3dfMerkur[uiPosArrayMerkur].X != MercuryPos.X) &&
(v3dfMerkur[uiPosArrayMerkur].Y != MercuryPos.Y) &&
(v3dfMerkur[uiPosArrayMerkur].Z != MercuryPos.Z))
{
if (uiPosArrayMerkur <= max_array) uiPosArrayMerkur++; //Nächsten Array-Eintrag
v3dfMerkur[uiPosArrayMerkur] = MercuryPos;
}
//Hat sich die Venus bewegt ?
if ((v3dfVenus[uiPosArrayVenus].X != VenusPos.X) &&
(v3dfVenus[uiPosArrayVenus].Y != VenusPos.Y) &&
(v3dfVenus[uiPosArrayVenus].Z != VenusPos.Z))
{
if (uiPosArrayVenus <= max_array) uiPosArrayVenus++; //Nächsten Array-Eintrag
v3dfVenus[uiPosArrayVenus] = VenusPos;
}
//Hat sich der Mars bewegt ?
if ((v3dfMars[uiPosArrayMars].X != MarsPos.X) &&
(v3dfMars[uiPosArrayMars].Y != MarsPos.Y) &&
(v3dfMars[uiPosArrayMars].Z != MarsPos.Z))
{
if (uiPosArrayMars <= max_array) uiPosArrayMars++; //Nächsten Array-Eintrag
v3dfMars[uiPosArrayMars] = MarsPos;
}
//Hat sich der Jupiter bewegt ?
if ((v3dfJupiter[uiPosArrayJupiter].X != JupiterPos.X) &&
(v3dfJupiter[uiPosArrayJupiter].Y != JupiterPos.Y) &&
(v3dfJupiter[uiPosArrayJupiter].Z != JupiterPos.Z))
{
if (uiPosArrayJupiter <= max_array) uiPosArrayJupiter++; //Nächsten Array-Eintrag
v3dfJupiter[uiPosArrayJupiter] = JupiterPos;
}
//Hat sich der Saturn bewegt ?
if ((v3dfSaturn[uiPosArraySaturn].X != SaturnPos.X) &&
(v3dfSaturn[uiPosArraySaturn].Y != SaturnPos.Y) &&
(v3dfSaturn[uiPosArraySaturn].Z != SaturnPos.Z))
{
if (uiPosArraySaturn <= max_array) uiPosArraySaturn++; //Nächsten Array-Eintrag
v3dfSaturn[uiPosArraySaturn] = SaturnPos;
}
//Hat sich der Uranus bewegt ?
if ((v3dfUranus[uiPosArrayUranus].X != UranusPos.X) &&
(v3dfUranus[uiPosArrayUranus].Y != UranusPos.Y) &&
(v3dfUranus[uiPosArrayUranus].Z != UranusPos.Z))
{
if (uiPosArrayUranus <= max_array) uiPosArrayUranus++; //Nächsten Array-Eintrag
v3dfUranus[uiPosArrayUranus] = UranusPos;
}
//Hat sich der Neptun bewegt ?
if ((v3dfNeptun[uiPosArrayNeptun].X != NeptunPos.X) &&
(v3dfNeptun[uiPosArrayNeptun].Y != NeptunPos.Y) &&
(v3dfNeptun[uiPosArrayNeptun].Z != NeptunPos.Z))
{
if (uiPosArrayNeptun <= max_array) uiPosArrayNeptun++; //Nächsten Array-Eintrag
v3dfNeptun[uiPosArrayNeptun] = NeptunPos;
}
//Hat sich der Pluto bewegt ?
if ((v3dfPluto[uiPosArrayPluto].X != PlutoPos.X) &&
(v3dfPluto[uiPosArrayPluto].Y != PlutoPos.Y) &&
(v3dfPluto[uiPosArrayPluto].Z != PlutoPos.Z))
{
if (uiPosArrayPluto <= max_array) uiPosArrayPluto++; //Nächsten Array-Eintrag
v3dfPluto[uiPosArrayPluto] = PlutoPos;
}
};
void Zeichne_tatsaechlichen_Orbit(IVideoDriver *driver)
{
video::SMaterial mat;
mat.Lighting = false;
driver->setMaterial(mat);
//Weltkoordinaten verwenden (keine lokalen Koordinaten)
driver->setTransform(video::ETS_WORLD, core::matrix4());
//Erde
for(unsigned int i = 0; i <= uiPosArrayErde; i++)
{
if (uiPosArrayErde >2) driver->draw3DLine(v3dfErde[i-1],v3dfErde[i],SColor(255,255,255,0));
}
//Merkur
for(unsigned int i = 0; i <= uiPosArrayMerkur; i++)
{
if (uiPosArrayMerkur >2) driver->draw3DLine(v3dfMerkur[i-1],v3dfMerkur[i],SColor(255,125,255,100));
}
//Venus
for(unsigned int i = 0; i <= uiPosArrayVenus; i++)
{
if (uiPosArrayVenus >2) driver->draw3DLine(v3dfVenus[i-1],v3dfVenus[i],SColor(200,0,255,125));
}
//Mars
for(unsigned int i = 0; i <= uiPosArrayMars; i++)
{
if (uiPosArrayMars >2) driver->draw3DLine(v3dfMars[i-1],v3dfMars[i],SColor(200,0,255,125));
}
//Jupiter
for(unsigned int i = 0; i <= uiPosArrayJupiter; i++)
{
if (uiPosArrayJupiter >2) driver->draw3DLine(v3dfJupiter[i-1],v3dfJupiter[i],SColor(200,255,100,70));
}
//Saturn
for(unsigned int i = 0; i <= uiPosArraySaturn; i++)
{
if (uiPosArraySaturn >2) driver->draw3DLine(v3dfSaturn[i-1],v3dfSaturn[i],SColor(125,125,255,125));
}
//Uranus
for(unsigned int i = 0; i <= uiPosArrayUranus; i++)
{
if (uiPosArrayUranus >2) driver->draw3DLine(v3dfUranus[i-1],v3dfUranus[i],SColor(175,0,100,70));
}
//Neptun
for(unsigned int i = 0; i <= uiPosArrayNeptun; i++)
{
if (uiPosArrayNeptun >2) driver->draw3DLine(v3dfNeptun[i-1],v3dfNeptun[i],SColor(125,125,255,125));
}
//Pluto
for(unsigned int i = 0; i <= uiPosArrayPluto; i++)
{
if (uiPosArrayPluto >2) driver->draw3DLine(v3dfPluto[i-1],v3dfPluto[i],SColor(255,255,255,255));
}
};
#endif
