Hi Leute!

Ich hab nochmal ne Frage. Wenn ich jetzt unser Sonnensystem in OpenGL darstellen will, dann werd ich die Planeten wohl am besten als gluSphere darstellen (ich weiss das Planeten nicht ganz kreisförmig sind, ist aber glaub ich vernachlässigbar).
1. Wie texturier ich die Dinger denn dann am besten? Gibt's schon vorgefertigte Texturen für die Plani, oder muss ich mir selber welche bauen? Problem seh ich darin das die Texturen ja verformt bzw. verzerrt sein müssen damit sie bei der "Tapezierung" der Sphere wieder korrekt aussehen (also entzerrt werden).
2. Fortgeschritten: Wie krieg ich das "Wabern" der Sonnenoberfläche hin (das man den Eindruck hat die Oberfläche wäre wirklich geschmolzen und heiss)? Mehrere Texturen oder so?

Also, Frage 1 ist mir eigentlich wichtiger. Frage 2 ist ja nur so'ne Art "Bonus" bei der Darstellung.

Danke schon mal für die Antworten, McFly

1)Es gibt schon vorgefertigte Texturen von Planeten, wo man die findet weiß ich nicht. googeln(bildsuche) hilft fast immer

2)Das Wabbern kann man mit Shadern verwirklichen (kompliziert und setzt sehr aktuelle HW voraus), oder mit Hilfe einer Detailtextur mit einem causting-effekt; das sind vorgerenderte Texturen[-folgen], die eine meistens Wasser-ähnlichen Effekt haben. Diese Detailtextur kann mit Hilfe von Multitexturing und blending sehr effektvoll mit einer Standard-Sonnentextur verbunden. Auch hier hilft die google-Bildsuche (wenn du nichts findest, kann ich dir meine als Attachement anhängen )

_________________
"Phantasie ist wichtiger als Wissen, denn Wissen ist begrenzt" Albert Einstein

Ich hab ein neues Problem bei der Sonne.
Die Sonne ist ja eine gluSphere; jetzt hab ich eben eine Lichquelle in die Szene gesetzt, genau dahin wo die Sonne ist. Aber natürlich "umschließt" die Sonne die Lichtquelle, so daß kein Licht zu sehen ist.
Kann ich der Sphere irgendwie sagen daß sie Lichtstrahlen von innen nach außen durchlassen soll? Am besten natürlich in Verbindung damit das sie "leuchtet".

mfG, McFly

Schalt am besten die Beleuchtung für die Sonne aus. Die Sonne wird ja auch nicht beleuchtet, sondern leuchtet selber. Die Helligkeit hängt daher nur von der Texture oder dem Shader auf der Sonne ab.

wie schalt ich denn lokal für ein Objekt die Beleuchtung ab In dem ich keine Normal definiere?
Das Licht hab ich bis jetzt immer nur mit glEnable, glDisable an- und ausgemacht.

@Beleuchtung :
Geht ganz einfach :


Das ist das schöne an ner Statemachine wies OpenGL eine ist.

@Planetentexturen :
Unter diesem Link solltest du fündig werden.

@Sonnenwabern :
Das lässt sich recht einfach über die Texturkoordinaten machen. Die kannste dann per Sinusfunktion manipulieren um nen Wabereffekt zu erhalten. Dazu musst du allerdings die Kugel selbst rendern und auch die Texturkoordinaten logischerweise selbst übergeben. Ist aber mit grundlegenden mathematischen Kenntnissen kein Problem.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

haste recht! Hät ich auch selber drauf kommen können.
Is halt nix wenn man alt wird

Danke

scheisse, ich muss nochmal fragen.
Ich kann mit glDisable und Enable die Beleuchtung zwar vorübergehend ausstellen, aber es dringt ja trotzdem kein Licht aus der Sonne heraus.
Hab einen Screenshot gemacht falls das hilft.

Ich danke für die Geduld und Hilfe.

mfG, McFly

Da machst du definitiv was anderes falsch. Da OpenGl kein Lichtmodell nutzt bei dem Strahlen von der Licht ausgehen nutzt, wird auch nicht geprüft ob das Licht von irgendeinem Objekt blockiert wird. Ob du die Kugel zeichnest oder nicht, spielt für die Lichtquelle keine Rolle. Also liegt dein Problem an einer anderen Stelle. Was für nen Lichtquellentyp nutzt du denn? Eine örtlich begrenzte (sowas wie Spotlight, Pointlight mit Attenuation) oder ne "unendliche" Lichtquelle wie z.B. unser Sonnenlicht?

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Ich nutze folgende Parameter (ich weiss noch nicht genau was für Licht die Sonne ausstrahlt, deshalb hab ich erstmal ambient, diffus und spekular voll eingesetzt):

GLfloat ambient[4] = {1,1,1,1};
GLfloat diffuse[4] = {1,1,1,1};
GLfloat specular[4] = {1,1,1,1};
GLfloat position[4] = {0,0,0,1};
GLfloat AttConst = 0;
GLfloat AttLin = 0;
GLfloat AttQuad = 0;

und initialisiere dann

glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, AttConst);
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, AttLin);
glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, AttQuad);
glEnable(GL_LIGHT0);

Ich hab's jetzt hinbekommen, daß der Rest der Szene beleuchtet wird (war wie du sagtest du Position des Lichter, hatte vorher {0,0,0,}).
Allerdings wird jetzt die gesamt Szene komplett ausgeleuchtet, die Planis haben keine "Schattenseite" mehr; Die Situation gleicht der ohne jede Beleuchtung die ich vorher hatte.

mfG, McFly

Zur beleuchtung hätte ich aber auch mal noch ne Frage...
Kennt jemand das Spiel Haegemonia?
Dort hat man einen absolut gut gemachten Übergang zwischen Tag und Nacht Seite eines Planeten. Also der nicht beleuchtette Teil wird durch ne andere Textur dunkel gemacht. Das ganze hat dort nen flüssigen Übergang wodurch es einfach nur genial aussieht. Sollte man die komplette beleuchtung nicht lieber über so einen weg lösen?! Im Weltraum sieht man nur das Licht was auf irgendwelchen Objekten reflektiert wird...
Aber, wie mache ich so einen flüssigen Übergang zwischen einer Tag und einer Nacht Textur?!

Man kann auch mit wenig Polygonen einen flüssigen Übergang erzeugen, wenn man die Beleuchtung in einer Cubemap speichert. Dann kann man die Normale benutzen um aus der Cubemap zu lesen. Die Normale wird zwar bei der Interpolation über die Oberfläche denormalisiert, aber für die Cubemap spielt das keine Rolle und man sieht im Gegensatz zu dem Vertex Licht keine Kanten zwischen den Dreiecken.
Entweder man gibt statt der Normale die Texturekoordinaten, oder man benutzt eine Extension die das automatisch macht oder noch einfacher geht es über ein Vertex Program.