JPCT 3d-Spiele Programmierung Tutorial

[Xams]

Wie in einem vorherigen Thread angekündigt, schreibe ich nun ein Tutorial zu 3d-Spiele Programmierung mit JPCT.
Was wird benötigt:

-JAVA 1.5 JDK (oder höher)
-Blender (www.blender.org)
-3dGamestudio(kostenlose Testversion für 30 Tage auf www.3dgamestudio.de, diese sollte ausreichen.)
-JPCT (www.jpct.net)
-dazu kommen noch einige 3D-Modelle, auf die werde ich aber an gegebener Stelle hinweisen.

Voraussetztungen sind:
-JAVA GRUNDKENTNISE
WER MIT IF ABFRAGEN ODER FOR SCHLEIFEN NICHTS ANFANGEN KANN IST HIER FALSCH :wink:
-Geduld, Geduld und nochmals Geduld (grade im Umgang mit Blender- hier gilt wirklich Übung macht den Meister)


Etwas über dieses Tutorial:
Dieses Tutorial weicht von normalen Formen ab. Ein 3D-Spiel erstellt man nicht alleine, deswegen wird jeder hier seine Lösung von bestimmten Problemen zeigen und dann wird von allen entschieden, welche am praxistauglichsten ist- Das muss nicht meine sein. Ich zeige nur eine Möglichkeit von vielen. Am Ende steht dann da ein Programm, das von vielen mit entwickelt wurde.
Ich werde versuchen jede Woche das Tutorial weiter zu schreiben.
Behandelt wird im ersten Tutorial(diesem hier) die Programmierung eines Autorennspiels, evtl. in einem zweiten die Programmierung eines Shooters.

Wer würde denn trotz der etwas ungewöhnlichen Form(normalerweise wird der Leser ja nicht in ein Tutorial mit einbezogen) daran teilnehmen?

MFG
[EDIT1]Adresse von Jpct und Java-Version geändert.

 

[EgonOlsen]

-JPCT (www.jpct.org)

www.jpct.net...nicht .org!

 

[WieselAc]

ich bin dabei!!

hab aber eine Frage, wenn das wochenweise weiter gehen soll (was ich begrüße, da man so neben der Arbeit am WE die "Wochenaufgabe" abarbeiten kann) reicht dann die 30 Tage Testversion, sprich ist das in 4 Abschnitten zu schaffen?

 

[Evil-Devil]

Warum Java 6? Ich hab zwar nichts gegen den neuen Release, er läuft schön schnell, aber solange man keine Annotation, Enums oder Generics nutzt kann man für das Tutorial damit es eine breitere Benutzerschaft erreicht auf Java 1.4.2 oder falls Enums und Generics genutzt werden halt Java 5.

@Gemeinsam: Find ich gut die Idee, dass man mehrere Ansätze diskutieren kann Hoffe das Tutorial wird viele Anhänger finden. Dann hau mal in die Tasten.

 

[zd]

Seh ich das richtig, dass es dieses 3Dgamestudio nur für Windows gibt?
Läuft denn wenigstens der Rest (also auch das fertige Spiel) dann auch unter Linux?

Falls nein, fände ichs schade, hätte sonst gerne mitgemacht.

 

[Xams]

hab aber eine Frage, wenn das wochenweise weiter gehen soll (was ich begrüße, da man so neben der Arbeit am WE die "Wochenaufgabe" abarbeiten kann) reicht dann die 30 Tage Testversion, sprich ist das in 4 Abschnitten zu schaffen?

Nein in 4 Abschnitten ist das natürlich nicht zu schaffen, aber werden wir am Anfang die 3d-Modelle erstellen und danach das Programm nicht mehr benötigen... Eine Alternative ist Blender, wie oben genannt, das gibt es komplett umsonst, ist aber ein Profiprogramm und für Anfänger schwer zu bedienen. Für Blender brauch man auch noch einen Konverter in ein von JPCT unterstütztes Format.

läuft denn das fertige Programm auf Linux?

Ja, das fertige Programm läuft auf allen Java-Plattformen mit Jre 5. Blender ist ebenfalls für Linux und Mac geeignet (siehe oben)
ich hoffe, dass das dich dazu bewegt doch mit zu machen^^
MFG

 

[zd]

Ja, das fertige Programm läuft auf allen Java-Plattformen mit Jre 5. Blender ist ebenfalls für Linux und Mac geeignet (siehe oben)
ich hoffe, dass das dich dazu bewegt doch mit zu machen^^
MFG

D.h. abgesehen vom Erstellen der Models am Anfang kann ich überall mitmachen?
Dann bin ich dabei

 

[Wildcard]

D.h. abgesehen vom Erstellen der Models am Anfang kann ich überall mitmachen?
Dann bin ich dabei

Was spricht dagegen dich in der Zeit in Blender einzuarbeiten? Ist frei und eins der besten Programme auf dem Markt.
Zu wissen wie man es benutzt ist sicherlich kein Nachteil.

 

[Java-Freak.]

Also, du kannst auch die Models erstellen, wie gesagt Blender läuft auch auf Linux. Aber ich kann dir natürlich auch meine zu verfügung stellen.

 

[Java-Freak.]

@Wildcard Würdest du mitmachen?

 

[Wildcard]

Nein, da fehlt mir leider die Zeit, aber die Idee und Vorgehensweise finde ich gut :toll:

 

[zd]

Hm, ich werd mir Blender mal anschaun, schaut aufn ersten Blick ja sehr gut aus.
Aber allzuviel Ergebnisse würde ich mir da nicht erhoffen, hab in der Richtung noch nie was gemacht, und auch nicht soo viel Zeit
Die Programmiertechnischen Sachen interessieren mich aber eh deutlich mehr.

 

[F4llen4ngel]

find das ganze auch sehr intressant und werd versuchen schritt zu halten ,)

 

[doctus]

klingt wirklich gut. habe mir schonmal blender runterzuladen, um schonmal ein bisschen "rumzuspielen"^^

lg doctus

 

[Xams]

Tutorial Teil 1 Vorbereitung
Mit diesem Teil werde ich das Tutorial beginnen
Hier werdet ihr lernen, wie man die Grundlagen von JPCT anwendet. Demonstriert wird das am Beispiel eines Autorennens.

AUFGABE: Ladet euch die oben genannten Programme herunter, sowie auf JPCT.net unter downloads das Demo Programm Car, hier findet eine 3ds Datei eines Autos.
Sucht wenn ihr Zeit habt nach einer 3DS Datei eines Autos (oder von mehreren) Postet hier dann bitte den Link, und versucht mit 3dgamestudio eine Strecke zu erstellen. Das muss nichts aufwändiges sein.
Nächste Woche gehe ich auf die Grundlagen von JPCT ein.
MFG

 

[Noar]

Also ich bin dann auch mal dabei...

Habe das hier gefunden (freies 3DS-Modell). Zwar nicht das schönste Auto, aber besser als nix...

3DS-Modell eines Jeeps

 

[TRunKX]

Wann sollte es denn losgehen? Soll ich vielleicht ne eigene site dafür erstellen?

 

[Faeb]

Beginnt mal... Habe mir schon eine Welt erstellt mit JPCT und eine Kugel/Cube, die von verschiedenen Seiten beleuchtet wird..
Leider finde ich sonst nirgends ein Tutorial und ich würde gern beginnen, Spiele zu programmieren...

Also gogogo! =))

 

[Xams]

Wir haben schon angefangen guck mal eine Seite vorher^^

 

[Xams]

TUTORIAL TEIL 2
Installation und Vorbereitung
An dem Code des Demoprogrammes werde ich die Grundlagen von JPCT erklären. Der Code ist sehr gut dokumentiert, es lohnt sich auch den Code des zweiten Demo-Programms anzusehen.

GRUNDSÄTZLICHES:
Jedes Programm besteht aus einer "Welt" und Objecten die sich darin bewegen, dazu kommen noch Kameras und "Lampen".
Ein JPCT Screen kann wie ein AWT-Screen behandelt werden, deswegen sind AWT und evtl. Swing Kenntnisse unbedingt erforderlich.

INSTALLATION Ein installiertes JDK 1.5 oder höher wird vorausgesetzt... :wink:
Zum Programmieren legt man ein neues Verzeichniss mit dem Namen "JPCT" an und entpackt die JPCT.jar in dieses Verzeichniss, jetzt müsste man da einen Ordener namens "com" sehen, der einen weiteren Ordner namens "threed" enthält. Die weiteren Dateien(lowgl) fügt man dem entsprechend hinzu.
Damit ist die Instalation abgeschlossen, evtl. muss man die Dateien noch in Eclipse einbinden.
Ich fordere noch mal dazu auf ein wenig mit Blender oder 3dGamestudio zu spielen und eine Strecke zu erstellen, dies wird sehr wichtig im weiteren Verlauf. Wer mag kann auch nach 3ds Dateien von Autos suchen.
MFG

 

[Guest]

Ein JPCT Screen kann wie ein AWT-Screen behandelt werden, deswegen sind AWT und evtl. Swing Kenntnisse unbedingt erforderlich.

Das heißt ich kann auch z.B

drawString

aufrufen?

 

[Gast]

ich krieg irgendwie nur klötze hin mit dem 3dgamestudio x_X

also dieses 3d zeug modelieren kann ich irgendwie echt nich hmm

 

[para_]

wie mache ich 3ds dateien auf? geht weder mit blender noch mit 3dGameStudio brauch ich da dann noch ein extra programm?

edit: ah, über import bei blender ^^ (thx nudel)

 

[Xams]

Ein JPCT Screen kann wie ein AWT-Screen behandelt werden, deswegen sind AWT und evtl. Swing Kenntnisse unbedingt erforderlich.

Das heißt ich kann auch z.B

drawString

aufrufen?

Du kannst schon aber es wird nichts bringen, da wenn du Paint überlagerst JPCT nicht funktiniert.

wie mache ich 3ds dateien auf? geht weder mit blender noch mit 3dGameStudio brauch ich da dann noch ein extra programm?

edit: ah, über import bei blender ^^ (thx nudel)

also mit §d Gamestudio gehts auch^^

 

[para_]

wie muss eigentlich die strecke aussehen? also wie groß ungefähr? hast du zufällig ein beispiel?

 

[Xams]

einfach nur ne leere Fläche mit vllt einigen Hindernissen.
Zu den autos, bei www.blendpolis.org gibt es viele 3d-Modelle für Blender, ich hab hier schon 4 Autos heruntergeladen und in 3ds umgewandelt. Ich werde die bald zum download stellen.
MFG

 

[para_]

reicht sowas hier? --> http://www.stud.uni-karlsruhe.de/~umcyb/blender/gegend6.blend

is der maßstab eigentlich wichtig?

 

[Xams]

reicht sowas hier? --> http://www.stud.uni-karlsruhe.de/~umcyb/blender/gegend6.blend

is der maßstab eigentlich wichtig?

Perfekt genau so soll es sein
ich werde später noch zeigen , wie man einen Editor ala Trackmania erstellt.

 

[para_]

Hi, wann gehts weiter?^^

 

[TRunKX]

Denke mal heute oder morgen oder?

Er sagte doch wöchentlich! :###

 

[para_]

hm Teil 2 des Tutorials ist aber schon vom 3.4. ( vor 15 Tagen^^ )

 

[Noar]

Hey, Java-Freak, wie sieht's aus? Geht das hier auch weiter? Wenn nicht, wäre es nett, hier ne Info zu posten.

Gruß,
Noar

 

[Xams]

Ich muss mich entschuldigen, doch musste ich die letzten drei Wochen im Krankenhaus verbringen (Lebensmittelvergiftung) und hatte keine Möglichkeit am Tutorial weiterzuschreiben.
Ich verspreche aber in den nächsten Tagen den nächten Teil zu liefern.
MFG

 

[Xams]

Tutorial Teil 3

Die Klassen im Paket org.threed.jpct

Das Kernstück von Jpct sind die Klassen World, Object3d, Camera und der Loader. Während die ersten beiden Klassen jeweils sehr komplex sind, ist der Loader die Klasse zum Laden von (je nach Version) fünf verschiedene Formate:
3ds
md2
obj
asc
jaw
wobei in Zukunft vermutlich noch weitere hinzukommen werden. Eine gute Beschreibung erhält man unter http://www.jpct.net/manual2/index.html
Wie vielleicht schon vermutet, gibt es für die populärsten 3d-Formate einen Loader, mir selbst fehlen aber noch einige, wie zum Beispiel das ".blend" Format von Blender.
In diesem Tutorial werden wir das ".obj" Format und das Programm "Blender"(www.blender.org) verwenden. Wer das für Anfänger leichtere Programm 3dGamestudio vorzieht, muss dann im Code den entsprechenden Loader (Loader.load3DS) benutzen. Nun aber zu den Klassen:
Die Klasse World:
Die Klasse World ist die wichtigste Klasse von JPCT, so schreibt EgonOlsen in der Dokumentation: „The World class is the most important class in jPCT. It's like the "glue" that holds everything together. The world contains objects and light sources that define the scene for jPCT.” Also, die Klasse World ist die wichtigste Klasse in JPCT. Sie ist, wie ein Kleber der alles zusammen hält. World beinhaltet Objects und light sources, die Szene für JPCT zusammenstellen. Die Methoden die für uns anfangs von Bedeutung sind, wären folgende:

