Delphi-PRAXiS - OpenGL Texture -Problem

Hallo zusammen...

Habe da ein kleines Problem mit Texturen in OpenGL.
Die Texturen werden geladen, aber dennoch nicht angezeigt...
vielleicht habe ich ja was übersehen...

also zuerst die ganzen Parameter initialisieren

Delphi-Quellcode:

			function Init_OpenGL ( _handle: THandle; _width, _height: Word ): Boolean;

var

  TMUs: Integer;

begin

  try

    // init the camera

    Camera := Init_3D_TRS;

    Camera._tx := 0;

    Camera._ty := -0.7;

    Camera._tz := -7;

    // Setup OpenGL

    DC := GetDC ( _handle );

    RC := CreateRenderingContext ( DC,

                                   [ opDoubleBuffered ],

                                   32,                         // ColorBits

                                   24,                         // ZBits

                                   0,                          // StencilBits

                                   0,                          // AccumBits

                                   0,                          // AuxBuffer

                                   0 );                        // Layer

    ActivateRenderingContext ( DC, RC );

    // Check, if the GFX-Card supports Multitexturing

    glGetIntegerv ( GL_MAX_TEXTURE_UNITS, @TMUs );

    if TMUs < 2 then begin

      console ( 'no support for multitexturing' );

    end;

    // Enable 2D Textures

    glEnable ( GL_TEXTURE_2D );

    // Enable Depth Test

    glEnable ( GL_DEPTH_TEST );

    // Depth Buffer Setup

    glClearDepth ( 1.0 );

    // Set Detph Function

    glDepthFunc ( GL_LEQUAL );

    // Qualitativ bessere Koordinaten Interpolation

    glHint ( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );

    // Set Clear Color = black

    glClearColor ( 0, 0, 0, 0 );

    // set screen-size

    Resize_OpenGL ( _width, _height );

    // create font

    CreateFont ( 0.01 );

    // clean the texture-puffer

    Init_Textures;

    // create Quadric

    MySphere := gluNewQuadric();

    // Set OpenGL initialized

    OpenGL_Initialized := true;

    result := true;

  except

    OpenGL_Initialized := false;

    result := false;

    exit;

  end;

end; // <- Init_OpenGL

Delphi-Quellcode:

			function Init_Textures: Boolean;

var

  Counter: Word;

begin

  try

    // init the texture-puffer

    for Counter := 1 to TEXTURESMAX do

      if Textures [ Counter ] <> nil then begin

        Textures [ Counter ].Free;

        Textures [ Counter ] := nil;

      end;

    result := true;

  except

    result := false;

    exit;

  end;

end; // <- Init_Textures

Das Array Textures sieht folgendermaßen aus...

Delphi-Quellcode:

textures: array [ 1..TEXTURESMAX ] of TGLBmp;

Dann werden mal ein paar Texturen geladen...(alles 512x512 jpg-files)

Delphi-Quellcode:

			  Load_Texture ( textures [ 1 ], EPath + '\media\yx_values_13080Hz_abs.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 2 ], EPath + '\media\yz_values_13080Hz_abs.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 3 ], EPath + '\media\zx_values_13080Hz_abs.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 4 ], EPath + '\media\yx_values_13080Hz_im.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 5 ], EPath + '\media\yz_values_13080Hz_im.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 6 ], EPath + '\media\zx_values_13080Hz_im.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 7 ], EPath + '\media\yx_values_13080Hz_re.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 8 ], EPath + '\media\yz_values_13080Hz_re.bin.jpg' );//, true, true );

  Load_Texture ( textures [ 9 ], EPath + '\media\zx_values_13080Hz_re.bin.jpg' );//, true, true );

das Load_Texture sieht so aus:

Delphi-Quellcode:

			function Load_Texture ( var _tex: TGLBmp; _filename: String; _s3tc: Boolean = false; _ani: Boolean = false ): Boolean; overload;

begin

  try

    if _tex <> nil then

      _tex.Free;

    _tex := TGLBmp.Create ( _filename );

    _tex.GenTexture ( _s3tc, _ani );

    result := true;

  except

    result := false;

    exit;

  end;

end; // <- Load_Texture

TGLBmp.Create ( _filename ); ...sollte funktionieren...da macht er nichts anderes als die texturedaten einlesen
GenTexture (); ...ist eigentlich auch fertig und sollte tun...aber naja...

Delphi-Quellcode:

			procedure TGLBMP.GenTexture(pS3TC, pAni : Boolean);

var

 MaxAnisotropy : TGLUInt;

begin

  if Assigned(rgbBits) then begin

    // If a texture object has already been created, delete it

    if TextureID > 0 then

      glDeleteTextures(1, @TextureID);

    // Create a new OpenGL texture object

    glGenTextures(1, @TextureID);

    glBindTexture(GL_TEXTURE_2D, TextureID);

    // Set up parameters

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texWrapS);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texWrapT);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);

    // Zusatz : Anisotropisches Filtern

{!} if pAni then

{!}  begin

{!}  glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAnisotropy);

{!}  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, MaxAnisotropy);

{!}  end

{!} else

{!}  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0);

    // MipMaps generieren, wenn möglich im komprimierten S3TC-Format

