OpenGL Textur Zylinder Problem

Question

Ich bin ein bisschen verwirrt.

Ich will einen „Zylinder“ strukturieren, so dass mein erster Ansatz war (mit n der Anzahl der Flächen und die Anzahl der Iteration k)

void cylindrer(double r, int n,double h){ 
    double x[n],y[n]; 
    for(int k=0; k<n; k++){ 
     x[k]=r*cos(2*k*M_PI/n); 
     y[k]=r*sin(2*k*M_PI/n); 
    } 


    glEnable(GL_TEXTURE_2D); 
    glBindTexture(GL_TEXTURE_2D, texObject[1]); 

    for(int k=0; k<n ;k++){ 
     int m= (k+1)%n; 

     glBegin(GL_POLYGON); 
      glTexCoord2f(1.0/n*(k),0.0); glVertex3f(x[k], y[k], h/2); 
      glTexCoord2f(1.0/n*(k),1); glVertex3f(x[k], y[k], -h/2); 
      glTexCoord2f(1.0/n*(k+1),1); glVertex3f(x[m], y[m], -h/2); 
      glTexCoord2f(1.0/n*(k+1),0.0); glVertex3f(x[m], y[m], h/2); 
     glEnd(); 
    } 
    glDisable(GL_TEXTURE_2D); 
} 

Die Textur angewandt wird, sondern umgekehrt, so würde ich geändert

glBegin(GL_POLYGON); 
    glTexCoord2f(1.0/n*(n-k), 0.0); glVertex3f(x[k], y[k], h/2); 
    glTexCoord2f(1.0/n*(n-k), 1.0); glVertex3f(x[k], y[k], -h/2); 
    glTexCoord2f(1.0/n*(n-k-1), 1.0); glVertex3f(x[m], y[m], -h/2); 
    glTexCoord2f(1.0/n*(n-k-1), 0.0); glVertex3f(x[m], y[m], h/2); 
glEnd(); 

und es funktioniert und wie folgt aussehen:

wenn ich diese Textur:

Aber jetzt will ich die Textur von 90 Grad drehen, so dass ich schaffen sie eine neue JPEG-Datei und drehen.

So ist die Textur nun so aussehen:

Aber das ist das Ergebnis, wenn ich es verwenden:

Die Textur um den Zylinder verdreht ist, und ich don verstehe nicht warum.

Irgendeine Idee?

Wie ich Textur laden:

#include <math.h> 
#include <jpeglib.h> 
#include <jerror.h> 

GLuint texObject[2]; // textures 

int main(int argc,char **argv){ 
    glutInit(&argc,argv); 
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); 
    glutInitWindowPosition(200,200); 
    glutInitWindowSize(1366,768); 
    glutCreateWindow(""); 

    glClearColor(0.0,0.0,0.0,0.0); 
    //glColor3f(1.0,1.0,1.0); 
    glShadeModel(GL_FLAT); 
    glPointSize(2.0); 
    glEnable(GL_DEPTH_TEST); 

    glGenTextures(2, texObject); 

    loadJpegImage("./textureCorps5.jpg", 1); 

    glutMainLoop(); 
    return 0; 
} 


void loadJpegImage(char *fichier, int i) 
{ 
    struct jpeg_decompress_struct cinfo; 
    struct jpeg_error_mgr jerr; 
    FILE *file; 
    unsigned char *ligne; 

    cinfo.err = jpeg_std_error(&jerr); 
    jpeg_create_decompress(&cinfo); 
    #ifdef __WIN32 
     if (fopen_s(&file,fichier,"rb") != 0) 
     { 
      fprintf(stderr,"Error\n"); 
      exit(1); 
     } 
    #elif __GNUC__ 
     if ((file = fopen(fichier,"rb")) == 0) 
     { 
      fprintf(stderr,"Error\n"); 
      exit(1); 
     } 
    #endif 
    jpeg_stdio_src(&cinfo, file); 
    jpeg_read_header(&cinfo, TRUE); 

    unsigned char image[cinfo.image_width*cinfo.image_height*3]; 

    jpeg_start_decompress(&cinfo); 
    ligne=image; 
    while (cinfo.output_scanline<cinfo.output_height) 
    { 
     ligne=image+3*cinfo.image_width*cinfo.output_scanline; 
     jpeg_read_scanlines(&cinfo,&ligne,1); 
    } 
    jpeg_finish_decompress(&cinfo); 
    jpeg_destroy_decompress(&cinfo); 


    glBindTexture(GL_TEXTURE_2D, texObject[i]); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, cinfo.image_width, cinfo.image_height, 0, 
       GL_RGB, GL_UNSIGNED_BYTE, image); 
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
} 

Answer 1

GL_UNPACK_ALIGNMENT legt die Ausrichtungsanforderungen für den Beginn jeder Pixelreihe im Speicher. Standardmäßig ist GL_UNPACK_ALIGNMENT auf 4 gesetzt. Das bedeutet, dass jede Zeile der Textur eine Länge von 4 * N Bytes haben soll.

Ihre Textur ist eine RGB-Textur, die 24 Bits oder 3 Bytes für jedes Texel benötigt und Sie die Texel und insbesondere die Linien der Textur dicht gepackt haben. Dies bedeutet, dass Sie die Ausrichtung von 4 für den Anfang einer Linie der Textur ignorieren können (Außer 3 mal ist die Breite der Textur durch 4 teilbar, ohne dass eine übrig bleibt).

Um damit umzugehen, müssen Sie die Ausrichtung auf 1 ändern. Das bedeutet, dass Sie glPixelStorei(GL_UNPACK_ALIGNMENT, 1); vor glTexImage2D festlegen müssen, um eine dicht gepackte Textur zu lesen.

Andernfalls erhalten Sie beim Lesen der Textur einen Offset pro Zeile von 0-3 Bytes. Dies verursacht eine kontinuierlich verdrehte Textur.

Stattdessen können Sie kümmern sich um die Ausrichtung übernehmen und die ausgerichtete Länge einer Linie, wenn Sie die gedrehte Textur erstellen, zu:

int bytesPerLine = cinfo.image_width * 3; 
bytesPerLine += bytesPerLine % 4; 

unsigned char image[bytesPerLine * cinfo.image_height]; 

jpeg_start_decompress(&cinfo); 
while (cinfo.output_scanline<cinfo.output_height) 
{ 
    ligne = image + bytesPerLine*cinfo.output_scanline; 
    jpeg_read_scanlines(&cinfo,&ligne,1); 
} 
jpeg_finish_decompress(&cinfo); 
jpeg_destroy_decompress(&cinfo);