addLight(SimpleVector lightPos, java.awt.Color col)

addLight(SimpleVector lightPos, float r, float g, float b)

Mit dieser Methode platziert man Lichtquellen in der "Welt", man übergibt die Position und die Farbe(!) der „Lampe“. Es reicht aber nicht aus, nur eine Lichtquelle in der "Welt" zu platzieren.
Wenn man sich das Demoprogramm JPCTDemo anschaut, sieht man, dass dort 13Lichtquellen verwendet werden.

addObject(Object3D obj)

Fügt ein Object3D zur der Welt hinzu. dementsprechend gibt es auch.

removeObject(Object3D obj)

um das Object wieder zu entfernen. Mit

getObjectByName(java.lang.String name)

wird das angegebene Objekt zurückgegeben.

buildAllObjects()

Ruft die Methode build() für alle hinzugefügten Objekte auf.

Interessant ist auch noch:

toXML()

Hiermit wir die Welt mit den Objekten in einer XML-Datei gespeichert, die man mit

Loader.loadSceneFromXML(java.io.InputStream stream, World world)

wieder laden kann.

Wichtig bei einem Rennspiel wird auch die Methode

getCamera()

sein, mit der man die aktuelle Kamera zurückgegeben bekommt.

Der Loader:
Welchen man auch immer verwendet, die Aufrufsyntax ist immer gleich.
Loader.loadXXX(java.lang.String filename, float scale)
oder entsprechend. Scale ist die Vergrößerung des Models. Hier muss man ein wenig experimentieren.
Der Loader gibt ein Object3D zurück.

Die Klasse Camera:
Die Klasse Camera repräsentiert die Position und die Bewegungsrichtung einer Kamera.
Mit
align(Object3D object)
weißt man eine Kamera an einem Objekt zu folgen.
Mit
getXAxis()
getYAxis()
getZAxis()
erhält man die Achsen der Kamera und kann diese mit
rotateCameraAxis(SimpleVector axis, float angle)
um die jeweilige Achse rotieren lassen
JPCT bietet sehr viele Möglichkeiten, von der Erzeugung von primitiven 3d Formen, bis zur Animation von Wasser, die aber meistens nur in speziellen Fällen wirklich benötigt werden und so würde es den Rahmen dieses Tutorial sprengen, auf all diese einzugehen.
JPCT ist übrigens nicht an Fenstersysteme gebunden, man kann es auch auf (J)Panels verwenden und damit animierte Logos erstellen.
(Eine Möglichkeit, die ich für unsinnig halte, da JPCT als 3D-Engine halt nicht gerade Cpu schonend ist. Man kann das etwa mit der Verwendung von DirectX für ein Logo vergleichen...) Auch Applets können JPCT verwenden, aber hier kann man nur den Softwarerender benutzen.

(ich werde in den nächsten Tagen dies noch ergänzen -im. fehlt z.B noch die Klasse Object3D- und ein Basisprogramm vorstellen. Hierzu bin ich aus den oben genannten Gründen noch nicht gekommen)
MFG

 

[para_]

hatte jetzt keine zeit, aber ich werds mir die woche wohl mal anschaun schön dass es weitergeht

 

[Xams]

Tutorial Teil 4
Die Klasse Object3D:
Die Klasse Object3D repräsentiert Objekte in der Welt.
Sie implementiert eine Vielzahl von Methoden, wovon wir am Anfang aber nur einige benötigen werden.
Da wäre einmal:
public static Object3D mergeObjects(Object3D first, Object3D second)
Parameter
first – Das erste Objekt zum zusammenführen
second- Das zweite Objekt
Das sich daraus ergebene Objekt wird zurückgegeben.

public void build()

Diese Methode sollte aufgerufen werden, wenn das Objekt fertig ist, also alle Texturen hinzugefügt sind, etc.
Diese Methode ist nicht sehr performant, man sollte sie nur aufrufen, wenn man sie unbedingt brauch.

public void setSpecularLighting(boolean mode)

