Irrlicht - from Noob to Pro: Funktionen.hpp

Aus Wikibooks
Zur Navigation springen Zur Suche springen
#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