Ich hab da mal ne Frage, weil ich derzeit echt an einem Punkt am verzweifeln bin.
Ich soll eine Sonnensystem erstellen inklusive Rotationen etc.

Ich bin soweit gekommen das siche alle Planeten um die Sonne drehen so wie sie sollen, nur wollen meine Monde nicht so wie sie sollen. Kann mir vielleicht jemand dabei helfen wie der richtige Code für die Monde lauten würde?
Zur Zeit dreht sich der Mond einfach nur um den Startpunkt der Erde und weiter nicht. Ich weiß nicht wie ich den noch mit der Erde zusammen um die Sonne kreisen lassen soll

Danke schon mal für die Hilfe.

Bisher habe ich das:

#include <iostream>

#include <simpleGP/color.h>
#include <simpleGP/rasterization.h>
#include <simpleGP/vec2i.h>
#include <simpleGP/window.h>
#include <simpleGP/mesh.h>
#include <simpleGP/triangle.h>	
#include <simpleGP/mat4f.h>
#define _USE_MATH_DEFINES
#include <math.h>

// Methoden
Mesh transformPoints(Mesh m, Mat4f world)
{ 
	for(unsigned int i = 0; i < m.GetNumOfTriangles(); i++)
	{
		Triangle* pTriangle = m.GetTrianglePointer(i);
		pTriangle->P0 = world * pTriangle->P0;
		pTriangle->P1 = world * pTriangle->P1;
		pTriangle->P2 = world * pTriangle->P2;
	}
	return m;
}

Mesh transformNormals(Mesh m, Mat4f world)
{
	for(unsigned int j = 0; j < m.GetNumOfTriangles(); j++)
	{
		Triangle* pTriangle = m.GetTrianglePointer(j);
		pTriangle->N0 = world * pTriangle->N0;
		pTriangle->N1 = world * pTriangle->N1;
		pTriangle->N2 = world * pTriangle->N2;
	}
	return m;
}

Mat4f translate(float x, float y, float z)
{
	return Mat4f(1, 0, 0, x,
				 0, 1, 0, y,
				 0, 0, 1, z,
				 0, 0, 0, 1);
}

Mat4f rotate(float winkel)
{
	return Mat4f(cos(winkel / 180 * M_PI), -sin(winkel / 180 * M_PI),0, 0,
				 sin(winkel / 180 * M_PI), cos(winkel / 180 * M_PI), 0, 0, 
				 0, 0, 1, 0,
				 0, 0, 0, 1);
}

Mat4f scale(float faktor)
{ 
	return Mat4f(faktor, 0, 0, 0,
				 0, faktor, 0, 0,
				 0, 0, faktor, 0,
				 0, 0, 0, 1);
}

////////////////////////////////////////////////////////////////////////////////
// main function
////////////////////////////////////////////////////////////////////////////////
void main ()
{
  Window myWindow(640, 480, "Ich bin das Sonnensystem! :-)");

  // Positionierung
  Mesh sonne("../meshes/D/yellow.obj");
  Mat4f position_sonne = translate(320, 240, 0) * scale(6);
  sonne = transformPoints(sonne, position_sonne);

  Mesh merkur("../meshes/D/gray.obj");
  Mat4f position_merkur = translate(320, 298, 0) * scale(1.2);
  merkur = transformPoints(merkur, position_merkur);

  Mesh venus("../meshes/D/gray.obj");
  Mat4f position_venus = translate(320, 340, 0) * scale(3);
  venus = transformPoints(venus, position_venus);

  Mesh erde("../meshes/D/blue.obj");
  Mat4f position_erde = translate(320, 390, 0) * scale(3.2);
  erde = transformPoints(erde, position_erde);

  Mesh mond("../meshes/D/gray.obj");
  Mat4f position_mond = translate(345, 390, 0) * scale(0.8);
  mond = transformPoints(mond, position_mond);

  Mesh mars("../meshes/D/orange.obj");
  Mat4f position_mars = translate(320, 468, 0) * scale(1.6);
  mars = transformPoints(mars, position_mars);

  Mesh phobos("../meshes/D/gray.obj");
  Mat4f position_phobos = translate(338, 468, 0) * scale(0.75);
  phobos = transformPoints(phobos, position_phobos);

  Mesh deimos("../meshes/D/gray.obj");
  Mat4f position_deimos = translate(290, 468, 0) * scale(0.5);
  deimos = transformPoints(deimos, position_deimos);

  positionLight(Vec4f(320,240,0,1));

  while (myWindow.IsOpen())
  {

    myWindow.HandleEvents();

    myWindow.Clear();

    // Code
	rasterizeMesh(sonne);

	Mat4f move_merkur = translate(320, 240, 0) * rotate(360 / 87.969) * translate(-320, -240, 0);
	merkur = transformNormals(merkur, move_merkur);
	merkur = transformPoints(merkur, move_merkur);
	rasterizeMesh(merkur);

	Mat4f move_venus = translate(320, 240, 0) * rotate(360 / 224.701) * translate(-320, -240, 0);
	venus = transformNormals(venus, move_venus);
	venus = transformPoints(venus, move_venus);
	rasterizeMesh(venus);

	Mat4f move_erde = translate(320, 240, 0) * rotate(360 / 365.256) * translate(-320, -240, 0);
	erde = transformNormals(erde, move_erde);
	erde = transformPoints(erde, move_erde);
	rasterizeMesh(erde);

	Mat4f move_mond = translate(320, 390, 0) * rotate(360 / 27.3217) * translate(-320, -390, 0);
	mond = transformNormals(mond, move_mond);
	mond = transformPoints(mond, move_mond);
	rasterizeMesh(mond);

	Mat4f move_mars = translate(320, 240, 0) * rotate(360 / 686.98) * translate(-320, -240, 0);
	mars = transformNormals(mars, move_mars);
	mars = transformPoints(mars, move_mars);
	rasterizeMesh(mars);

/*	Mat4f move_phobos = translate(320, 240, 0) * rotate(360 / 224.701) * translate(-320, -240, 0);
	phobos = transformNormals(phobos, move_phobos);
	phobos = transformPoints(phobos, move_phobos);
	rasterizeMesh(phobos);

	Mat4f move_deimos = translate(320, 240, 0) * rotate(360 / 224.701) * translate(-320, -240, 0);
	deimos = transformNormals(deimos, move_deimos);
	deimos = transformPoints(deimos, move_deimos);
	rasterizeMesh(deimos);
*/
    myWindow.Display();
  }  
}

