Um einen netten Glas-Effekt zu erzeugen kann man z.B. folgende Blendfunktion benutzen:

glBlendFunc( GL_ONE, GL_ONE );

die Textur wird dazu nun so erstellt (mit mipmaps):
glBindTextre( ... );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
gluBuild2DMipmaps( GL_TEXTURE_2D, 4, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data );

das funktioniert soweit wunderbar:

Wenn nun jedoch die Textur direkt über glTexImage2D geladen wird (also ohne gluBuild2DMipmaps):

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D, 0, 4, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );

schlecht :(

Das Poblem trat nähmlich auf als ich eine eigene Mipmap-routine implementiert
habe um die Depency zu glu32 aufzuheben. Die Textur wird dabei immer um ein Viertel verkleinert und über glTexImage2D( GL_TEXTURE_2D, level ... ) geldaden.

Meine Frage ist dabei: Was macht bitteschön gluBuild2DMipmaps anders als der ober beschriebene Vorgang oder woran könnte das liegen? Am Alpha-Channel oder glColor - Werten liegt höchstwahrscheinlich nicht - das habe ich nähmlich bereits getestet.

beim mipmapping musst du ALLE verkleinerungen bis runter zu 1x1 generieren, sonst ist es keine gueltige textur!
also bei einer 64x128 textur musst du folgende mipmaps erzeugen:
0: 64x128
1: 32x64
2: 16x32
3: 8x16
4: 4x8
5: 2x4
6: 1x2
7: 1x1

btw: der glaseffekt gefaellt mir nicht, bei deinem effekt wird das dahinterliegende heller, aber durch filter (wozu auch glas zaehlt) kann wird das dahinterliegende immer dunkler. (zumindest marginal, auf jeden fall wird es nicht heller)

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

ja das ist mir schon klar - mein mipmapping funktioniert ja auch wunderbar - bis eben auf die Blendfunktion. Ich habe ja auch erleutert dass es mit Normalem Texture-Load (also mipmaps) nicht funktioniert, sonern nur eben mit gluBuild2DMipmaps.
Gibts zu "glu" nicht zufällig eine sample-implementierung für win32? Bisher habe ich nur welche für X-Window Systems gesehen. (am besten die von Nvidia:)

Ahem. Eine Sample-Implementierung von glu dürfte keinen Unterschied zwischen X-Windows und Win32 haben, zumindest nicht bei so elementaren Dingen wie BuildMipmaps.

Wenn ich das richtig verstanden habe hängt dein Problem ja nicht mit Mipmapping zusammen - wieso sprichst du Mipmapping also überhaupt an?.
Man kann hier ja leicht sehen, daß die Textur nicht komplett ist (bzw. Texturing ist disabled), aber warum läßt sich an Hand von den paar Codeschnippseln nicht wirklich sagen.
Übrigens: der "Fuß" von dieser Glasscheibe ist ja im ersten Bild auch schon inkorrekt.

Kleine Randbemerkung: Ab OpenGL 1.2 oder 1.3 kann man die Anzahl der Mipmappinglevels verändern (TexParameter) und muß nicht mehr alle bis zu 1x1 erstellen, aber das hat mit diesem Thread ja wohl nichts zu tun.

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

der Fuß hat ne weiße Textur - das soll ein leuchtender Sockel sein.
Ich komme deswegen mit BuildMipmaps an, weil diese Funktion scheinbar irgend etwas anderes macht als nur die Pixel zu scalen und via Teximage2D zu laden.
Bei Texturen ohne Blending funkioniert meine eigene Mipmap-Funktion schließlich einwandfrei - es kann also nicht am nicht eingeschalteten 2DTexture-Mapping liegen. Dieser Fehler tritt auch ohne Multitexturing auf - kommt also auch nicht als Fehlerquelle in Frage.
Vielleicht habe ich aber auch nur etwas total beschissenes übersehen, dehalb poste ich hier mal sicherheitshalber meinen Mipmap-Code:

Quellcode:
void GL_Scale2DPixels( GLint components, GLsizei width, GLsizei height, byte *data )
{
  int i, j, k, index, index2;

  byte *data2;

  data2 = data;

  for( i=0 ; i<height ; i+=2 )  // zwei vertikale Pixel ...
  {
    for( j=0 ; j<width ; j+=2 )  // ... und zwei horizontale Pixel werden zu einem
    {
      index = (i*width + j) * components;    // aktuelle Spalte
      index2 = ((i+1)*width + j) * components;  // nächste Spalte

      for( k=0 ; k<components ; k++ )
      {
        *data2++ = ( data[index] + data[index+components] +
          data[index2] + data[index2+components] ) >> 2;
        index++;
        index2++;
      }
    }
  }
}

void _gluBuild2DMipmaps( GLenum target, GLint components, GLint width, GLint height,
    GLenum format, GLenum type, const void *data )
{
  int  miplevel, mipsize;
  byte *mipdata;

  // was anderes wird nicht unterstützt!
  assert( target == GL_TEXTURE_2D );
  assert( type == GL_UNSIGNED_BYTE );

  mipsize = width*height*components;
  mipdata = new byte[ mipsize ];
  memcpy( mipdata, data, mipsize );

  miplevel = 0;

  glTexImage2D( target, miplevel, components,
    width, height, 0, format, type, mipdata );

  while( width > 1 || height > 1 )
  {
    GL_Scale2DPixels( components, width, height, mipdata );
    miplevel++;

    width >>= 1;
    height >>= 1;

    if( width < 1 )
      width = 1;
    if( height < 1 )
      height = 1;

    glTexImage2D( target, miplevel, components,
      width, height, 0, format, type, mipdata );
  }

  delete [] mipdata;
}