Trama OpenGL spostata leggermente a sinistra quando applicato a un quad

Question

Sono un po 'nuovo a OpenGL e ho riscontrato un problema con l'utilizzo di trame. La texture sembra caricarsi bene, ma quando eseguo il programma, la texture mostra un paio di pixel spostati a sinistra, con la sezione tagliata dallo spostamento che appare sul lato destro. Non so se il problema qui è nel mio caricatore TGA o se è il modo in cui sto applicando la trama al quad.

Ecco il caricatore:

#include "texture.h" 
#include <iostream> 

GLubyte uncompressedheader[12] = {0,0, 2,0,0,0,0,0,0,0,0,0}; 
GLubyte compressedheader[12] = {0,0,10,0,0,0,0,0,0,0,0,0}; 


TGA::TGA() 
{ 

} 

//Private loading function called by LoadTGA. Loads uncompressed TGA files 
//Returns: TRUE on success, FALSE on failure 
bool TGA::LoadCompressedTGA(char *filename,ifstream &texturestream) 
{ 
return false; 
} 

bool TGA::LoadUncompressedTGA(char *filename,ifstream &texturestream) 
{ 
cout << "G position status:" << texturestream.tellg() << endl; 
texturestream.read((char*)header, sizeof(header));  //read 6 bytes into the file to get the tga header 
width = (GLuint)header[1] * 256 + (GLuint)header[0]; //read and calculate width and save 
height = (GLuint)header[3] * 256 + (GLuint)header[2]; //read and calculate height and save 
bpp = (GLuint)header[4];   //read bpp and save 

cout << bpp << endl; 

if((width <= 0) || (height <= 0) || ((bpp != 24) && (bpp !=32))) //check to make sure the height, width, and bpp are valid 
{ 
    return false; 
} 
if(bpp == 24)   
{ 
    type = GL_RGB; 
} 
else 
{ 
    type = GL_RGBA; 
} 
imagesize = ((bpp/8) * width * height);   //determine size in bytes of the image 
cout << imagesize << endl; 
imagedata = new GLubyte[imagesize];   //allocate memory for our imagedata variable 

texturestream.read((char*)imagedata,imagesize);  //read according the the size of the image and save into imagedata 

for(GLuint cswap = 0; cswap < (GLuint)imagesize; cswap += (bpp/8))   //loop through and reverse the tga's BGR format to RGB 
{ 
    imagedata[cswap] ^= imagedata[cswap+2] ^=     //1st Byte XOR 3rd Byte XOR 1st Byte XOR 3rd Byte 
    imagedata[cswap] ^= imagedata[cswap+2]; 
} 

texturestream.close();    //close ifstream because we're done with it 
cout << "image loaded" << endl; 

glGenTextures(1, &texID);    // Generate OpenGL texture IDs 
glBindTexture(GL_TEXTURE_2D, texID);   // Bind Our Texture 
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Linear Filtered 
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
glTexImage2D(GL_TEXTURE_2D, 0, type, width, height, 0, type, GL_UNSIGNED_BYTE, imagedata); 



    delete imagedata; 
return true; 
} 

//Public loading function for TGA images. Opens TGA file and determines 
//its type, if any, then loads it and calls the appropriate function. 
//Returns: TRUE on success, FALSE on failure 

bool TGA::loadTGA(char *filename) 
{ 
cout << width << endl; 
ifstream texturestream; 
texturestream.open(filename,ios::binary); 
texturestream.read((char*)header,sizeof(header));  //read 6 bytes into the file, its the header.    //if it matches the uncompressed header's first 6 bytes, load it as uncompressed 
LoadUncompressedTGA(filename,texturestream); 
return true; 
} 

GLubyte* TGA::getImageData() 
{ 
return imagedata; 
} 

GLuint& TGA::getTexID() 
{ 
return texID; 
} 

Ed ecco il quad:

void Square::show() 
{  

glEnable(GL_TEXTURE_2D); 
glBindTexture(GL_TEXTURE_2D, texture.texID); 


    //Move to offset 
    glTranslatef(x, y, 0); 

//Start quad 
    glBegin(GL_QUADS); 

//Set color to white 
glColor4f(1.0, 1.0, 1.0, 1.0); 

//Draw square 
glTexCoord2f(0.0f, 0.0f); glVertex3f(0,   0,    0); 
glTexCoord2f(1.0f, 0.0f); glVertex3f(SQUARE_WIDTH, 0,    0); 
glTexCoord2f(1.0f, 1.0f); glVertex3f(SQUARE_WIDTH, SQUARE_HEIGHT, 0); 
glTexCoord2f(0.0f, 1.0f); glVertex3f(0,   SQUARE_HEIGHT, 0); 

    //End quad 
    glEnd(); 

    //Reset 
glLoadIdentity(); 
} 

Answer 1

Uno screenshot sarebbe molto utile.
La mia prima ipotesi è che le righe non siano allineate a 4 byte. In tal caso, modificare l'allineamento della confezione a 1 byte con glPixelStorei(GL_UNPACK_ALIGNMENT, 1); prima di chiamare glTexImage2D().

Answer 2

Si desidera impostare il parametro di trama in modo che la trama si riduca per adattarsi al quad. Lo fai con le seguenti linee di codice:

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 

Questi avranno trame di scala linearmente su o giù per adattarsi al quad.

Probabilmente si dovrebbe anche bloccare il tessuto con le seguenti chiamate:

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);