4. OpenGL Texturen Laden und Zeichnen im Allgemeinen

OpenGL Texturen Laden und Zeichnen im Allgemeinen

  • L
     

    GLuint tex;

//Draw:
glBindTexture(GL_TEXTURE_2D,tex);

//Aufruf von s.u.:
LadeTex("test.tga", tex);

//textur laden:
void LadeTex(std::string datei, GLuint &ziel)
{
  std::fstream test;
  //Load texture from file, and build all mipmap levels
  test.open(datei.c_str());
  if (!test)
  {
    logdatei << "Fehler:\n \"" << datei << "\" fehlt!" << std::endl;
    glfwTerminate();
    exit(-3);
  }
  test.close();
  test.clear();

  glGenTextures(1, &ziel);
  glBindTexture(GL_TEXTURE_2D, ziel);

  // Load texture from file, and build all mipmap levels
  if (!glfwLoadTexture2D(datei.c_str(), GLFW_BUILD_MIPMAPS_BIT))
  {
    logdatei << "Fehler:\n \"" << datei
    <<"\" konnte nicht geladen werden!" << std::endl;
    glfwTerminate();
    exit(-2);
  }
  // Use trilinear interpolation for minification
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                 GL_LINEAR_MIPMAP_LINEAR );
  // Use bilinear interpolation for magnification
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                 GL_LINEAR );
  logdatei << " \"" << datei << "\" geladen!" << std::endl;
}

    Ich mein so war's... 🙄

    0
  • M

    Danke sehr, ich habe jetzt eine wunderschöne Funktion zusammengewerkelt, die mir Texturen lädt. Vielen dank für die Vorlage. 🙂

    Nun fehlt mir nur noch eine Antwort auf die erste Frage. Ich konnte bisher noch nichts handgreifliches dazu finden. *seufz*

    0
  • B

    Was meinst du mit starr zum Nullpunkt zeichnen?

    Ich würde aber eigentlich Translate vorziehen, da du dabei die Vertexdaten nicht ändern musst. Erleichter den Einsatz von Vertexlisten. (Heißen die so? ^^ Ich meine diese Liste in denen man die ganzen Aufrufe speichert um schneller rendern zu können)

    0
  • M

    Gut..ich habe selber die Erkenntnis erlangt das translate besser ist..allerdings komme ich damit durcheinander...
    Durch das Translatieren wird sozusagen der Nullpunkt verschoben nicht wahr? Oder mehr der Punkt an dem ich Zeichne verschiebt sich auf den Axen über die vorgegebenen Werte.
    Allerdings kriege ich es partout nicht hin erst einen sich drehenden Cube am Nullpunkt zu zeichnen und dann eine Art "Wand" Dahinter. (Ein texturiertes Quad)

    Wenn mir jemand zeigen könnte wie genau der Ablauf dieser Zeichenverläufe sein muss, wäre ich sehr dankbar. (Btw: Für das Rotieren nutze ich glRotate() )
    Pseudocode würde mir schon reichen.. >_<

    0
  • L

    Google mal nach "glPopMatrix()", "glPushMatrix()" und "glLoadIdentity"... 😉

    0
  • M

    glloadIdenty benutze ich, brachte mir allerdings leider nicht den erhofften Erfolg.
    Die matrixfunktionen kannte ich bisher noch nicht..ich sollte mal wieder meine Googlesuchen optimieren. >_<

    Danke schoneinmal, ich werde sie mal anschauen und testen.

    Nun gut:

    Ich resete also erstmal die Modelview Matrx per glLoadIdentity();. Dann rufe ich glPushMatrix() auf, translatiere und schieb sie anschließend per glPopMatrix() auf den Stack. Das gleiche Spiel wiederholt sich immer wieder, richtig?

    Ich schätze das ich alles grundlegend Missverstanden habe, denn es will immernoch nicht arbeiten. Ich würde jetzt gerne erzählen was nicht funktioniert, aber ich weiß es leider selber nicht. >_<

    0
  • M

    Gut, ich habe es versucht, aber - wie es scheint - kläglich versagt.

    Zuersteinmal die Funktion:

    bool bk_draw::drawCubeT(float pos[2], float s[5][3][2], GLuint tex) {
  glPushMatrix();
      glTranslatef(pos[0],pos[1],pos[2]);
      glBindTexture(GL_TEXTURE_2D,tex);
      glBegin(GL_QUADS); // vordere Seite  
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-s[0][0][0],-s[0][0][1], s[0][0][2]); // Unten links der Textur und des Quadrats  
        glTexCoord2f(1.0f, 0.0f); glVertex3f( s[0][1][0],-s[0][1][1], s[0][1][2]); // Unten rechts der Textur und des Quadrats  
        glTexCoord2f(1.0f, 1.0f); glVertex3f( s[0][2][0], s[0][2][1], s[0][2][2]); // Oben rechts der Textur und des Quadrats  
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-s[0][3][0], s[0][3][1], s[0][3][2]); // Oben links der Textur und des Quadrats  
        // hintere Seite  
        glTexCoord2f(1.0f, 0.0f); glVertex3f(-s[1][0][0],-s[1][0][1], -s[1][0][2]); // Unten rechts der Textur und des Quadrats  
        glTexCoord2f(1.0f, 1.0f); glVertex3f(-s[1][1][0], s[1][1][1], -s[1][1][2]); // Oben rechts der Textur und des Quadrats  
        glTexCoord2f(0.0f, 1.0f); glVertex3f( s[1][2][0], s[1][2][1], -s[1][2][2]); // Oben links der Textur und des Quadrats  
        glTexCoord2f(0.0f, 0.0f); glVertex3f( s[1][3][0],-s[1][3][1], -s[1][3][2]); // Unten links der Textur und des Quadrats 
        // obere Seite  
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-s[2][0][0], s[2][0][1],-s[2][0][2]); // Oben links der Textur und des Quadrats  
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-s[2][1][0], s[2][1][1], s[2][1][2]); // Unten links der Textur und des Quadrats  
        glTexCoord2f(1.0f, 0.0f); glVertex3f( s[2][2][0], s[2][2][1], s[2][2][2]); // Unten rechts der Textur und des Quadrats  
        glTexCoord2f(1.0f, 1.0f); glVertex3f( s[2][3][0], s[2][3][1],-s[2][3][2]); // Oben rechts der Textur und des Quadrats  
        // untere Seite  
        glTexCoord2f(1.0f, 1.0f); glVertex3f(-s[3][0][0], -s[3][0][1],-s[3][0][2]); // Oben rechts der Textur und des Quadrats  
        glTexCoord2f(0.0f, 1.0f); glVertex3f( s[3][1][0], -s[3][1][1],-s[3][1][2]); // Oben links der Textur und des Quadrats  
        glTexCoord2f(0.0f, 0.0f); glVertex3f( s[3][2][0], -s[3][2][1], s[3][2][2]); // Unten links der Textur und des Quadrats  
        glTexCoord2f(1.0f, 0.0f); glVertex3f(-s[3][3][0], -s[3][3][1], s[3][3][2]); // Unten rechts der Textur und des Quadrats  
        // rechte Seite  
        glTexCoord2f(1.0f, 0.0f); glVertex3f( s[4][0][0],-s[4][0][1],-s[4][0][2]); // Unten rechts der Textur und des Quadrats  
        glTexCoord2f(1.0f, 1.0f); glVertex3f( s[4][1][0], s[4][1][1],-s[4][1][2]); // Oben rechts der Textur und des Quadrats  
        glTexCoord2f(0.0f, 1.0f); glVertex3f( s[4][2][0], s[4][2][1], s[4][2][2]); // Oben links der Textur und des Quadrats  
        glTexCoord2f(0.0f, 0.0f); glVertex3f( s[4][3][0],-s[4][3][1], s[4][3][2]); // Unten links der Textur und des Quadrats  
        // linke Seite  
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-s[5][0][0],-s[5][0][1],-s[5][0][2]); // Unten links der Textur und des Quadrats  
        glTexCoord2f(1.0f, 0.0f); glVertex3f(-s[5][1][0],-s[5][1][1], s[5][1][2]); // Unten rechts der Textur und des Quadrats  
        glTexCoord2f(1.0f, 1.0f); glVertex3f(-s[5][2][0], s[5][2][1], s[5][2][2]); // Oben rechts der Textur und des Quadrats  
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-s[5][3][0], s[5][3][1],-s[5][3][2]); // Oben links der Textur und des Quadrats  
      glEnd();
    glPopMatrix();

  return true;
}

    Das ganze ist eine der Funktionen der Klasse bk_draw.

    draw.drawCubeT(pos, arr, tex);
draw.drawCubeT(pos2, arr2, tex);

    Sind die Aufrufe der Funktion.

    arr und arr2 erstelle ich dabei ganz simpel mit einer Funktion. (Die füllt mir einfach das Array^^)

    void bk_draw::createCubeArray(float length, float (*destination)[5][3][2]) {
  int i=0,j=0,k=0;
  for(i=0;i<6;i++) {
    for(j=0;j<4;j++) {
      for(k=0;k<3;k++) {
        (*destination)[i][j][k]=length;
      }
    }
  }
}

    Pos und Pos2:

    float pos[2];
    pos[0]=0;
    pos[1]=-0.4;
    pos[2]=0;

float pos2[2];
    pos[0]=0;
    pos[1]=0.2;
    pos[2]=0;

    Allerdings zeichnet er scheinbar nur einen der Cudes...>_<

    Entdeckt jemand einen gröberen Denkfehler? >_<

    0
  • T

    makkurona schrieb:

    float pos[2];

    So erstellst du ein Array mit der Größe 2. Es beginnt bei dem Index 0 und endet bei dem Index 2-1.

    0
  • M

    verstehe..><
    Ich werdes mal prüfen.. ich wusste ich hab was verwechselt. (Ich bin von damals an PHP gewöhnt.>    >)

    0
  • M

    Ich bin am verzweifeln und einige von euch werden sich wahrscheinlich atm denken "Was für ein DAE." (DAE = Dümmster anzunehmender Entwickler)

    Nun gut, ich habe alles umgestellt und soweit mir möglich versucht zu verstehen und selbst zu erarbeiten. Google war eine große Hilfe aber bei individuellen Dummheitsfehlern, für dessen Ursache man zwar verantwortlich ist, dessen Lösungsweg aber gänzlich unbekannt.. nunja, denkt euch den Rest.

    Mein Problem ist: Ich kriege einfach nichts auf den Screen! Seit ich noch glScalef() nutze funktioniert gar nichts mehr.
    Nunja, fangen wir an mit den Codeausschnitten:

    bool bk_draw::drwDrawCubeT(float pos[3], float s[6][4][3], GLuint tex) {
  glPushMatrix();
      glScalef(float(1/this->xwidth),float(1/this->ywidth), float(1/this->ywidth));
      glTranslatef(pos[0],pos[1],pos[2]);
      glBindTexture(GL_TEXTURE_2D,tex);
      glBegin(GL_QUADS); // vordere Seite  
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-s[0][0][0],-s[0][0][1], s[0][0][2]); // Unten links der Textur und des Quadrats  
        glTexCoord2f(1.0f, 0.0f); glVertex3f( s[0][1][0],-s[0][1][1], s[0][1][2]); // Unten rechts der Textur und des Quadrats  
        glTexCoord2f(1.0f, 1.0f); glVertex3f( s[0][2][0], s[0][2][1], s[0][2][2]); // Oben rechts der Textur und des Quadrats  
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-s[0][3][0], s[0][3][1], s[0][3][2]); // Oben links der Textur und des Quadrats  

