Texturen

• 2D-Rastergrafiken, die als "Farbtapete" auf 3D-Geometrie aufgetragen werden

  

• dadurch höherer Detailgrad als durch reine Geometrie

• pro Polygon oder pro Geometrie

Texture Mapping

• Texturen sind i.d.R. quadratisch und im Bereich $[0;1]$$[0;1]$ parametrisiert
• Zur Anwendung benötigt es Abbildung, die 2D-Koordinaten auf 3D-Oberflächen mapped: Texture-Mapping

OpenGL

• Setzen von Texturkoordinate: glTexCoord2f(x, y)

• wird beim nächsten Zeichnen eines Stützpunktes zugeordnet

  xxxxxxxxxx
  glBegin(GL_POLYGON);
  glTexCoord2f(0.25f,0.50f); glVertex3f(-1.0f, 1.0f, 1.0f);
  glTexCoord2f(0.25f,0.25f); glVertex3f(-1.0f,-1.0f, 1.0f);
  glTexCoord2f(0.50f,0.25f); glVertex3f( 1.0f,-1.0f, 1.0f);
  glTexCoord2f(0.50f,0.50f); glVertex3f( 1.0f, 1.0f, 1.0f);
  glEnd();
  

• Texturkoordinaten sind Teil der Vertex-Daten (Pipeline links)

• Texturen selbst sind Pixeldaten (Pipeline rechts)

• Texturpixel = "Texel"

• Texturen werden i.d.R. vor Rendern erzeugt

• Erzeugung:

  xxxxxxxxxx
  glBindTexture(GL_TEXTURE_2D, texID);
  glTexImage2D(GL_TEXTURE_2D, texLevel, texFormat, inWidth, inHeight, 
               inBorder, inFormat, inType, inData);
  

  • texID: Kennzeichner der erzeugten Textur

• während Rendering muss zuerst Textureinheit aktiviert werden: glEnable(GL_TEXTURE_2D)

• Beim Rendern wird über texID auf Textur zugegriffen und diese an GL_TEXTURE_2D gebunden: glBindTexture(GL_TEXTURE_2D, texID);

  • bei neuer ID wird Textur erzeugt, bei bestehender ID wird Textur aktiviert

Wrap-Parameter

• GL_TEXTURE_WRAP bestimmt, wie Texture-Mapping sich verhält, wenn Texturkoordinaten außerhalb $[0;1]$$[0;1]$ liegen

  

Filter-Parameter

• zur Berechnung von Farbwerten, für Koordinaten, die nicht exakt auf dem Pixelraster der Textur liegen

• Verwendung:

  xxxxxxxxxx
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  

• Unterscheidung:

  • GL_TEXTURE_MAG_FILTER: Für Vergrößerungen: Auflösung der Textur ist geringer als die des Viewports, ein Texturpixel "überlagert also mehrere Viewportpixel"

    z.B.: Viewport: 4k; Textur: 720p

  • GL_TEXTURE_MIN_FILTER: Für Verkleinerungen: Auflösung der Textur ist höher als die des Viewports, es "passen mehrere in einen Viewportpixel"

    z.B.: Viewport: 720p, Textur: 4k

• Parameterwerte

  • GL_NEAREST

    • rundet auf nächste Texturkoordinate (Pixel)
    • schnell

  • GL_LINEAR

    • bilineare Interpolation
    • die vier benachbarten Texturpixel (in x- und y-Richtung) werden betrachtet und ein mittlerer Farbwert aus diesen wird interpoliert
    • aufwändig
    • Aliasing wird reduziert

Mip-Mapping

• Trotz bilinearer Interpolation kann es bei weit entfernten Oberflächen zu Aliasing kommen, da sehr viele Texturpixel auf einen Kamerapixel projiziert werden

• Um dies zu verhindern müssten daher nicht nur die benachbarten 4 sondern alle betroffenen Texel bei der Interpolation berücksichtigt werden.
• Mipmaps (lat. multum in parvo = "viel im Kleinen") dienen zur Approximation dessen.

• Auflösungspyramide, mit jeweils Viertelung der Auflösung auf nächsthöherer Ebene

  

• OpenGL wählt automatisch Mip-Map, deren Auflösung am nächsten an der Auflösung der Projektion im Framebuffer liegt

Wirkung der Textur

• Mit glTexEnv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); kann beeinflusst werden, wie Texturfarbe mit aktuellem Fragment (Farbwert und Alphakanal) kombiniert wird.

  • GL_REPLACE: Texturfarbe wird direkt übernommen
  • GL_MODULATE: multiplikative Mischung aus Textur- und Fragmentfarbe
  • GL_DECAL: Blending der Texturfarbe auf Fragmentfarbe abhängig vom Alphakanal der Textur
  • GL_BLEND: Blending der Texturfarbe auf Fragmentfarbe abhängig von Farbe des Fragments
  • GL_ADD: Aufaddierung der Texturkanäle auf die Fragmentkanäle

Automatische Erzeugung von Texturen

• Motivation: händische Zuweisung von Texturkoordinaten ist für komplexe Oberflächen sehr aufwändig
• Idee (von Bier & Sloan): Umhüllung des Objektes mit primitivem Objekt (Zylinder, Kugel, Quader) und Texturierung dessen

3D-Texturen

• Rastergrafiken mit drei Dimensionen
• bestehen aus aufeinander gestapelten 2D-Texturen
• z.B. aus medizinische Bilderfassung

Textureinheiten

• Grafikkarten verfügen über mehrere Textureinheiten
• erlauben gleichzeitigen Zugriff auf mehrere Texturen (mehrere Texturen gleichzeitig gebunden)
• Umschaltung per glActiveTexture(GL_TEXTURE0), glActiveTexture(GL_TEXTURE1), ...
• relevant für Shader

Framebuffer Objects

• In OpenGL können Pixel-Daten des Framebuffers ausgelesen werden, um sie z.B. für zweiten Rendering-Durchgang zu nutzen.
• Statt auf den originalen Framebuffer ("sichtbare Leinwand") zu rendern, wird ein neues Framebuffer Object (FBO) definiert und als Renderziel gesetzt: Off-Screen-Rendering

• Zur Speicherung der zu erzeugenden Pixeldaten können entweder Texturen oder Renderbuffer Objects verwendet werden.