4. Anfänger hat Fragen zu Terrainengines

Anfänger hat Fragen zu Terrainengines

  • S

    Hallo, ich bin glaub ich neu hier und will daher erst einmal etwas über mich sagen, damit eventuelle Antworten nicht auf einem zu hohen Niveau kommen. 😉
    Nachdem ich nun einige C++-Bücher gelesen habe, und OOP halbwegs verstanden habe, wollte ich mich nun endlich an eine eigene Engine machen.
    Zumindest an eine kleine, um das Gelernte anzuwenden und vorallem neues zu lernen.
    Mir ist klar, dass das nicht alles so einfach geht, grade weil ich von OpenGL (was ich ausgewählt habe) noch keine Ahnung habe und von Mathe nicht viel (halt nichts von Vektoren und Matrizen, bin in der 9. Klasse...).
    Nunja, ich habe also die Vorstellung, vor dem ganzen anderen Kram eine Terrainengine zu implementieren, und mitlerweile hab ich (unter enormer Zuhilfenahme von Beispielcode aus Tutorials 🙄 :D) immerhin erstmal ein Fenster mit variabler Auflösung erstellt, Kameracode eingebastelt, so dass ich durch leeren Raum laufen kann, und 2dFont-Code von Gametutorials.com in eine Klasse gewrappt.
    Meine erste Frage ist nun allgemeinerer Natur:
    Schon etwas enttäuscht stelle ich überall in Tutorials und Quelltexten fest (außer in fertigen Engines), dass intensiv von C Gebrauch gemacht wird, aber so gut wie keiner von C++. Ich hab mir erst gedacht, dass ich das dann halt alles selbst umschreibe, aber dabei fällt mir immer mehr auf, dass es dabei nur umständlicher wird, oder sogar unlösbare Probleme auftreten! (zumindest für mich) Ich scheine, was OOP betrifft, noch nicht sicher genug zu sein, aber ich weiß wirklich nicht, wie man die gefürchteten globalen Variablen, von denen sich bei mir immer mehr anhäufen, ersetzen sollte, ohne gleichzeitig den 100fachen Speicherplatz zu benötigen!
    Also endlich zur Frage: Ist es üblich Spiele größtenteils in C zu schreiben, globale Variablen zu verwenden und so weiter, um sich den Code zu vereinfachen und die Performance zu erhöhen, und ist dies nicht verurteilenswert?
    Und nun Fragen zur Threadüberschrift:
    Meine Todoliste sieht so aus:
    -einfache LOD-Algorithmen einbauen
    -Beleuchtung oder sowas
    -Heightmaps laden können (werden im Moment noch mit sin und cos generiert)
    -Camera mit Kollisionsabfrage ausrüsten um auf Landschaft laufen zu können
    -einfache Texturierung
    -Schatten
    -verbesserter LOD-Algorithmus mit Geomorphing
    -Multitexturing oder sowas (hab auch was von Splatting gehört)

    Im Moment befinde ich mich beim ersten Punkt, und ich hoffe dass ich das mit Tutorials selbst bewerkstelligen kann. Aber: Der nächste bereitet mir Kopfzerbrechen! Ich will selbstverständlich endlich mehr sehen als nur ein einfarbiges Gebilde, das nur bei Bewegung an der Kontur als Hügel zu identifizieren ist.
    Nur, wenn ich das richtig verstanden habe, gibt man bei OpenGL jedem Vertex eine Richtung (Normalvektor oder so?) und dann kann man Licht einschalten, Lichtquellen setzen und Materialeigenschaften und so, und dann wird ein Objekt schön beleuchtet. Aber ist denn das nicht viel zu viel Aufwand für eine Landschaft, die sich ja garnicht bewegt? (Genausowenig wie eine Sonne als Lichtquelle) Würde denn nicht die Landschaft immer gleich beleuchtet sein, so dass man das irgendwie vorberechnen könnte? Und nennt man sowas dann etwa Lightmap? Oder ist die Kameraposition doch wichtig, wegen Einfallswinkel=Ausfallswinkel und hellen Stellen und so? Oder ist das sowieso Quatsch, und man muss nur eine Textur mit einer SHADOWmap drauflegen, wie auch immer das geht, und dann reicht das? Wodurch entsteht denn eigentlich der realistische Eindruck des Terrains wie es von Terragen oder so einem Prog gerendert wurde? Doch durch den Schatten (+Bumpmapping), und nicht durch das Licht, oder?
    Habt ihr allgemeine Tipps für mich, Codeschnipsel, Ideen, und würdet ihr die To-do-liste vielleicht ganz anders aufbauen?

    Vielen Dank für die Mühe den langen Text zu lesen, und im Voraus für Antworten abgesehen von "Fang mit was leichterem an..." und so :p

    0
  • O

    die sache mit den normal vektoren ist eigentlich schnell erklärt:
    diese normalvektoren dienen zur LIchtberechnung auf Vertexbasis, und mithilfe der normal vectoren wird wie du richtig vermutet hast berechnet,in welche richtung das licht reflektiert wird,und im endeffekt, was du sehen kannst.
    Direkt vorberechnen kannst du dabei nichts, die berechnungen gehen heutzutage aber schon sehr flott von der Hand,sodass man sich erst ab mehr als 3 lichtern gleichzeitig sorgen machen sollte 😉
    diese normalvector berechnung hat im unterschied zu den light maps den vorteil, dass du einen variablen sonnengan berechnen kannst, und sowas lohnt sich meiner Meinung schon.
    Lightmaps sind "nur" texturen,die von einem Programm vorher berechnet werden, und sind halt statisch.
    gut,wenn du keine variablen lichteffekte haben willst.

    Wie terragen die goilen landschaften hinkriegt?
    ein Wort: Raytracing.
    das ist lichtberechnung auf Pixelbasis,absolut unschlagbar, und absolut langsam, der schatten etsteht automatisch, wenn kein Licht auf den Pixel fällt.

    0
  • A

    Auf der NEHE Website findest du gute VC++ Tutorials für OpenGL.

    Hier der Link.

    http://nehe.gamedev.net/

    Ich denke mal das wird dich einen Schritt weiterbringen 🙂

    0
  • S

    Thx für die Infos.
    Hm, ich habe eigentlich keine variablen Lichteffekte vorgesehen, aber wenn das schnell gehen sollte...mach ichs halt so! Aber umso mehr Polygone -> umso mehr Zeit? Oder spielt nur die Anzahl der Lichtquellen ne Rolle?
    Und wie genau macht man das nun? Ich hab erstmal diesen Code in meiner Init-Funktion:

    GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f}; 
	GLfloat ambientLight[] = { 1.0, 1.0, 1.0, 1.0 };
	GLfloat diffuseLight[] = { 1.0,1.0,1.0,1.0};
	GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; 
	glLightfv(GL_LIGHT0, GL_AMBIENT,ambientLight);
	glLightfv(GL_LIGHT0, GL_DIFFUSE,diffuseLight); 
	glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
	glLightfv(GL_LIGHT0, GL_POSITION, light_position); 
	glEnable(GL_LIGHTING); 
	glEnable(GL_LIGHT0);

    Jetzt muss ich doch nurnoch die Normalen angeben! Lassen die sich einfach berechnen, wenn ich die Koordinaten 3er Verticies kenne, oder muss ich noch mehr dafür wissen?
    Aber dummerweise könnte es trotzdem schwierig werden: Benutze nämlich diesen Code zum rendern, (den ich nur teilweise verstehe), um später besser einen LOD-Algorithmus einbauen zu können.
    Und selbstverständlich interessieren mich meine anderen Fragen auch weitehin :p

    EDIT: @Ag3Nt: Danke, aber den Link kenn ich schon 🙂 Ist auch wieder eine von den Seiten, wo alles in C geschrieben ist! Oder zumindest vieles!
    Naja, zu den Normalen würde ich da sicher auch einiges erfahren, aber ich dachte halt, dass es vielleicht angenehmer (für mich) ist, wenn ich euch das auch gleich noch frage, wo ich doch sowieso schon Fragen stelle 🤡
    Nochmal EDIT: Ups, hab ja "diesen Code" vergessen, da isser:

    void spew_fans() 
{ 
        int i; 
        NV *pv;
        pv = nvertices; 
        glBegin(GL_TRIANGLE_FAN);

        for(i =  0;  i <  nverts; i++)
		{
            if(pv->vertex._x <= -9990) {                        
                glEnd();                        
                glBegin(GL_TRIANGLE_FAN);                
            }
            else
            {
                glVertex3f(pv->vertex._x,pv->vertex._y,pv->vertex._z);
            }
            pv++;
        }
        glEnd();
}
    0

  • Eine große Sammlung an Informationen zu diesem Thema: www.vterrain.org

    Bye, TGGC \-/

    0
  • D

    Hi,

    ich kann Ag3nt nur zustimmen. In den NeHe-Tutorials müsstest du eigentlich die passenden Tuts finden. Und die sind wirklich SEHR GUT.
    Das Englisch ist zwar leicht verständlich(auch für dich in der 9.Klasse) aber hier findest du auch einige der NeHe's auf deutsch(Terrain aus Heightmaps zu erstellen ist dort vorhanden). www.codeworx.org.

    Gruß ######

    0
Anmelden zum Antworten