[...]

    glEnd();
  glPopMatrix();

  return true;
}

    Wie man sieht habe ich die ganzen Quads der Übersichtshalber herausgenommen.

    bk_draw* draw;
draw=new bk_draw(1024, 768, 0);
draw->drwSetScreenScale(1024, 768, 0);
bk_tex.texLoadTexturD("textur/", text);
draw->drwCreateCubeArray(100.0f,&arr);

    Ist meine Initialisierung des Drawobjektes und einiger Parameter die man später benötigt. Dabei werden auch die drei Membereigenschaften von bk_draw gesetzt. (xwidth, ywidth, zwidth)

    Das Zeichnen:

    float pos[3];
pos[0]=0;
pos[1]=-60.0;
pos[2]=0;
float pos2[3];
pos[0]=0;
pos[1]=20.0;
pos[2]=-3;

draw->drwDrawCubeT(pos, arr, tex);
draw->drwDrawCubeT(pos2, arr, tex);

    Arr und Tex werden per Funktionsparameter übergeben, sind also existent und funktional.

    **
    Wiedereinmal die Frage: Sieht jemand, der sich besser mit der Materie auskennt einen Fehler?
    Wie schon erwähnt, ich bin bsiher nciht in der Lage ihn, oder auch sie, auszumachen. Auch langes Suchen brachte mich nicht weiter.**

    0
  • W

    Könnte es daran liegen

    0
  • M

    Eigentlich nicht, ich habe das glSwapBuffers() mit drinne.

    while(running)
{
	display(text.at(10),draw,0.0,0.0,0.0);
	glfwSwapBuffers();
	running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
}

    Edit: Bei Bedarf kann ich auch das gesamte Projekt zum Doanload bereitstellen.
    Ich finde immer noch keinen fehler..ob direkt oder indirekt..>_<

    0
  • H
     

    void bk_draw::createCubeArray(float length, float (*destination)[5][3][2]) {
  int i=0,j=0,k=0;
  for(i=0;i<6;i++) {
    for(j=0;j<4;j++) {
      for(k=0;k<3;k++) {
        (*destination)[i][j][k]=length;
      }
    }
  }
}

    ja und jetzt sind alle deine eckpunkte an der position (length, length, length) ?...

    0
  • M

    Siehe Zeichenroutine. Das ganze läuft über die Funktion. Man selbst muss nur die Länge angeben.
    So war es zumidnest gedacht, oder habe ich da einen Denkfehler bei der Minussetzung?

    0
Anmelden zum Antworten