title: Why is my openGL texture only covering half of my quad? Source included
body: <p>Here is my code. I'm attempting to draw a simple quadrilateral, and place a checkerboard pattern on both sides of it. I want to allow the user to rotate around this piece with the mouse. Everything works fine, other than the texture - it is slanted, and only covers about half of the quad. Can anyone see something glaringly obvious that I am doing wrong? Thanks.</p>
  
  <pre><code>#include "glut-3.7.6-bin\glut.h"
  
  // Constants for rotating camera
  #define CAMERA_RELEASE 0
  #define CAMERA_ROTATE 1
  #define CAMERA_ZOOM 2
  
  // Current camera control setting
  int cameraSetting;
  
  // Current viewing angle and scale of the scene
  float viewAngleX, viewAngleY, scaleFactor = 1.0;
  
  // Click coordinates
  int clickX, clickY;
  
  // Screen size
  const int screenWidth = 600;
  const int screenHeight = 600;
  
  // Texture data
  GLuint texture;
  
  ////////////////////////////////////////////////////////////////
  //      Function Prototypes
  ////////////////////////////////////////////////////////////////
  
  GLuint loadTexture(const char * filename);
  
  ////////////////////////////////////////////////////////////////
  //      Callback and Initialization Functions
  ////////////////////////////////////////////////////////////////
  
  void callbackMouse(int button, int state, int x, int y)
  {
      if (state == GLUT_DOWN)
      {
          // Store clicked coordinates
          clickX = x;
          clickY = y;
  
          // Set camera mode to rotate
          if (button == GLUT_LEFT_BUTTON)
          {
              cameraSetting = CAMERA_ROTATE;
          } 
          // Set camera mode to zoom
          else if (button == GLUT_RIGHT_BUTTON) 
          {
              cameraSetting = CAMERA_ZOOM;
          }
      }
      // Ignore camera commands if no button is clicked
      else if (state == GLUT_UP)
      {
          cameraSetting = CAMERA_RELEASE;
      }
  }
  
  void callbackKeyboard(unsigned char key, int x, int y)
  {
      if (key == 'q') {
          exit(0);
      }
  
  }
  
  void callbackMotion(int x, int y)
  {
      if (cameraSetting == CAMERA_ROTATE)
      {
          // Camera rotate setting - adjust the viewing angle by the direction of motion
          viewAngleX += (x - clickX) / 5.0;
          viewAngleX = viewAngleX &gt; 180 ? (viewAngleX - 360) : (viewAngleX &lt; - 180 ? (viewAngleX + 360) : viewAngleX);
          clickX = x;
  
          viewAngleY += (y - clickY) / 5.0;
          viewAngleY = viewAngleY &gt; 180 ? (viewAngleY - 360) : (viewAngleY &lt; - 180 ? (viewAngleY + 360) : viewAngleY);
          clickY = y;
      }
      else if (cameraSetting == CAMERA_ZOOM)
      {
          // Polygonal scale to simulate camera zoom
          float currentScaleFactor = scaleFactor;
  
          scaleFactor *= (1+ (y - clickY) / 60.0);
  
          scaleFactor = scaleFactor &lt; 0 ? currentScaleFactor : scaleFactor;
  
          clickY = y;
      }
  
      glutPostRedisplay();
  }
  
  void callbackDisplay()
  {
      // Clear the screen
      glEnable(GL_DEPTH_TEST);
      glClearColor(0, 0, 0, 0);
      glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  
      // Set world window
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      gluPerspective(60, 1, 1, 100);
  
      // Setup 3D environment
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();
  
      gluLookAt(0,0,5,
              0,0,0,
              0,1,0);
  
      // Rotate and scale 3D environment to current user settings
      glRotatef(viewAngleX, 0, 1, 0);
      glRotatef(viewAngleY, 1, 0, 0);
      glScalef(scaleFactor, scaleFactor, scaleFactor);
  
      glBegin(GL_QUADS);
          glTexCoord2d(0.0, 0.0); glVertex3f(-30, -5, -30);
          glTexCoord2d(1.0, 0.0); glVertex3f(30, -5, -30);
          glTexCoord2d(1.0, 1.0); glVertex3f(30, -5, 30);
          glTexCoord2d(0.0, 1.0); glVertex3f(-30, -5, 30);
      glEnd();
  
      // Swap frame buffers
      glutSwapBuffers();
  }
  
  void windowInitialization() {
  
      // Enable textures by default
      glEnable(GL_TEXTURE_2D);
  
      // Load texture
      texture = loadTexture("checkerboard.raw");
  
      glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
  
  }
  
  ////////////////////////////////////////////////////////////////
  //      Main
  ////////////////////////////////////////////////////////////////
  
  int main(int argc, char** argv)
  {   
      // GLUT Initialization
      glutInit(&amp;argc, argv); 
      glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH); 
      glutInitWindowSize(screenWidth,screenHeight); 
  
      // Create main window
      glutCreateWindow("Test"); 
      windowInitialization();
  
      // Register callback functions
      glutDisplayFunc(callbackDisplay); 
      glutMouseFunc(callbackMouse); 
      glutMotionFunc(callbackMotion);
      glutKeyboardFunc(callbackKeyboard); 
  
      // Enter event processing loop
      glutMainLoop(); 
  
  }
  
  ////////////////////////////////////////////////////////////////
  //      Prototyped Functions
  ////////////////////////////////////////////////////////////////
  
  GLuint loadTexture(const char * filename)
  {
      GLuint texture;
      int width, height;
      BYTE * data;
      FILE * file;
  
      // open texture data
      file = fopen( filename, "rb" );
      if ( file == NULL ) return 0;
  
      // allocate buffer
      width = 256;
      height = 256;
      data = (BYTE *) malloc( width * height * 3 );
  
      // read texture data
      fread( data, width * height * 3, 1, file );
      fclose( file );
  
      glGenTextures( 1, &amp;texture );
      glBindTexture( GL_TEXTURE_2D, texture );
  
      glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
  
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
  
      // texture wraps over at the edges
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 1 );
      glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 1);
  
      // build texture
      gluBuild2DMipmaps( GL_TEXTURE_2D, 3, width, height,
                         GL_RGB, GL_UNSIGNED_BYTE, data );
  
      // free buffer
      free( data );
  
      return texture;
  }
  </code></pre>
  
  <p><img src="https://i.stack.imgur.com/RARS0.png" alt="half-covered,distorted"></p>