opegnl LoadBMP or texture 2 sphere

This is a discussion on opegnl LoadBMP or texture 2 sphere within the Game Programming forums, part of the General Programming Boards category; aynone knows why it does not display the texture on the sphere? Code: GLunit TextureArray[6]; glGenTextures(1, &TextureArray[1]); glBindTexture(GL_TEXTURE_2D, TextureArray[1]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); ...

  1. #1
    Registered User
    Join Date
    Sep 2009
    Posts
    37

    opegnl LoadBMP or texture 2 sphere

    aynone knows why it does not display the texture on the sphere?


    Code:
    GLunit TextureArray[6];
    
    	glGenTextures(1, &TextureArray[1]);
    		glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
    		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
    		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
    	glTexImage2D(GL_TEXTURE_2D, 0, 3, image->width, image->height, 0,
    					GL_RGB, GL_UNSIGNED_BYTE, image->data);


    Code:
     quadratic=gluNewQuadric();
    	glBindTexture(GL_TEXTURE_2D, 1);
    	gluQuadricDrawStyle(quadratic,GLU_FILL);
    	gluSphere(quadratic,6, 15 ,40);
    gluQuadricTexture(quadratic, GL_TRUE);
    Last edited by punkywow; 10-12-2009 at 01:59 AM.

  2. #2
    Intranasal Heroin User Xterria's Avatar
    Join Date
    Sep 2001
    Location
    Buffalo, NY
    Posts
    1,035
    I'm not sure if what you posted is the faulty code, but I will throw my two cents in by saying you shouldn't be using the old LoadBMP code that comes with Glaux. I would assume you're still using the LoadBMP() from the old Glaux library and not the replacement code for it(Glaux is rarely used these days). This could be why the texture isn't on the sphere, it might not be loading at all. But in either case, I suggest using TARGA's instead.

    Here, throw this in your project:

    tga.h
    Code:
    #include <iostream>
    #include <fstream>
    #include <memory.h>
    
    #define IMG_OK              0x1
    #define IMG_ERR_NO_FILE     0x2
    #define IMG_ERR_MEM_FAIL    0x4
    #define IMG_ERR_BAD_FORMAT  0x8
    #define IMG_ERR_UNSUPPORTED 0x40
    
    class TGAImg
     {
      public:
       TGAImg();
       ~TGAImg();
       int Load(char* szFilename);
       int GetBPP();
       int GetWidth();
       int GetHeight();
       unsigned char* GetImg();       // Return a pointer to image data
       unsigned char* GetPalette();   // Return a pointer to VGA palette
    
      private:
       short int iWidth,iHeight,iBPP;
       unsigned long lImageSize;
       char bEnc;
       unsigned char *pImage, *pPalette, *pData;
       
       // Internal workers
       int ReadHeader();
       int LoadRawData();
       int LoadTgaRLEData();
       int LoadTgaPalette();
       void BGRtoRGB();
       void FlipImg();
     };
    
    
    TGAImg::TGAImg()
     { 
      pImage=pPalette=pData=NULL;
      iWidth=iHeight=iBPP=bEnc=0;
      lImageSize=0;
     }
    
    
    TGAImg::~TGAImg()
     {
      if(pImage)
       {
        delete [] pImage;
        pImage=NULL;
       }
    
      if(pPalette)
       {
        delete [] pPalette;
        pPalette=NULL;
       }
    
      if(pData)
       {
        delete [] pData;
        pData=NULL;
       }
     }
    
    
    int TGAImg::Load(char* szFilename)
     {
      using namespace std;
      ifstream fIn;
      unsigned long ulSize;
      int iRet;
    
      // Clear out any existing image and palette
       if(pImage)
        {
         delete [] pImage;
         pImage=NULL;
        }
    
       if(pPalette)
        {
         delete [] pPalette;
         pPalette=NULL;
        }
    
      // Open the specified file
      fIn.open(szFilename,ios::binary);
        
       if(fIn==NULL)
        return IMG_ERR_NO_FILE;
    
      // Get file size
      fIn.seekg(0,ios_base::end);
      ulSize=fIn.tellg();
      fIn.seekg(0,ios_base::beg);
    
      // Allocate some space
      // Check and clear pDat, just in case
       if(pData)
        delete [] pData; 
    
      pData=new unsigned char[ulSize];
    
       if(pData==NULL)
        {
         fIn.close();
         return IMG_ERR_MEM_FAIL;
        }
    
      // Read the file into memory
      fIn.read((char*)pData,ulSize);
    
      fIn.close();
    
      // Process the header
      iRet=ReadHeader();
    
       if(iRet!=IMG_OK)
        return iRet;
    
       switch(bEnc)
        {
         case 1: // Raw Indexed
          {
           // Check filesize against header values
            if((lImageSize+18+pData[0]+768)>ulSize)
             return IMG_ERR_BAD_FORMAT;
    
           // Double check image type field
            if(pData[1]!=1)
             return IMG_ERR_BAD_FORMAT;
    
           // Load image data
           iRet=LoadRawData();
            if(iRet!=IMG_OK)
             return iRet;
    
           // Load palette
           iRet=LoadTgaPalette();
            if(iRet!=IMG_OK)
             return iRet;
    
           break;
          }
    
         case 2: // Raw RGB
          {
           // Check filesize against header values
            if((lImageSize+18+pData[0])>ulSize)
             return IMG_ERR_BAD_FORMAT;
    
           // Double check image type field
            if(pData[1]!=0)
             return IMG_ERR_BAD_FORMAT;
    
           // Load image data
           iRet=LoadRawData();
            if(iRet!=IMG_OK)
             return iRet;
    
           BGRtoRGB(); // Convert to RGB
           break;
          }
    
         case 9: // RLE Indexed
          {
           // Double check image type field
            if(pData[1]!=1)
             return IMG_ERR_BAD_FORMAT;
    
           // Load image data
           iRet=LoadTgaRLEData();
            if(iRet!=IMG_OK)
             return iRet;
    
           // Load palette
           iRet=LoadTgaPalette();
            if(iRet!=IMG_OK)
             return iRet;
    
           break;
          }
     
         case 10: // RLE RGB
          {
           // Double check image type field
            if(pData[1]!=0)
             return IMG_ERR_BAD_FORMAT;
    
           // Load image data
           iRet=LoadTgaRLEData();
            if(iRet!=IMG_OK)
             return iRet;
    
           BGRtoRGB(); // Convert to RGB
           break;
          }
    
         default:
          return IMG_ERR_UNSUPPORTED;
        }
    
      // Check flip bit
       if((pData[17] & 0x20)==0) 
         FlipImg();
    
      // Release file memory
      delete [] pData;
      pData=NULL;
    
      return IMG_OK;
     }
    
    
    int TGAImg::ReadHeader() // Examine the header and populate our class attributes
     {
      short ColMapStart,ColMapLen;
      short x1,y1,x2,y2;
    
       if(pData==NULL)
        return IMG_ERR_NO_FILE;
    
       if(pData[1]>1)    // 0 (RGB) and 1 (Indexed) are the only types we know about
        return IMG_ERR_UNSUPPORTED;
    
       bEnc=pData[2];     // Encoding flag  1 = Raw indexed image
                          //                2 = Raw RGB
                          //                3 = Raw greyscale
                          //                9 = RLE indexed
                          //               10 = RLE RGB
                          //               11 = RLE greyscale
                          //               32 & 33 Other compression, indexed
    
        if(bEnc>11)       // We don't want 32 or 33
         return IMG_ERR_UNSUPPORTED;
    
    
      // Get palette info
      memcpy(&ColMapStart,&pData[3],2);
      memcpy(&ColMapLen,&pData[5],2);
    
      // Reject indexed images if not a VGA palette (256 entries with 24 bits per entry)
       if(pData[1]==1) // Indexed
        {
         if(ColMapStart!=0 || ColMapLen!=256 || pData[7]!=24)
          return IMG_ERR_UNSUPPORTED;
        }
    
      // Get image window and produce width & height values
      memcpy(&x1,&pData[8],2);
      memcpy(&y1,&pData[10],2);
      memcpy(&x2,&pData[12],2);
      memcpy(&y2,&pData[14],2);
    
      iWidth=(x2-x1);
      iHeight=(y2-y1);
    
       if(iWidth<1 || iHeight<1)
        return IMG_ERR_BAD_FORMAT;
    
      // Bits per Pixel
      iBPP=pData[16];
    
      // Check flip / interleave byte
       if(pData[17]>32) // Interleaved data
        return IMG_ERR_UNSUPPORTED;
    
      // Calculate image size
      lImageSize=(iWidth * iHeight * (iBPP/8));
    
      return IMG_OK;
     }
    
    
    int TGAImg::LoadRawData() // Load uncompressed image data
     {
      short iOffset;
     
       if(pImage) // Clear old data if present
        delete [] pImage;
    
      pImage=new unsigned char[lImageSize];
    
       if(pImage==NULL)
        return IMG_ERR_MEM_FAIL;
    
      iOffset=pData[0]+18; // Add header to ident field size
    
       if(pData[1]==1) // Indexed images
        iOffset+=768;  // Add palette offset
    
       memcpy(pImage,&pData[iOffset],lImageSize);
    
      return IMG_OK;
     }
    
    
    int TGAImg::LoadTgaRLEData() // Load RLE compressed image data
     {
      short iOffset,iPixelSize;
      unsigned char *pCur;
      unsigned long Index=0;
      unsigned char bLength,bLoop;
    
      // Calculate offset to image data
      iOffset=pData[0]+18;
    
      // Add palette offset for indexed images
       if(pData[1]==1)
        iOffset+=768; 
    
      // Get pixel size in bytes
      iPixelSize=iBPP/8;
    
      // Set our pointer to the beginning of the image data
      pCur=&pData[iOffset];
    
      // Allocate space for the image data
       if(pImage!=NULL)
        delete [] pImage;
    
      pImage=new unsigned char[lImageSize];
    
       if(pImage==NULL)
        return IMG_ERR_MEM_FAIL;
    
      // Decode
       while(Index<lImageSize) 
        {
          if(*pCur & 0x80) // Run length chunk (High bit = 1)
           {
            bLength=*pCur-127; // Get run length
            pCur++;            // Move to pixel data  
    
            // Repeat the next pixel bLength times
             for(bLoop=0;bLoop!=bLength;++bLoop,Index+=iPixelSize)
              memcpy(&pImage[Index],pCur,iPixelSize);
      
            pCur+=iPixelSize; // Move to the next descriptor chunk
           }
          else // Raw chunk
           {
            bLength=*pCur+1; // Get run length
            pCur++;          // Move to pixel data
    
            // Write the next bLength pixels directly
             for(bLoop=0;bLoop!=bLength;++bLoop,Index+=iPixelSize,pCur+=iPixelSize)
              memcpy(&pImage[Index],pCur,iPixelSize);
           }
        }
     
      return IMG_OK;
     }
    
    
    int TGAImg::LoadTgaPalette() // Load a 256 color palette
     {
      unsigned char bTemp;
      short iIndex,iPalPtr;
      
       // Delete old palette if present
       if(pPalette)
        {
         delete [] pPalette;
         pPalette=NULL;
        }
    
      // Create space for new palette
      pPalette=new unsigned char[768];
    
       if(pPalette==NULL)
        return IMG_ERR_MEM_FAIL;
    
      // VGA palette is the 768 bytes following the header
      memcpy(pPalette,&pData[pData[0]+18],768);
    
      // Palette entries are BGR ordered so we have to convert to RGB
       for(iIndex=0,iPalPtr=0;iIndex!=256;++iIndex,iPalPtr+=3)
        {
         bTemp=pPalette[iPalPtr];               // Get Blue value
         pPalette[iPalPtr]=pPalette[iPalPtr+2]; // Copy Red to Blue
         pPalette[iPalPtr+2]=bTemp;             // Replace Blue at the end
        }
    
      return IMG_OK;
     }
    
    
    void TGAImg::BGRtoRGB() // Convert BGR to RGB (or back again)
     {
      unsigned long Index,nPixels;
      unsigned char *bCur;
      unsigned char bTemp;
      short iPixelSize;
    
      // Set ptr to start of image
      bCur=pImage;
    
      // Calc number of pixels
      nPixels=iWidth*iHeight;
    
      // Get pixel size in bytes
      iPixelSize=iBPP/8;
    
       for(Index=0;Index!=nPixels;Index++)  // For each pixel
        {
         bTemp=*bCur;      // Get Blue value
         *bCur=*(bCur+2);  // Swap red value into first position
         *(bCur+2)=bTemp;  // Write back blue to last position
    
         bCur+=iPixelSize; // Jump to next pixel
        }
    
     }
    
    
    void TGAImg::FlipImg() // Flips the image vertically (Why store images upside down?)
     {
      unsigned char bTemp;
      unsigned char *pLine1, *pLine2;
      int iLineLen,iIndex;
     
      iLineLen=iWidth*(iBPP/8);
      pLine1=pImage;
      pLine2=&pImage[iLineLen * (iHeight - 1)];
    
       for( ;pLine1<pLine2;pLine2-=(iLineLen*2))
        {
         for(iIndex=0;iIndex!=iLineLen;pLine1++,pLine2++,iIndex++)
          {
           bTemp=*pLine1;
           *pLine1=*pLine2;
           *pLine2=bTemp;       
          }
        } 
    
     }
    
    
    int TGAImg::GetBPP() 
     {
      return iBPP;
     }
    
    
    int TGAImg::GetWidth()
     {
      return iWidth;
     }
    
    
    int TGAImg::GetHeight()
     {
      return iHeight;
     }
    
    
    unsigned char* TGAImg::GetImg()
     {
      return pImage;
     }
    
    
    unsigned char* TGAImg::GetPalette()
     {
      return pPalette;
     }
    and in your main cpp file add the prototype and the function itself
    Code:
    bool LoadTexture(char *TexName, GLuint TexHandle);
    
    //.....
    
    // Load a TGA texture
    bool LoadTexture(char *TexName, GLuint TexHandle)
    {
    	TGAImg Img;        // Image loader
    
    	// Load our Texture
    	if(Img.Load(TexName)!=IMG_OK)
    		return false;
    
    	glBindTexture(GL_TEXTURE_2D,TexHandle); // Set our Tex handle as current
    
    	// Create the texture
    	if(Img.GetBPP()==24)
    		glTexImage2D(GL_TEXTURE_2D,0,3,Img.GetWidth(),Img.GetHeight(),0,GL_RGB,GL_UNSIGNED_BYTE,Img.GetImg());
    	else if(Img.GetBPP()==32)
    		glTexImage2D(GL_TEXTURE_2D,0,4,Img.GetWidth(),Img.GetHeight(),0,GL_RGBA,GL_UNSIGNED_BYTE,Img.GetImg());
    	else
    		return false;
    
    	// Specify filtering and edge actions
    	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
    	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
    	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
    
    	return true;
    }
    Then you can simply use LoadTexture with a direct reference to the .tga file itself:
    Code:
    LoadTexture("TILE.tga", Texture2[0]);
    right before you draw your quad. It makes transparency a lot easier too since 32-bit TGA's have an alpha channel. This may or may not fix your problem, but IMHO I think you should be using this over any LoadBMP function.

  3. #3
    Registered User
    Join Date
    Sep 2009
    Posts
    37
    thnx a lot for this nice class

  4. #4
    Registered User
    Join Date
    Nov 2010
    Posts
    1
    My visual studio 2010 can't find that Texture2[0] in the call of the LoadTexture() function anywhere and it gives an error. What's wrong? Nice class btw.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. d3d9 c++ texture wrapper... again...
    By yaya in forum Game Programming
    Replies: 0
    Last Post: 04-01-2009, 01:08 PM
  2. D3d Texture Wrapper == ARRRGGGGHHH
    By yaya in forum Game Programming
    Replies: 1
    Last Post: 03-25-2009, 06:41 PM
  3. Replies: 4
    Last Post: 02-27-2008, 02:10 PM
  4. OpenGL - look trough surface -nehe lesson
    By GanglyLamb in forum Game Programming
    Replies: 8
    Last Post: 08-24-2006, 11:06 PM
  5. Pong is completed!!!
    By Shamino in forum Game Programming
    Replies: 11
    Last Post: 05-26-2005, 10:50 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21