Das Dokument behandelt prozedurale Texturen in der Grafikumgebung OpenGL mit Java und hebt deren Vorteile wie geringeren Speicherbedarf und verlustfreie Qualität hervor. Es wird erläutert, wie prozedural generierte Texturen mithilfe von Algorithmen erstellt werden, sowie deren Anwendung in 3D-Programmen. Beispielhafte Implementierungen, einschließlich Techniken wie Perlin Noise, werden präsentiert, um die Funktionsweise und den Nutzen dieser Texturen zu verdeutlichen.

1. C A R L
V O N
O S S I E T Z K Y
Prozedurale Texturen
Johannes Diemke
Ubung im Modul OpenGL mit Java
Wintersemester 2012/2013

2. Ruckblick
Traditionelles Texture Mapping
Graphische Primitive werden mit Bildern versehen
Verlagerung von Details in Texturen
I Vereinfachung geometrischer Modelle
I Darstellung komplizierter Ober
achen durch Photographien und
Bilder
Nachteile
Hoher Speicherbedarf
Kompliziertes Mapping
Photographien beinhalten bereits Beleuchtung
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 2/21

3. Ruckblick
Wieso ist das ein Problem?
Inhalt von 3D Programmen setzt sich zusammen aus
I Meshes
I Animationen
I Texturen
Texturen nehmen ublicherweise den groten Anteil am benotigten
Speicherbedarf ein
Was kann man machen?
JPG Komprimierung (Faktor 10 bis 20, verlustbehaftet)
Prozedural generierte Texturen (sehr viel hoher, verlustfrei)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 3/21

4. Prozedurale Techniken
Allgemein
Verwendung von deterministischen Algorithmen zur Generierung von
Programminhalten
I Objekte
I Eigenschaften
I Bewegungen
I Musik
Vorteile
I Zeit- und platzsparende Generierung komplexer Inhalte
I Flexibilitat durch parametrische Kontrolle
I Detail on Demand
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 4/21

5. Prozedurale Techniken
Beispiel: Pixar's Brave
Prozedural generierte Baume, Busche, Blumen etc.
math as a brush/an artistic tool
(Quelle: http://youtu.be/EnaA9ZRPXiE)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 5/21

6. Prozedurale Texturen
Was sind prozedurale Texturen?
Durch Algorithmen generierte Texturen
I Im Primarspeicher
I Direkt im Fragment-Shader
Textur = Algorithmus + Parameter
Komplexe Texturen durch Kombination und Modi

7. kation
bestehender Texturen
I Texturen werden in einfachere Operationen unterteilt (divide and
conquer)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 6/21

8. Prozedurale Texturen
Vorteile
Beliebige Au
osung (Detail on Demand)
Keine Komprimierungsartefakte (verlustfrei)
Geringer Speicherbedarf
Texturen konnen falls notwendig direkt
tileable erzeugt werden
Normal-Map Generierung
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 7/21

9. Prozedurale Texturen
Verbinden mehrerer einfacher Standardfunktionen ...
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 8/21

10. Prozedurale Texturen
... zu etwas Komplexerem
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 9/21

11. Prozedurale Texturen
Beispiel: Textur im Primarspeicher generieren
Speicher fur die Textur allozieren:
int[] texture = new int[256*256];
// Hier die Textur mit Daten fullen
IntBuffer intBuffer = IntBuffer.wrap(texture);
gl.glBindTexture(GL2.GL_TEXTURE_2D, textureId);
gl.glTexSubImage2D(GL2.GL_TEXTURE_2D, 0, 0, 0, 256, 256, GL2.GL_RGBA,
GL2.GL_UNSIGNED_BYTE, intBuffer);
Texel in die Textur schreiben:
public void setTexel(int x, int y, int r, int g, int b, int a) {
texture[x + (y 8)] = ((a 0x000000ff) 24) |
((b 0x000000ff) 16) |
((g 0x000000ff) 8) |
((r 0x000000ff));
}
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 10/21

12. Prozedurale Texturen
Beispiel: Textur im Primarspeicher generieren (Forts.)
Sinusplasma:
for(int y=0; y 256; y++)
for(int x=0; x 256; x++) {
int value = (int)((Math.sin(2*Math.PI/256*x*xPeriods) +
Math.sin(2*Math.PI/256*y*yPeriods) + 2) / 4 * 255);
setTexel(x, y, value, value, value, 255);
}
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 11/21

13. Prozedurale Texturen
Perlin Noise
Wurde 1983 von Ken Perlin wahrend seiner Arbeit an TRON
entwickelt
I Primarspeicher war zu klein fur Texturen
I Objekte sahen zu
sauber aus
I Idee: Modulation mit Rauschfunktion noise : Rn ! R
(Quelle: http://www.noisemachine.com/talk1/)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 12/21

14. Prozedurale Texturen
Beispiel: Perlin Noise in TRON Legacy
Isosurface eines Perlin Noise Volumens unter Verwendung des
Marching Cubes Algorithmus
(Quelle: http://jtnimoy.net/?q=178)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 13/21

15. Prozedurale Texturen
Perlin Noise (Forts.)
Fraktionale Brownsche Bewegung:
fBm(p) = noise(p) + 12
noise(2p) + 1
4 noise(4p) : : :
Turbulenz:
turbulence(p) = jnoise(p)j + 12
jnoise(2p)j + 14
jnoise(4p)j : : :
Marmor:
marble(p) = sin(p:x + turbulence(p))
(Quelle: http://www.noisemachine.com/talk1/)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 14/21

16. Prozedurale Texturen
Beispiel: Solid Texturing im Fragment-Shader
vec4 colorize(vec4 color1, vec4 color2, float value) {
return value * color2 + (1-value)* color1;
}
vec4 marble2(vec3 pos) {
float intensity = dot(normalize(gl_LightSource[0].position.xyz),
normalize(eyeSpaceNormal));
float fBm = abs(snoise(pos*2)) + abs(snoise(pos*4))*1/2 +
abs(snoise(pos*8))*1/4 + abs(snoise(pos*16))*1/8;
float marble = (1+sin(pos.x*10+fBm*3.2))/2;
return colorize(vec4(0.2,0.0,0.1,1.0), vec4(1.0,1.0,1.0,1), marble) *
(intensity*0.7 + 0.3);
}
void main() {
gl_FragColor = marble2(pos);
}
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 15/21

17. Prozedurale Texturen
Beispiel: Solid Texturing im Fragment-Shader (Forts.)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 16/21

18. Prozedurale Texturen
XPTS
eXtensible Procedural Texturing System
Graphbasierter Editor zur Erzeugung prozeduraler Texturen im
Primarspeicher
Implementiert gangige Algorithmen
Erweiterbarkeit durch Plugins
Integrierte Plugin IDE
Speicherung von Texturen in XML-Dialekt oder Binarformat
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 17/21

19. Prozedurale Texturen
XPTS GUI
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 18/21

20. Prozedurale Texturen
XPTS Texturen
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 19/21

21. Prozedurale Texturen
XPTS Texturen (Forts.)
Johannes Diemke OpenGL mit Java WiSe 2012 / 2013 20/21