So, in diesem Tutorial will ich (möglichst für Linux-Anfänger) erklären, wie man Linux ohne eine IDE wie KDevelop/Code::Blocks benutzt. Dies hat den Vorteil, dass es überall funktioniert und man ohne zusätzliche Programme auskommt, Nachteile sehe ich aufgrund der mächtigen Editoren, die immer dabei sind (gedit, kate, wenns sein muss halt vim) nicht.
Als erstes compilieren wir Irrlicht. Dazu extrahieren wie die Irrlicht-Sources, sagen wir mal, in den Ordner irrlicht-1.3.1/sources/Irrlicht. In diesen Ordner wechseln wir nun in einem Terminal mit "cd <Pfad zum Irrlicht-Verzeichnis>/irrlicht-1.3.1/sources/Irrlicht".
Die eigentliche Compilierung ist sehr einfach, einfach "make sharedlib" tippen und sich zurücklehnen. Es kann sein, das Fehler auftreten, weil bestimmte Pakete betreffend OpenGL nicht installiert sind, in diesem Fall diese Pakete installieren (kA, wie die für die jeweiligen Distributionen heißen, im Zweifelsfall im Forum nachfragen
), und das "make sharedlib" wiederholen.
Nun sollte eine Datei "libIrrlicht.so.1.3.1" im Verzeichnis irrlicht-1.3.1/lib/Linux entstanden sein, diese entspricht einer DLL unter Windows und hat im Gegensatz zu der libIrrlicht.a den Vorteil, dass später nur noch diese .so-Datei verlinkt werden muss.
Der Einfachheit halber installieren wir sie nun per "su -c "make install""(inklusive innere Anführungszeichen).
Für die bequeme Compilierung des Projekts selbst erstellen wir nun eine Makefile, die sich dann später ganz bequem per "make" aufrufen lässt und das Projekt automatisch compiliert.
Eine Makefile besteht aus Targets (Zielen), die jeweils eine bestimmte Aufgabe haben, diese Targets haben nun bestimmte Abhängigkeiten (entweder Sourcecodes oder andere Targets), sie werden nun beim Aufruf von make nur compiliert, wenn die Abhängigkeiten seit dem letzten Compilieren verändert wurden, dies spart bei großen Projekten deutlich Zeit, wie man es auch von den meisten IDEs kennt (tatsächlich benutzen viele IDEs sogar make mit automatisch generierten Makefiles, zB Code::Blocks).
Eine Makefile sieht nun so aus:
Code:
program: abh1 abh2
abh1: src1
<TAB>Befehl1
<TAB>Befehl2
abh2: src2
<TAB>Befehl1
<TAB>Befehl2
Wenn man nun "make" aufruft, wird das erste Target in der Datei ausgeführt. In diesem Fall basiert es auf den Abhängigkeiten abh1 und abh2. Nun werden diese beiden Targets weiter verfolgt. Make sieht nun, dass abh2 auf dem Target src1 basiert, es schaut nun, ob sich src1 (Wir nehmen an, es handelt sich dabei um eine Datei) seit dem letzten Compilieren verändert hat (wichtig ist dabei, dass abh1 auch eine Datei diesen Namens erzeugt, um den Timestamp der Datei vergleichen zu können, wenn nicht, wird src1 IMMER compiliert). Wenn src1 neuer ist als abh1, werden nun die Befehle für abh1 ausgeführt, diese werden mit einem Tab (wichtig, sonst kann make die Makefile nicht korrekt auswerten!) eingerückt. Das selbe passiert auch mit abh2. Wurde jetzt entweder abh1 oder abh2 neu erstellt, dann wird auch program neu erstellt, denn die Abhängigkeiten haben sich verändert. In diesem Fall beinhaltet program jedoch keine Befehle und hat so keine Wirkung.
Das selbe noch mal etwas konkreter, das folgende Makefile kann benutzt werden, um ein einfaches HelloWorld-Programm oder ähnliches zu kompilieren:
Code:
all: helloworld
clean:
<TAB>-rm main.o helloworld
rebuild: clean helloworld
helloworld: main.o
<TAB>$(CXX) main.o -o helloworld
main.o: main.cpp
<TAB>$(CXX) -c main.cpp -o main.o
Das ganze sollte zum größten Teil nun verständlich sein, dazu gekommen sind:
- Bestimmte Aufgaben, die in den meisten Makefiles vorhanden sind, wurden als Targets definiert, und zwar:
all - Erstellt einfach das Programm (helloworld) und wird als das erste Target standardmäßig ausgeführt.
clean - Löscht alle Ausgabedateien (main.o, helloworld), das "-" vor dem Befehl macht, dass make nicht abbricht, wenn main.o oder helloworld nicht vorhanden sind, dies ist wichtig, damit "rebuild" funktioniert.
rebuild - Nicht so oft zu sehen, aber ich finde es praktisch, es löscht erst alle Ausgabedateien (clean) und erstellt dann wieder das Programm.
Diese Targets können per "make clean" oder "make rebuild" aufgerufen werden, für all reicht "make".
- Zum Linken des komplette Programmes wird der folgende Befehl benutzt:
Code:
$(CXX) main.o -o helloworld
$(CXX) ist eine Variable, die unter Linux auf den G++-Compiler verweist, sie kann dürch "g++" ersetzt werden, so ist es aber einfacher, wenn zB zum Crosscompilieren ein anderer Compiler verwendet werden soll.
main.o ist eine Eingabedatei, sie ist die Objektdatei, die beim Compilieren von main.c entsteht, dieser Befehl compiliert also nichts selber, sondern linkt nur die ganzen Objektdateien zusammen.
"-o helloworld" bestimmt den Ausgabedateinamen, wird diese Option weggelassen, heißt die entstehende Datei "a.out". Wir hatten gesagt, die Ausgabedatei soll wie das Target heißen - Stimmt.
- Zum Compilieren von main.c wird folgender Befehl benutzt:
Code:
$(CXX) -c main.cpp -o main.o
Hier ist $(CXX) wieder der Compiler G++.
Mit "-c" erreichen wir, das kein fertiges Programm erstellt wird, sondern eine Objektdatei, da nur compiliert und nicht gelinkt wird.
main.c ist wieder die Eingabedatei und "-o main.o" die Ausgabedatei.
Diese Makefile lässt sich jetzt sehr bequem per "make" ausführen (Man sollte allerdings die gesamte Zeit eine Konsole in dem Projektordner geöffnet haben).
Nun ist das schon für kleine Projekte ganz nett, aber sobald man sehr viele Dateien hat, wird die Makefile sehr lang. Für große Projekte deutlich vereinfachen kann man alles, indem man Variablen für sowohl Dateinamen als auch Compileroptionen einsetzt:
Code:
SRC = main.cpp datei1.cpp datei2.cpp datei3.cpp
OBJ = $(SRC:%cpp=%o)
CFLAGS = -O2
CXXFLAGS = $(CFLAGS)
LDFLAGS =
all: program
clean:
<TAB>-rm $(OBJ) program
rebuild: clean program
program: $(OBJ)
<TAB>$(CXX) $^ -o $@ $(LDFLAGS)
%o: %cpp
<TAB>$(CXX) -c -o $@ $< $(CXXFLAGS)
Heh... das ist wirklich halb so schlimm, wie es aussieht
Nun, am Anfang definieren wie erst mal die Variable "SRC", sie wird selbst nicht direkt benutzt und enthält sämtliche Quellcodes, durch Leerzeichen getrennt.
Die nächste Zeile ("OBJ = $(SRC:%.cpp=%.o)") erstellt nun aus SRC eine neue Variable, OBJ, diese enthält alle Objektdateien, indem alle Vorkommen von ".cpp" durch ".o" ersetzt werden.
CFLAGS enthält die Optionen, die zum Compilieren von C-Dateien benutzt werden, hier wird es nicht benötigt, da wir von einem reinen C++-Projekt ausgehen. CXXFLAGS enthält die Optionen für C++-Dateien, meistens sind es die selben Optionen wie für C-Dateien, die Variable wird nun einfach kopiert. In diesem Beispielprogramm hat nun CXXFLAGS den Wert "-O2", dadurch wird der g++ dazu gebracht, das Programm zu optimieren.
LDFLAGS enthält nun die Optionen für den Linker, hier kommen die benötigten Libraries und ähnliches hin.
Nun kommen die Befehle, in die die Variablen eingefügt werden:
"-rm $(OBJ) program" - hier werden nun alle Objektdateien gelöscht, dazu kommt noch die Datei program.
"program: $(OBJ)" - Hier werden dem Target program alle Objektdateien als Abhängigkeiten angefügt.
"$(CXX) $^ -o $@ $(LDFLAGS)" - hier werden nun alle Objektdateien gelinkt. Einfach zu verstehen ist das "LDFLAGS", hier werden einfach die Linker-Optionen angehängt. $@ und $^ sind zwei spezielle Variablen: $@ steht immer für den Namen des Targets, in diesem Fall "program". Dadurch wird "-o $@ ersetzt durch "-o program". $^ steht für ALLE Abhängigkeiten. Dadurch wird $^ ersetzt durch "$(OBJ)", sodass alle Objektdateien als Eingabedateien benutzt werden.
"%o: %cpp" - dies ist ein automatisches Target: Es gilt für alle .o-Dateien und setzt als abhängigkeit automatisch den selben Dateinamen, allerdings mit .cpp ein - genau das, was wir brauchen
"$(CXX) -c -o $@ $< $(CXXFLAGS)" - Dies entspricht dem Linkerbefehl, $@ zeigt dieses Mal auf eine .o-Datei, und $< auf die ERSTE Abhängigkeit, also die C++-Datei. An dieser Stelle wird auch klar, wozu diese Variablen gut sind - da wir nicht wissen, was jeweils als Target/Abhängigkeit eingesetzt wird, können wir diese Daten nicht fest in den Befehl schreiben. -c macht wieder, das nicht gelinkt wird, und $(CXXFLAGS) bindet die Optionen für den Compiler ein.
Nun, daraus lässt sich doch schon eindeutig mehr machen, oder?
Eine Beispielmakefile für die Irrlichtengine sähe so aus:
Code:
SRC = main.cpp player.cpp world.cpp menu.cpp network.cpp
OBJ = $(SRC:%cpp=%o)
PATH_TO_IRRLICHT = /home/phoenix/irrlicht-1.3.1
CFLAGS = -I $(PATH_TO_IRRLICHT)/include
CXXFLAGS = $(CFLAGS)
LDFLAGS = -lIrrlicht
all: mygame
clean:
<TAB>-rm $(OBJ) mygame
rebuild: clean mygame
mygame: $(OBJ)
<TAB>$(CXX) $^ -o $@ $(LDFLAGS)
%o: %cpp
<TAB>$(CXX) -c -o $@ $< $(CXXFLAGS)
Hier muss nur noch CFLAGS angepasst werden:
Per -I $(PATH_TO_IRRLICHT)/include wird dem Compiler gesagt, dass er in diesem Ordner nach den Irrlicht-Headern suchen soll. PATH_TO_IRRLICHT muss dabei selbst angepasst werden.
Dazu kommt noch, dass den LDFLAGS "-lIrrlicht" angehängt wird, um Irrlicht zu verlinken (Ich nehme hierbei an, dass ihr am Anfang Irrlicht per "su -c "make install"" in einen von g++ automatisch durchsuchten Pfad kopiert habt).
Nun, das wars eigentlich schon - mit solch einer Makefile könnt ihr eure Irrlicht-Projekte schön bequem kompilieren.
EDIT:
Was diese Makefile natürlich noch nicht kann, ist, wenn man eine Headerdatei ändert, alle darauf basierenden Sourcedateien zu ändern.
Die Irrlicht-Engine macht dies durch:
Code:
%.d:%.cpp
$(CXX) $(CXXFLAGS) -MM -MF $@ $<
-include $(OBJ:.o=.d)
Hier werden durch "$(CXX) -MM -MF" alle Headerdateien aufgelistet und als Target/Abhängigkeit-Information in einer .d-Datei gespeichert, da diese Datei nun das selbe Format wie eine Makefile hat, können alle .d-Dateien per include eingebunden werden (das "-" erreicht wiederum, dass make nicht fehlschlägt, wenn .d-Dateien fehlen, weil sie noch nicht erstellt wurden.
Dementsprechend muss dann halt "mygame: $(OBJ)" in "mygame: $(OBJ:.o=.d) $(OBJ)" umgewandelt werden, damit die Dateien erstellt werden (Denke ich mal, nicht ausprobiert). Dies kann halt die Compilierzeit vergrößern, wenn das Projekt nur ein Mal erstellt werden soll, später hilft es dann aber, Fehler zu vermeiden.
EDIT: $< teilweise durch $^ ersetzt.
Anmelden
Registrieren
FAQ
Suche
ich dachte das das der übersicht gut tut^^