{!} if pS3TC then

{!}  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, PByte(rgbBits))

{!} else

{!}  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, PByte(rgbBits))

  end;

end;

...so zu guter letzt die Renderei...

Delphi-Quellcode:

			procedure TForm1.Timer1Timer(Sender: TObject);

begin

  if not begin_Render then exit;

  // Switch to 2D mode

  OpenGL_2D;

//  Show_Line2D ( Vector2D ( 1, 1 ), Vector2D ( 200, 10 ), FloatColorAlpha ( 0, 0, 1, 1 ) );

  // Switch to 3D mode

  OpenGL_3D;

  inc ( count );

  set_globalambient ( 0.5, 0.5, 0.5, 1 );

  Show_TexturedQuad3D ( Get_3D_TRS ( 0, 0, 0, 0, 0, 0, 2, 2, 2 ),

                        FloatColorAlpha ( 1, 1, 1, 0.7 ), 3*textureindex-2 );

  Show_TexturedQuad3D ( Get_3D_TRS ( 0, 0, 0, 0, 90, 0, 2, 2, 2 ),

                        FloatColorAlpha ( 1, 1, 1, 0.7 ), 3*textureindex-1 );

  Show_TexturedQuad3D ( Get_3D_TRS ( 0, 0, 0, 90, 0, 0, 2, 2, 2 ),

                        FloatColorAlpha ( 1, 1, 1, 0.7 ), 3*textureindex-0 );

  end_Render;

end;

Delphi-Quellcode:

			function begin_Render: Boolean;

begin

  if not OpenGL_Initialized then begin

    result := false;

    exit

  end;

  // Clearscreen

  glClear ( GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT );

  glViewport ( 0, 0, Screen_Width, Screen_Height );

  glMatrixMode ( GL_MODELVIEW );

  glLoadIdentity;

  // set to camera-view

  Compute_Camera;

  result := true;

end; // <- begin_Render

procedure OpenGL_2D;

begin

  glMatrixMode ( GL_PROJECTION );

  glPushMatrix ();                                      // Store The Projection Matrix

  glLoadIdentity ();                                    // Reset The Projection Matrix

  glOrtho ( 0, Screen_width, 0, Screen_height, -1, 1 ); // Set Up An Ortho Screen

  glMatrixMode ( GL_MODELVIEW );

  glPushMatrix ();                                      // Store old Modelview Matrix

  glLoadIdentity (); // Reset The Modelview Matrix

end; // <- go2d

procedure OpenGL_3D;

begin

  glMatrixMode ( GL_PROJECTION );

  glPopMatrix ();                 // Restore old Projection Matrix

  glMatrixMode ( GL_MODELVIEW );

  glPopMatrix ();                 // Restore old Projection Matrix

end; // <- exit2d

procedure end_Render;

begin

  // Redraw screen

  SwapBuffers ( dc );

end; // <- end_Render

procedure Show_TexturedQuad3D ( _3D_TRS: T3D_TRS;

                                Color: TFloatColorAlpha;

                                _tex_Index: Word ); overload;

begin

  if _tex_Index < 1 then

    Show_TexturedQuad3D ( _3D_TRS, Color, nil )

  else

    Show_TexturedQuad3D ( _3D_TRS, Color, Textures [ _tex_Index ] );

end; // <- Show_TexturedQuad3D

procedure Show_TexturedQuad3D ( _3D_TRS: T3D_TRS;

                                Color: TFloatColorAlpha;

                                _tex: TGLBmp ); overload;

var

  C1, C2, C3, C4: TVector3D;

begin

  C1 := Vector3D ( -1,  1, 0 );

  C2 := Vector3D (  1,  1, 0 );

  C3 := Vector3D (  1, -1, 0 );

  C4 := Vector3D ( -1, -1, 0 );

  glEnable ( GL_BLEND );

  glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

  glPushMatrix;

  glTranslatef ( _3D_TRS._tx, _3D_TRS._ty, _3D_TRS._tz );

  glRotatef ( _3D_TRS._rx, 1, 0, 0 );

  glRotatef ( _3D_TRS._ry, 0, 1, 0 );

  glRotatef ( _3D_TRS._rz, 0, 0, 1 );

  glScalef ( _3D_TRS._sx, _3D_TRS._sy, _3D_TRS._sz );

  if _tex <> nil then

    _tex.Bind

  else

    glBindTexture ( GL_TEXTURE_2D, 0 );

  glcolor4f ( Color.r, Color.g, Color.b, Color.a );

  glbegin ( GL_QUADS );

    glTexCoord2f ( 0, 1 );

    glvertex3f ( C1.x, C1.y, C1.z );

    glTexCoord2f ( 1, 1 );

    glvertex3f ( C2.x, C2.y, C2.z );

    glTexCoord2f ( 1, 0 );

    glvertex3f ( C3.x, C3.y, C3.z );

    glTexCoord2f ( 0, 0 );

    glvertex3f ( C4.x, C4.y, C4.z );

  glend;

  glPopMatrix;

  glDisable ( GL_BLEND );

end; // <- Show_TexturedQuad3D

...so weit so gut...

grüße