OpenGL ES ist gar nicht mal schwer – man sollte nur gewohnt sein mit VBOs umzugehen und nicht noch in der alten “glBegin()”… “glEnd()” Welt feststecken.

Tag Archives: OpenGL
Beware of still enabled vertex attrib Arrays
The last days I had to fight against an annoying crash that always occurred when I switched shaders. As you most probably know, vertex data are bound to shaders using glVertexAttribPointer and glEnableVertexAttribArray. I assumed, that unbinding a buffer means automatically disabling all these attrib pointers. I was terribly wrong – if the new shader did not need any normals, for example, these attributes still stayed enabled and lead to the following crash message:
# A fatal error has been detected by the Java Runtime Environment:
#
# SIGSEGV (0xb) at pc=0xafe01d99, pid=10379, tid=2916498288
#
# JRE version: 7.0_03-b04
# Java VM: Java HotSpot(TM) Server VM (22.1-b02 mixed mode linux-x86 )
# Problematic frame:
# C 0xafe01d99
#
# Failed to write core dump. Core dumps have been disabled. To enable core dumping, try "ulimit -c unlimited" before starting Java again
#
# An error report file with more information is saved as:
# /home/stefan/dev/workspace/TheParrotEngine/hs_err_pid10379.log
#
# If you would like to submit a bug report, please visit:
# http://bugreport.sun.com/bugreport/crash.jsp
#
The detais I found in the report file were not very helpful, too:
Stack: [0xadd92000,0xadde2000], sp=0xadde0a3c, free space=314k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
C 0xad5dbd99
[error occurred during error reporting (printing native stack), id 0xb]
j jogamp.opengl.gl4.GL4bcImpl.dispatch_glDrawElements1(IIIJJ)V+0
j jogamp.opengl.gl4.GL4bcImpl.glDrawElements(IIIJ)V+47
j javax.media.opengl.DebugGL2.glDrawElements(IIIJ)V+13
j de.gaffga.DeleteBuffersTest.display(Ljavax/media/opengl/GLAutoDrawable;)V+350
j jogamp.opengl.GLDrawableHelper.displayImpl(Ljavax/media/opengl/GLAutoDrawable;)V+45
j jogamp.opengl.GLDrawableHelper.display(Ljavax/media/opengl/GLAutoDrawable;)V+2
j com.jogamp.newt.opengl.GLWindow$DisplayAction.run()V+60
j jogamp.opengl.GLDrawableHelper.invokeGLImpl(Ljavax/media/opengl/GLDrawable;Ljavax/media/opengl/GLContext;Ljava/lang/Runnable;Ljava/lang/Runnable;Ljavax/media/opengl/GLAutoDrawable;)V+136
j jogamp.opengl.GLDrawableHelper.invokeGL(Ljavax/media/opengl/GLDrawable;Ljavax/media/opengl/GLContext;Ljava/lang/Runnable;Ljava/lang/Runnable;)V+85
J com.jogamp.opengl.util.AnimatorBase.display()V
j com.jogamp.opengl.util.Animator$MainLoop.run()V+346
j java.lang.Thread.run()V+11
v ~StubRoutines::call_stub
--------------- P R O C E S S ---------------
Java Threads: ( => current thread )
0xf6803c00 JavaThread "DestroyJavaVM" [_thread_blocked, id=8770, stack(0xf6933000,0xf6983000)]
=>0xafede800 JavaThread "main-AWTAnimator-1" [_thread_in_native, id=8793, stack(0xadd92000,0xadde2000)]
0xafedb000 JavaThread "main-Display-X11_:0-1-EDT-1" daemon [_thread_blocked, id=8792, stack(0xadde2000,0xade32000)]
0xafe95800 JavaThread "main-SharedResourceRunner" daemon [_thread_blocked, id=8791, stack(0xadedd000,0xadf2d000)]
[...]
The solution is to make sure, the vertex attrib arrays all get disabled using glDisableVertexAttribArray after being used!
if(currentShader.aProg1VertexPos!=-1) {
gl.glVertexAttribPointer(currentShader.aProg1VertexPos, 3, GL.GL_FLOAT, false, 24, 0);
gl.glEnableVertexAttribArray(currentShader.aProg1VertexPos);
}
if(currentShader.aProg1NormalPos!=-1) {
gl.glVertexAttribPointer(currentShader.aProg1NormalPos, 3, GL.GL_FLOAT, false, 24, 12);
gl.glEnableVertexAttribArray(currentShader.aProg1NormalPos);
}
gl.glDrawElements(GL2.GL_QUADS, cubeIndices.length, GL2.GL_UNSIGNED_INT, 0);
gl.glBindBuffer(GLConst.GL_ARRAY_BUFFER, 0);
gl.glBindBuffer(GLConst.GL_ELEMENT_ARRAY_BUFFER, 0);
// IMPORTANT: Disable all vertex attrib arrays
if(currentShader.aProg1VertexPos!=-1) {
gl.glDisableVertexAttribArray(currentShader.aProg1VertexPos);
}
if(currentShader.aProg1NormalPos!=-1) {
gl.glDisableVertexAttribArray(currentShader.aProg1NormalPos);
}
So maybe you run into the same problem as me… and if this post now helped you solve your issue, it has served its purpose
WebGL Demo of animated Character
I finally finished my WebGL demo to render an animated character. To create the JSON File, I changed my ParrotEngine Blender Export Script to output a JSON file instead of XML.
The demo was tested on Firefox 7 and 8, Opera 12 and Google Chrome 15 – each was running fine. Internet Explorer does not support WebGL – and probably never will, so you have to use another browser to see the demo…
Continue reading
ParrotEngine 0.2 released
Ab sofort ist die Version 0.2 der 3D Parrot Engine verfügbar! Gegenüber der Vorversion wurde die grundlegende Struktur der Engine überarbeitet, das Renderverfahren flexibler gestaltet und eine Menge Performanceoptimierungen sowie Verbesserungen an der Klassenstruktur vorgenommen.
Dieses Release hat als Hauptaufgabe die Basisinfrastruktur der Engine so zu stabilisieren, dass eine feste Grundlage entsteht auf der alle weiteren Erweiterungen implementiert werden können ohne eine erneute Anpassung der Grundstruktur zu erfordern.
Mit dieser Version kommen nun auch einige Beispielprogramme um den Einstieg in die Programmierung mit der Engine zu erleichtern und auch um die Features zu demonstrieren. Das Build-System wurde komplett überarbeitet so dass nun ein einzelnes build.xml alle Aufgaben erledigen kann: Auch das Starten der Beispielprogramme.
Ein Getting-Started Tutorial zeigt, wie einfach mit der Entwicklung mit der Engine begonnen werden kann. Angefangen von der Einrichtung der Entwicklungsumgebung bis hin zum ersten lauffähigen Programm. Die Downloads und weiteren Links befinden sich wie gehabt auf der Hauptseite der Engine.
RenderState Sortierung und Optimierung
Jedes Objekt einer Szene kann ein oder mehrere Materialien verwenden. Ein Material wird über einen RenderState repräsentiert, welcher neben den üblichen OpenGL Material-Settings auch alle Textureinstellungen, die Shader-Programme, En- und Disabled Eigenschaften, den zu verwendenden Polygon Mode, Blend Operationen und viele weitere Eigenschaften enthält. Bei jedem Wechsel des aktiven RenderStates werden nur die OpenGL calls ausgeführt die wirklich notwendig sind. Es ist außerdem nicht notwendig, dass irgendein Objekt weiß welche Einstellungen in OpenGL vorliegen bevor es sich zeichnet – durch das Setzen seines RenderStates kann es sicher sein, dass genau nur die von ihm geforderten Einstellungen aktiv sind.
Ein Timer-Framework hilft dabei Performance-Engpässe zu erkennen und zu beseitigen.
Shader-Support
Die Engine unterstützt Vertex- und Fragmentshader in GLSL. Die Shader sind in die RenderStates eingebettet und werden so als Teil der Materialien angesehen. Die Shader können deklarativ mit Properties im Programm verknüpft werden. Auf diesem Weg können Parameter an die Shader übergeben werden.
Console
Um zur Laufzeit eine gute Kontrolle über die Engine zu haben und auch um auf ein laufendes Programm direkt Einfluss zu nehmen, gibt es die Console. Sie wird mit der Taste “^” eingeblendet und verfügt unter anderem über eine Historie der Eingabezeilen, Scrollback-Funktion und auch eine Eingabehilfe mit der Tabulator-Taste. Es ist für jedes Objekt sehr einfach möglich Variablen oder Kommandos in der Console zu registrieren und diese damit zur Laufzeit aufrufbar zu machen. Die der Console bereitgestellten Variablen sind so implemetiert, dass kein Performanceverlust dadurch entsteht. Es besteht also kein Grund darin, mit den Console-Variablen sparsam umzugehen.
Frustum Culling
Jedes Objekt im Szenenbaum besitzt eine Kugel die es komplett einschließt. Bevor Objekte gezeichnet werden, wird zunächst diese Kugel auf Sichtbarkeit geprüft und erst wenn die Kugel zumindest teilweise den aktiven Frustum berührt, wird das Objekt selbst auch gezeichnet. Das Terrain wird sogar in viele kleine Teile zerlegt und diese werden dann geprüft – allerdings werden die Terrainteile in Blöcke und nicht in Kugeln eingefasst.
Partikeleditor
Mit dem Partikeleditor kann komfortabel ein Partikelsystem aus mehreren Partikelströmen erzeugt werden. Der Editor unterstützt das Live-Verändern von Texturen, Bewegungseinstellungen, Farbverläufen, Größenänderungen, Schwerkraftverlauf, Emitterstärke und einiges mehr. Die so erzeugten Partikelsysteme können in einer XML-Datei exportiert und dann im eigenen Programm durch die Engine geladen in den Szenenbaum eingehangen werden.
Fontcreator
Der Fontcreator erzeugt aus TTF-Fonts Schrifttexturen die als Bitmapfonts verwendet werden können.
3D-TTF Text
Die Engine kann aus TTF-Dateien 3D-Texte erzeugen. Die Qualität der Texte kann beeinflusst werden und somit ist eine Steuerung der Menge an Geometriedaten möglich die erzeugt werden. Die 3D-Texte sind nach ihrer Erstellung normale 3D-Objekte und auch mit Texturkoordinaten versehen, so dass die normalen Objektoperationen damit möglich sind.
Terrain Rendering mit LOD
Aus einer Heightmap in Verbindung mit einer optionalen Textur kann ein Terrain erzeugt werden. Das Terrain wird unterteilt in ein NxN Raster von Blöcken. Diese werden – je nach Entfernung vom Betrachter – in unterschiedlichen Levels-of-Detail (LOD) dargestellt um die Menge an zu zeichnenden Geometriedaten zu optimieren.
Skybox
Einer Szene kann eine Skybox zugewiesen werden – dadurch ist es einfach möglich einer Szene einen Hintergrund zu geben der sich entsprechend bei der Änderung der Blickrichtung so verhält, als würde er eine weite umliegende Welt darstellen.
Input Handling
Über eine Abstraktionsschicht werden die Benutzereingaben gekapselt und vorverarbeitet. Die Eingaben landen in einer Queue die dann an die in dieser Queue registrierte Listener verteilt werden. Diese Listener erhalten dann die Möglichkeit exklusiv die Eingaben zu verarbeiten oder aber auch nur als Proxy zu fungieren und unverändert passieren zu lassen. Durch dieses Verfahren ist es einfach möglich eine Mouselook-Funktion für ein Programm zu implementieren: Einfach einen TurntableRotator instanzieren und in die Queue einhängen – wenn nun für jedes Frame der Frustum des TurntableRotators geholt und in die Engine gesetzt wird kann man sich schon mit der Maus frei umsehen.
Endlicher Automat
Zur Verwaltung von Spielzuständen und deren Wechsel untereinander ist ein endlicher Automat integriert.
Audio-System
Das integrierte Audio-System unterstützt das Abspielen von mehreren gleichzeitigen Sounds im WAV als auch im OGG-Format.
Blender Export Script
Zur Erstellung von 3D-Objekten ist ein Python Export-Skript für Blender bei der Engine dabei. Dieses Skript muss lediglich in den Skript-Path von Blender kopiert werden und ist anschließend in den Export-Modulen von Blender zu finden. Das Skript exportiert alle selektierten Objekte in einzelne XML-Dateien die jeweils den Namen des Objekts tragen. Wenn Texturen zugeordnet sind, werden diese ebenfalls exportiert. Empties (leere Objekte in Blender) landen als Marker Objekte in den exportierten Objektdateien – damit kann von Applikationen über den Namen des Markers auf deren Position und Ausrichtung innerhalb eines Objekts zugegriffen werden. Die Partikel-Demo nutzt dieses Feature zum Beispiel um die Position des Partikelsystems im Holzstapel zu bestimmen.
Feuer-Demo des Partikel-Systems
Ich habe eine Webstart-Demo online gestellt die den aktuellen Stand des Partikel-Systems in der Parrot Engine zeigt. Das Bild zeigt ein aus Partikeln bestehendes Feuer.
In der Engine gibt es bereits einen umfangreichen Partikel-Editor der das erstellte System per XML exportieren kann. Diese XML-Datei wird direkt von der Engine verarbeitet und das hierdurch definierte System kann anschließend direkt in den Szene-Graphen eingefügt werden. Das Zeichnen und simulieren des Systems steuert dann alles die Engine ganz automatisch.
Beim nächsten Release wird sowohl der Partikel-Editor schon mit dabei sein als auch diese Feuer-Demo und der Alienshooter. Ich hoffe auch, dass ich dazu kommen werde mit dem nächsten Release einiges an Dokumentation mitzuliefern: Eine Referenzdoku sowie ein “Getting-Started” sind wohl erstmal am dringensten.