Dies ist eine recht interessante Methode, da sie, wenn sie angeschaltet ist, Objekte wesentlich realistischer darstellt. Das ist allerdings von Fall zu Fall verschieden. Man muss ein wenig experimentieren.
Nun zu meinen eigenen Klassen.
Um zu erkennen, was sich in der Umgebung des Aktuellen Objekts befindet, habe ich einige Klassen von Object3D abgeleitet. Die Hierarchie sieht folgendermaßen aus:
MyObject
Plant Human Car Animal
Enemy Friend
Durch isXXX() Methoden kann man abfragen, worum es sich handelt. Enemy und Friend sind aus Human abgeleitet, man muss also erst überprüfen ob isHuman() true zurückliefert und kann dann weiter isEnemy aufrufen.
Hier die Klassen:

package de.jpct.utils;
import com.threed.jpct.*;
public class MyObject extends Object3D
{
	public MyObject(int arg0) {
		super(arg0);
		
	}
	public MyObject(Object3D object)
	{
		super(object);
	}
		
public boolean isPlant()
{
	return false;
}

public boolean isAnimal()
{
	return false;	
}
public boolean isCar()
{
	return false;
}
public boolean isHuman()
{
	return false;
}

}

package de.jpct.utils;

import com.threed.jpct.Object3D;

public class Car extends MyObject {

	public Car(int arg0) {
		super(arg0);
		
	}
	public Car(Object3D o)
	{
		super(o);
	}
@Override public boolean isCar()
{
	return true;
} 
}

package de.jpct.utils;

import com.threed.jpct.Object3D;

public class Plant extends MyObject {

	public Plant(int arg0) {
		super(arg0);
		
	}
	public Plant(Object3D o)
	{
		super(o);
	}
@Override public boolean isPlant()
{
	return true;
}
}

package de.jpct.utils;

import com.threed.jpct.Object3D;

public class Animal extends MyObject {

	public Animal(int arg0) {
		super(arg0);
		
	}
	public Animal(Object3D o)
	{
		super(o);
	}
@Override public boolean isAnimal()
{
	return true;
}

}

package de.jpct.utils;

import com.threed.jpct.Object3D;

public class Human extends MyObject {

	public Human(int arg0) {
		super(arg0);
		
	}
	public Human(Object3D o)
	{
		super(o);
	}
@Override public boolean isHuman()
{
	return true;
}
public boolean isFriend()
{
	return false;
}
public boolean isEnemy()
{
	return false;
}
}

package de.jpct.utils;

import com.threed.jpct.Object3D;

public class Enemy extends Human {

	public Enemy(int arg0) {
		super(arg0);
		
	}
	public Enemy(Object3D o)
	{
		super(o);
	}
public boolean isEnemy()
{
	return true;
}

}

 package de.jpct.utils;

import com.threed.jpct.Object3D;

public class Friend extends Human {

	public Friend(int arg0) {
		super(arg0);
		
	}
	public Friend(Object3D o)
	{
		super(o);
	}
@Override public boolean isFriend()
{
	return true;
}

}

Nächste Woche stelle ich den Texture Manager und die Render vor, da mit wird ein kleines Programm schon möglich sein.
[EDIT] Tippfehler in der Klasse Human behoben.
[EDIT 2]
Hab ich doch glatt die Aufgaben vergessen...

schreibt mal zu den Klassen oben weitere Methoden die ihr sinnvoll haltet, wie z.B getName() und postet diese hier.

 

[TRunKX]

Hi Leute / Java-Freak!

Arbeite gerade mit und versuche alles zu verstehen (erstaunlich schwer obwohl ich Anwendungsentwickler gelernt habe). Wollte dann auch mal fragen wann es weitergeht bzw. welche Bücher du empfiehlst um sich weiter in die Materie einzuarbeiten?

 

[Evil-Devil]

Na je gewichtiger ein Zug ist, desto schlechter ist er. Das sagt doch schon der Kommentar aus. Die KI will schließlich auch nur gewinnen

 

[Xams]

Bitte den Eintrag des Gastes löschen Crosspost!
Ausserdem sollte so eine Frage in einen eigenen Thread.
MFG

 

[merlin2]

Ist erwähnte nächste Woche nicht um? :?:
Außerdem könnte man auch Evil-Devils Antwort löschen.

 

[Xams]

Tutorial Teil 6
So es ist Zeit für ein erstes Demo-Programm:
Schauen wir uns einmal den ersten Jpct Versuch von Quaxil (Ich wollte eigentlich das beiligende Demoprogramm verwenden, Danke) an:

import com.threed.jpct.*; 
import java.awt.*; 

public class Test1 extends Frame{ 

   private static final long   serialVersionUID   = 1L; 
    
   private World world; 
   private Camera camera; 
   private FrameBuffer buffer; 
   boolean running = true; 
   Object3D box; 
   TextureManager texman; 

   public static void main(String[] args){ 
      new Test1(); 
   } 
    
   public Test1(){ 

      //Engine konfigurieren 
      Config.maxPolysVisible = 10000;  //max. sichtbare Polygone 
     
     world  = new World();  // Hauptklasse instanziieren 
     world.setAmbientLight(0,255,0); //grünes Umgebungslicht 
     
     texman = TextureManager.getInstance(); 
    Texture spot=new Texture(getClass().getClassLoader().getResourceAsStream("textures/envmap.jpg"),false); 
    TextureManager.getInstance().addTexture("car", spot); 
    
    //Box erzeugen 
     box = Primitives.getBox(8f,1f); 
     box.setTexture("car"); 
     box.setSpecularLighting(true);
     //   Textur als Umgebungs-Map. Noch keine so rechte Ahnung was gemeint ist, sieht 
     box.setEnvmapped(Object3D.ENVMAP_ENABLED); 
     box.build();     
     world.addObject(box); //Box in die Welt packen 
     
    camera = world.getCamera(); //Kamera abholen 
    camera.setPosition(50,-50,-5); //Position verändern 
    camera.lookAt(box.getTransformedCenter()); //auf die Box gucken 

     //Frame erzeugen 
    setTitle("jPCT "+Config.getVersion()); 
    pack(); 
    setSize(800,600); 
    setResizable(false); 
    setVisible(true); 

    loop();    
     
   } 
    
   private void loop(){ 
       
      World.setDefaultThread(Thread.currentThread());  //JPCT-Funktionen werde aus diese Thread aufgerufen 
      buffer = new FrameBuffer(800,600,FrameBuffer.SAMPLINGMODE_NORMAL); //FrameBuffer zum Zeichnen 
      buffer.enableRenderer(IRenderer.RENDERER_SOFTWARE); //Renderer zuweisen 
      buffer.optimizeBufferAccess();//schnellst Buffer-Zugriff ermitteln 
    
       
      while(running){ 
       
         buffer.clear(); //no comment 
       world.renderScene(buffer); //world.drawWireframe(buffer, Color.white); um im Wireframe zu zeichnen
       world.draw(buffer); //zeichne in den Buffer 
       buffer.update(); //gewährleistet, daß alle Änderungen übernommen werden. Update des Output-Buffers 
          buffer.display(getGraphics());
         Thread.yield(); 
          
         try { 
            Thread.sleep(20); 
         } catch (InterruptedException e) { 
            System.out.println(e); 
         } 
          
      } 
   } 
    
}

Die Datei envmap.jpg findet ihr bei den Jpct Beispielen.
Testet das erstmal.
Die Methode
Primitives.getBox(8f,1f);
gibt ein Object3d zurück,
Zum Konfigurieren wird einmal gesetzt wie viele Polygone maximal sichtbar sind.
Quaxil hat hier einen viel zu hohen Wert genommen, da der kleine Würfel natürlich keine 10000 Polygone, wohingegen im Beispielprogramm Car der Wert aus Performancegründen zu klein ist, das merkt man daran, das einige Berge erst auftauchen, wenn man auf sie zu fährt.
Etwas zum hinzufügen von Texturen, diese müssen einmal zum Object selber hinzugefügt werden und einmal zum Texturemanager den man über getInstance bekommt (ein klassisches Singelton).
Dann wird noch ein Framebuffer verwendet, den die Welt mit world.render(buffer) zum Zeichnen verwendet
Erstetzt diese Zeile mal durch:

world.drawWireframe(buffer, Color.green);

Die beiden Zeilen

buffer = new FrameBuffer(800,600,FrameBuffer.SAMPLINGMODE_NORMAL);       
buffer.enableRenderer(IRenderer.RENDERER_SOFTWARE);

konfigurieren diesen auf eine Auflösung von 800 * 600 und fordern ihn auf den Softwarerender zu verwenden
Um den OpenGL Render zuverwenden, ist die Konstante IRenderer.RENDERER_OPENGL zu übergeben.
Wenn noch weitere fragen aufkommen bitte sofort stellen, auf diese Grundlagen werden wir nämlich aufbauen.
MFG