Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » OpenGL » texturieren / GLUT

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ] [ 3 ]
000
30.05.2007, 11:51 Uhr
cmos



Hallo,
ich bin gerade vor ein kleines Problem gestoßen.
Ich möchte Körper, welche mit GLUT erzeugt wurden, texturieren.
Die Textur, sprich das Bitmap, ist schon geladen. Ich möchte jetzt nur
noch die Textur auf den Körper legen. In verschiedenen Tutorials steht auch
beschrieben wie man texturen mapped, allerdings wurden dort die
Körper z.B. mit GL_QUADS erzeugt und im Anschluss die Textur daraufgelegt.
Bei GLUT hat man ja aber nur einen Befehl, glSolidCube( , ). Wie kann ich da drauf eine Textur legen ?
Muss ich mir jetzt selber Gedanken darüber machen wo ich die Koordinaten herbekomme ?

Grüße,
cmos
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
30.05.2007, 12:34 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


Wenn ichs richtig in Errinnerung habe erzeugt GLUT die Texturkoordinaten - also einfach glEnable(GL_TEXTURE_2D) und dann glBindTexture(...) - dann glutSolidCube(...)
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
30.05.2007, 13:38 Uhr
cmos



Also entweder ist meine Textur nicht geladen oder das was du geschrieben hast geht doch nicht

ich rufe schon im Konstruktor
loadTexture("G\wood.bmp",&wood); auf (das ist ein G Doppelpunkt Doppelbackslash)
wood ist ein privater Member ( GLuint wood );
Habe eine Fläche erzeugt mit GL_QUADS und dann dort versucht eine Textur drauf zulegen.
Ich hab noch was von einer AUX Library gehört, aber die kann nur 64x64 Pixelgroße Texturen laden (?)


C++:
bool COGLTree::loadTexture(CString sFilename, GLuint *pTexName)
{
    //load Bitmap from File
    HBITMAP hBmp = (HBITMAP) ::LoadImage(NULL,                                  
        /*(LPCTSTR)*/ sFilename.GetString(),              //filename
                                         IMAGE_BITMAP,                       //format hint
                                         0, 0,                             //whole bitmap
                                         LR_LOADFROMFILE |                 //load format
                                         LR_CREATEDIBSECTION);             //

    if (hBmp == NULL)
    {
        return FALSE;  
    }

    BITMAP BM;                          // Get bitmap info.
    ::GetObject (hBmp,sizeof (BM),&BM); //
    if (BM.bmBitsPixel != 24)           // 24Bit-Bitmap?
    {
        return FALSE;                     // UNBRAUCHBAR
    }

    if (!*pTexName)                 //Textur schon vorhanden?
    {    
        glGenTextures(1, pTexName);   //Nein, dann Namen gen.
    }
    else
    {
        return FALSE;              //Ja, keine Doppeldef´s;
    }

    ::glBindTexture(GL_TEXTURE_2D,*pTexName);//Textur speich.
    ::glPixelStorei(GL_UNPACK_ALIGNMENT,4);  //Pixelablageart
    ::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);//0-gesamte Textur
    ::glPixelStorei(GL_UNPACK_SKIP_ROWS,  0);//0-gesamte Textur
    ::glPixelStorei(GL_UNPACK_SKIP_PIXELS,0);//0-gesamte Textur
    
    ::glTexParameteri(GL_TEXTURE_2D,         //Textur Parameter
                      GL_TEXTURE_MAG_FILTER,
                      GL_LINEAR
                     );   //alt.GL_NEAREST);
    
    ::glTexParameteri(GL_TEXTURE_2D,
                      GL_TEXTURE_MIN_FILTER,
                      GL_LINEAR
                     );   //alt.GL_NEAREST);

    ::glTexParameteri(GL_TEXTURE_2D,
                      GL_TEXTURE_WRAP_S,
                      GL_REPEAT
                     );       //alt. GL_CLAMP
    ::glTexParameteri(GL_TEXTURE_2D,
                      GL_TEXTURE_WRAP_T,
                      GL_REPEAT
                     );       //alt. GL_CLAMP

    //define texture environment
    ::glTexEnvf(GL_TEXTURE_ENV,
                GL_TEXTURE_ENV_MODE,
                GL_REPLACE);    //Ersetzmodus

    //build texture MIPMAP
    ::gluBuild2DMipmaps(GL_TEXTURE_2D,      
                        3,
                        BM.bmWidth, BM.bmHeight,  
                        GL_BGR_EXT,
                        GL_UNSIGNED_BYTE,
                        BM.bmBits  
                       );
  
    ::glBindTexture(GL_TEXTURE_2D, 0);

    return TRUE;

}


Dieser Post wurde am 30.05.2007 um 13:38 Uhr von cmos editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
30.05.2007, 16:14 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


Hi,
ohne spezielle non-power-of-two-extension kannst du immer nur quadratische texturen laden.
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
30.05.2007, 17:53 Uhr
cmos



Hallo, die Texturen sind quadratisch und gehören auch einer 2er Potenz an...
Und 24Bit Bitmap sollten sie auch sein, ich habs im Paintbrush in 24Bit BMP Format gespeichert


grüße, cmos
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
30.05.2007, 18:39 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


ah ich seh den fehler:


C++:
::glBindTexture(GL_TEXTURE_2D, 0);



damit wählste ja die textur wieder ab
d.h du musst beim zeichnen vorher schon glBindTexture aufrufen.
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
30.05.2007, 20:31 Uhr
cmos



Hallo,
diese Methode soll ja nur die Textur laden, für das jeweilige Objekt.
Eine Zeichen-Methode ist auch noch in dieser Klasse COGLTree enthalten.
Sollte ich dieses

C++:
::glBindTexture(GL_TEXTURE_2D, 0);



rausnehmen ?

Ich rufe es ja quasi auch bei der Zeichenfunktion auf.
allerdings nur so,

C++:
::glBindTexture(GL_TEXTURE_2D);

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
31.05.2007, 00:23 Uhr
cmos



Hallo,
also das Problem scheint woanders zu liegen.


C++:
::GetObject (hBmp,sizeof (BM),&BM); //




Das liefert mir immer falsche Werte bzw. sind sie alle vertauscht (?)
Habe im Debug Modus mal nachgesehen.


Code:
bmType = irgendeine Zahl
bmWidth = 0
bmHeight = 64
bmWidthBytes = 64
bmBitsPixel = 0




Also bei mir scheint diese Methode nicht zu klappen. Habe auchmal LiadBitmap probiert anstelle von LoadImage. Ich habe die Zeilen mal mit denen von nem Freund abgeglichen.
Bis ::GetObject ... ist es identisch. Bei ihm stimmt die BM Struktur .. nur bei mir nicht.
Da is doch waas faul ?

Grüße,
cmos

Dieser Post wurde am 31.05.2007 um 11:56 Uhr von FloSoft editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
31.05.2007, 01:02 Uhr
cmos



So, das lag daran, das ich damals beim Projekterstellen eine Win32 Konsolenanwendung ausgewählt habe. Irgendwie konnte dann nicht richtig das Bitmap geladen werden,...
Jetzt hab ich s geändert und die BITMAP Struktur hat auch die richtigen Informationen.
Aber eine Textur wird noch nicht angezeigt

Grüße und gute Nacht,
cmos
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
31.05.2007, 11:58 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


Hi,
du musst beim Erstellen glEnable(GL_TEXTURE_2D) auch schon angeben (außer du hast das schon woanders gemacht)
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ] [ 3 ]     [ OpenGL ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: