opegnl LoadBMP or texture 2 sphere

punkywow · 10-12-2009, 01:32 AM

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);

Xterria · 10-12-2009, 10:25 AM

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.

punkywow · 10-22-2009, 02:07 AM

thnx a lot for this nice class

10-22-2009, 02:07 AM	#3
punkywow Registered User Join Date: Sep 2009 Posts: 37	thnx a lot for this nice class
punkywow is offline

Thread Tools
Show Printable Version Email this Page
Display Modes
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode

Similar Threads
Thread	Thread Starter	Forum	Replies	Last Post
d3d9 c++ texture wrapper... again...	yaya	Game Programming	0	04-01-2009 01:08 PM
D3d Texture Wrapper == ARRRGGGGHHH	yaya	Game Programming	1	03-25-2009 06:41 PM
Why doesn't glbindtexture recognize the texture id I pass it?	Shamino	Game Programming	4	02-27-2008 03:10 PM
OpenGL - look trough surface -nehe lesson	GanglyLamb	Game Programming	8	08-24-2006 11:06 PM
Pong is completed!!!	Shamino	Game Programming	11	05-26-2005 10:50 AM