Ich weiß nicht wie ich den noch mit der Erde zusammen um die Sonne kreisen lassen soll

Und hier wären Klassen mal soo sinnvoll gewesen. -.-
Wie auch immer, du musst beim Kreisen der Monde ja die Position der Planeten mitberücksichtigen. Also einfach zu deren Position schieben und dann rotieren.

PS: Ich hoffe das soll nichts in Originalgröße werden? Dann siehste nämlich nichts mehr sobald die Sonne am Start ist.

hab ma nen screen gemacht, damit ihr hoffentlich versteht was ich meine, weil ich das nicht erklären kann.

http://s1.directupload.net/images/120109/rgquqiw8.jpg

und nein wird nich maßstabs getreu

das mach ich mit 2 matrizen

Mat4f translate(float x, float y, float z)
{
    return Mat4f(1, 0, 0, x,
                 0, 1, 0, y,
                 0, 0, 1, z,
                 0, 0, 0, 1);
}

Mat4f rotate(float winkel)
{
    return Mat4f(cos(winkel / 180 * M_PI), -sin(winkel / 180 * M_PI),0, 0,
                 sin(winkel / 180 * M_PI), cos(winkel / 180 * M_PI), 0, 0,
                 0, 0, 1, 0,
                 0, 0, 0, 1);
}

und das sieht dann so aus wenn ich das mache:

Mat4f move_erde = translate(320, 240, 0) * rotate(360 / 365.256) * translate(-320, -240, 0);

Und warum nimmst du 365.256, wenn es doch eigentlich 365.2425 Tage sind?

Es geht um das siderische Jahr, also um eine vollständige Umrundung von außen betrachtet.

~Edit: Pedanterie~

also, falls ich das jez richtig verstanden habe. ich verschiebe die planten in den ursprung lasse sie rotieren und verschieb die wieder zurück.

Dann verschieb den Mond zur Position des Planeten, dann in den ursprung, lass ihn wie den Planeten rotieren, schiebe ihn an die position des planeten, rotiere ihn mit der Mondrotation und schieb den Mond wieder weg. Sollte dann doch passen, oder?

da wo die translates usw untereinander stehn, is das was ich meine verstanden zu haben was kleiner troll meint. nur funzt das nich, aba ich geh ma davon aus das es an mir liegt weil ich grad echt überfordert bin.. kann mir denn keiner sagen wie ich das richtig schreibn damit ichs für die zukunft weiß, und nich weitere stunden wut, wegn meines eigenen nichtkönnens aufkommt xD

da wo die translates usw untereinander stehn, is das was ich meine verstanden zu haben was kleiner troll meint. nur funzt das nich, aba ich geh ma davon aus das es an mir liegt weil ich grad echt überfordert bin.. kann mir denn keiner sagen wie ich das richtig schreibn damit ichs für die zukunft weiß, und nich weitere stunden wut, wegn meines eigenen nichtkönnens aufkommt xD

Zu unlesbar wegen zuvieler magischer Werte. Außerdem kann das keiner zuhause ausprobieren, weil uns deine Bibliotheken fehlen. Man kann es daher nur mit Worten erklären:

Wenn du die Erde dreht:
0. Den Mond die gleiche Drehung machen lassen.
Dann, wenn der Mond drankommt:
1. Position der Erde von der Position des Mondes abziehen
2. Monddrehung anwenden
3. Position der Erde hinzu addieren