Category

Development Platform
Home > SourceCode/Document > Graph program > View Code
background_xD.cpp
Package: solidgraph_sources.zip　[view]
Upload User: kairuinn
Upload Date: 2009-02-07
Package Size: 2922k
Code Size: 16k
Category:

Graph program

Development Platform:

Visual C++

background_xD.cpp：Code Content
  1. #include "stdafx.h"
  2. #include "background_xD.h"
  3. #include "math.h"
  4. #include <io.h>
  5. #include <fcntl.h>
  6. #include <glglu.h>
  8. //-----------------------------------------------------------//
  9. //                         public                            //
  10. //-----------------------------------------------------------//
  12. //-------------------------------------------------------------
  13. //constructor
  14. //public
  15. #define FAR_CLIP 2000.0
  17. CBackground::CBackground()
  18. {
  19.     m_depth = FAR_CLIP;
  20.     m_row_num = 1;
  21.     m_col_num = 1;
  23. m_corners[0].r = 0.2f;
  24. m_corners[0].g = 0.2f;
  25. m_corners[0].b = 0.6f;
  26. m_corners[0].a = 1.0f; 
  28. m_corners[1].r = 0.2f;
  29. m_corners[1].g = 0.2f;
  30. m_corners[1].b = 0.6f;
  31. m_corners[1].a = 1.0f; 
  33.     m_corners[2].r = 0.9f;
  34.     m_corners[2].g = 0.9f;
  35.     m_corners[2].b = 1.0f;
  36.     m_corners[2].a = 1.0f; 
  38.     m_corners[3].r = 0.9f;
  39.     m_corners[3].g = 0.9f;
  40.     m_corners[3].b = 1.0f;
  41.     m_corners[3].a = 1.0f; 
  42.     
  43.     m_mirror_type = MIRROR11;
  44.     m_textureID = 0;
  45.     m_texture_file.Empty();
  46. }
  47. //-------------------------------------------------------------
  48. //destructor
  49. //public
  50. CBackground::~CBackground()
  51. {
  52.     if(m_textureID)
  53.     {
  54.         glDeleteTextures(1, &m_textureID);
  55.         m_textureID = 0;
  56.     }  
  57. }
  58. //-------------------------------------------------------------
  59. //set background params
  60. //public
  61. void CBackground::SetParams(SBACKGROUND_PARAMS *params)
  62. {
  63.     if(!params)        return;
  64.     if(m_textureID)
  65.     {
  66.         glDeleteTextures(1, &m_textureID);
  67.         m_textureID = 0;
  68.     }  
  69.     m_row_num = params->row_num;
  70.     m_col_num = params->col_num;
  71.     m_mirror_type = params->mirror_type;
  72.     m_texture_file = params->texture_file;
  73.     for( int i=0; i<4; i++)
  74.     {
  75.         m_corners[i].r = params->corner[i].r;
  76.         m_corners[i].g = params->corner[i].g;
  77.         m_corners[i].b = params->corner[i].b;
  78.         m_corners[i].a = params->corner[i].a;
  79.     }
  80. }
  81. //-------------------------------------------------------------
  82. //get background params
  83. //public
  84. void CBackground::GetParams(SBACKGROUND_PARAMS *params)
  85. {
  86.     if(!params)        return;
  87.     params->row_num = m_row_num;
  88.     params->col_num = m_col_num;
  89.     params->mirror_type = m_mirror_type;
  90.     params->texture_file = m_texture_file;
  91.     for( int i=0; i<4; i++)
  92.     {
  93.         params->corner[i].r = m_corners[i].r;
  94.         params->corner[i].g = m_corners[i].g;
  95.         params->corner[i].b = m_corners[i].b;
  96.         params->corner[i].a = m_corners[i].a;
  97.     }
  98. }
  99. //-------------------------------------------------------------
  100. //set z coordinate of the background
  101. //this function is called in CScene::SetBackgroung(CBackground *background)
  102. //public
  103. void CBackground::SetDepth(float depth)
  104. {
  105.     m_depth = depth;
  106. }
  107. //-------------------------------------------------------------
  108. //showing background
  109. //called in CScene::Display()
  110. //public
  111. void CBackground::Display()
  112. {
  113.     int i, j;
  115.     if(m_textureID==0 && !m_texture_file.IsEmpty())
  116.     {
  117.         CreateTexture();
  118.         if(m_textureID==0)
  119.         {    
  120.             ASSERT(0);
  121.             return;
  122.         }
  123.     }
  125.     glMatrixMode(GL_MODELVIEW);
  126. glPushMatrix();
  127. glLoadIdentity();
  129. glMatrixMode(GL_PROJECTION);
  130. glPushMatrix();
  131. glLoadIdentity();
  132. glOrtho(0, 1, 0, 1, 0, -(m_depth+1));
  134.     glPushAttrib(GL_ENABLE_BIT| GL_TEXTURE_BIT | GL_POLYGON_BIT);
  135.     glDisable(GL_CULL_FACE);
  136.     glDisable(GL_BLEND);  
  137.     glDisable(GL_LIGHTING);
  138.     //if we have texture (*.bmp file) then show texture
  139. if(m_textureID)
  140.     {
  141.         bool vert_mirror_status=false;
  142.     bool hor_mirror_status=true;
  144.         glBindTexture(GL_TEXTURE_2D, m_textureID);
  145.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  146.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  148.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  149.         for(i=0; i<m_col_num; i++)
  150. {
  151. for(j=0; j<m_row_num; j++)
  152. {
  153. glBegin(GL_QUADS);
  154. if(!vert_mirror_status && !hor_mirror_status)
  155. glTexCoord2f(0.f,0.f);
  156. if(vert_mirror_status && !hor_mirror_status)
  157. glTexCoord2f(1.f,0.f);
  158. if(!vert_mirror_status && hor_mirror_status)
  159. glTexCoord2f(0.f,1.f);
  160. if(vert_mirror_status && hor_mirror_status)
  161. glTexCoord2f(1.f,1.f);
  162.                     glVertex3f((float)i/(float)m_col_num, (float)(j+1)/(float)m_row_num, m_depth);
  163.                     
  164. if(!vert_mirror_status && !hor_mirror_status)
  165. glTexCoord2f(1.f,0.f);
  166. if(vert_mirror_status && !hor_mirror_status)
  167. glTexCoord2f(0.f,0.f);
  168. if(!vert_mirror_status && hor_mirror_status)
  169. glTexCoord2f(1.f,1.f);
  170. if(vert_mirror_status && hor_mirror_status)
  171. glTexCoord2f(0.f,1.f);
  172.      glVertex3f((float)(i+1)/(float)m_col_num, (float)(j+1)/(float)m_row_num, m_depth);
  173.                     
  175. if(!vert_mirror_status && !hor_mirror_status)
  176. glTexCoord2f(1.f,1.f);
  177. if(vert_mirror_status && !hor_mirror_status)
  178. glTexCoord2f(0.f,1.f);
  179. if(!vert_mirror_status && hor_mirror_status)
  180. glTexCoord2f(1.f,0.f);
  181. if(vert_mirror_status && hor_mirror_status)
  182. glTexCoord2f(0.f,0.f);
  183.      glVertex3f((float)(i+1)/(float)m_col_num, (float)j/(float)m_row_num, m_depth);
  185. if(!vert_mirror_status && !hor_mirror_status)
  186. glTexCoord2f(0.f,1.f);
  187. if(vert_mirror_status && !hor_mirror_status)
  188. glTexCoord2f(1.f,1.f);
  189. if(!vert_mirror_status && hor_mirror_status)
  190. glTexCoord2f(0.f,0.f);
  191. if(vert_mirror_status && hor_mirror_status)
  192. glTexCoord2f(1.f,0.f);
  193. glVertex3f((float)i/(float)m_col_num, (float)j/(float)m_row_num,m_depth);
  196. glEnd();
  198.     if(m_mirror_type == MIRROR01 || m_mirror_type == MIRROR11)
  199.     hor_mirror_status=!hor_mirror_status;
  200.     }
  201.             if(m_mirror_type == MIRROR10 || m_mirror_type == MIRROR11)
  202.     vert_mirror_status=!vert_mirror_status;
  204.             hor_mirror_status=true;
  205. }
  206. }
  207. else
  208. {
  209.         bool vert_mirror_status=false;
  210.     bool hor_mirror_status=false;
  212.         glEnable(GL_BLEND);
  213. glDisable(GL_TEXTURE_2D);
  215. for(i=0; i<m_col_num; i++)
  216. {
  217. for(j=0; j<m_row_num; j++)
  218. {
  219. glBegin(GL_QUADS);
  220.      if(!vert_mirror_status && !hor_mirror_status)
  221.      glColor4f(m_corners[0].r, m_corners[0].g, m_corners[0].b,1.0f);
  222.      if(vert_mirror_status && !hor_mirror_status)
  223.      glColor4f(m_corners[1].r, m_corners[1].g, m_corners[1].b,1.0f);
  224.      if(vert_mirror_status && hor_mirror_status)
  225.      glColor4f(m_corners[2].r, m_corners[2].g, m_corners[2].b,1.0f);
  226.                     if(!vert_mirror_status && hor_mirror_status)
  227.      glColor4f(m_corners[3].r, m_corners[3].g, m_corners[3].b,1.0f);
  228.                     glVertex3f((float)i/(float)m_col_num, (float)(j+1)/(float)m_row_num,m_depth);
  229.                     //glVertex2f((float)i/(float)m_col_num, (float)(j+1)/(float)m_row_num);
  230.                 
  231.      if(vert_mirror_status && !hor_mirror_status)
  232.      glColor4f(m_corners[0].r, m_corners[0].g, m_corners[0].b,1.0f);
  233.                     if(!vert_mirror_status && !hor_mirror_status)
  234.      glColor4f(m_corners[1].r, m_corners[1].g, m_corners[1].b,1.0f);
  235.      if(!vert_mirror_status && hor_mirror_status)
  236.      glColor4f(m_corners[2].r, m_corners[2].g, m_corners[2].b,1.0f);
  237.      if(vert_mirror_status && hor_mirror_status)
  238.      glColor4f(m_corners[3].r, m_corners[3].g, m_corners[3].b,1.0f);
  239.      glVertex3f((float)(i+1)/(float)m_col_num, (float)(j+1)/(float)m_row_num,m_depth);
  240.                     //glVertex2f((float)(i+1)/(float)m_col_num, (float)(j+1)/(float)m_row_num);
  241.                     
  242.                 
  243.      if(vert_mirror_status && hor_mirror_status)
  244.      glColor4f(m_corners[0].r, m_corners[0].g, m_corners[0].b,1.0f);
  245.      if(!vert_mirror_status && hor_mirror_status)
  246.      glColor4f(m_corners[1].r, m_corners[1].g, m_corners[1].b,1.0f);
  247.                     if(!vert_mirror_status && !hor_mirror_status)
  248.      glColor4f(m_corners[2].r, m_corners[2].g, m_corners[2].b,1.0f);
  249.      if(vert_mirror_status && !hor_mirror_status)
  250.      glColor4f(m_corners[3].r, m_corners[3].g, m_corners[3].b,1.0f);
  251.                     glVertex3f((float)(i+1)/(float)m_col_num, (float)j/(float)m_row_num,m_depth);
  252.                     //glVertex2f((float)(i+1)/(float)m_col_num, (float)j/(float)m_row_num);
  253.                 
  254.      if(!vert_mirror_status && hor_mirror_status)
  255.      glColor4f(m_corners[0].r, m_corners[0].g, m_corners[0].b,1.0f);
  256.      if(vert_mirror_status && hor_mirror_status)
  257.      glColor4f(m_corners[1].r, m_corners[1].g, m_corners[1].b,1.0f);
  258.      if(vert_mirror_status && !hor_mirror_status)
  259.      glColor4f(m_corners[2].r, m_corners[2].g, m_corners[2].b,1.0f);
  260.                     if(!vert_mirror_status && !hor_mirror_status)
  261.      glColor4f(m_corners[3].r, m_corners[3].g, m_corners[3].b,1.0f);
  262.                     glVertex3f((float)i/(float)m_col_num, (float)j/(float)m_row_num,m_depth);
  263.                     //glVertex2f((float)i/(float)m_col_num, (float)j/(float)m_row_num);
  264.          
  265.     glEnd();
  267.     if(m_mirror_type == MIRROR01 || m_mirror_type == MIRROR11)
  268.     hor_mirror_status=!hor_mirror_status;
  269.     }
  270.             if(m_mirror_type == MIRROR10 || m_mirror_type == MIRROR11)
  271.     vert_mirror_status=!vert_mirror_status;
  273.             hor_mirror_status=false;
  274.     }
  275.     }
  277. glPopAttrib();
  278. glPopMatrix();
  280. glMatrixMode(GL_MODELVIEW);
  281. glPopMatrix();
  282. }
  284. //-----------------------------------------------------------//
  285. //                         private                           //
  286. //-----------------------------------------------------------//
  288. //creating background texture from *.bmp file
  289. //private
  290. bool CBackground::CreateTexture()
  291. {
  292.     if(m_texture_file.IsEmpty())
  293.     {
  294.         if(m_textureID)
  295.         {
  296.             glDeleteTextures(1, &m_textureID);
  297.             m_textureID = 0;
  298.         }
  299.         return false;
  300.     }
  302.     if(m_textureID)
  303.         if(m_textureID)
  304.     glDeleteTextures(1, &m_textureID);
  305.   
  306.     //glGenTextures(1, &m_textureID);
  307.         m_textureID = 10067;
  309.     ASSERT(m_textureID>0);
  311.     int textuere_width;
  312.     int texture_height;
  313.     int tmp_width;
  314.     int tmp_height;
  315.     BYTE *pTexture = NULL;
  316.     BYTE *pTmpData = NULL;
  317.     char path[MAX_PATH];
  319.     sprintf(path, "%s", (LPCTSTR) m_texture_file);
  320.     
  321. pTmpData = LoadFromBmp(path, &tmp_width, &tmp_height);
  323. if(pTmpData)
  324. {
  325.      textuere_width=32;
  326. textuere_width = (int)pow((float)2.0f,(float)
  327. ((log((float)tmp_width)/log(2.0f))+
  328. 1.0-
  329. (log((float)m_col_num)/log(2.0f))));
  330. if(textuere_width<32)
  331.     textuere_width=32;
  332. if(textuere_width>1024)
  333. textuere_width=1024;
  335. texture_height=32;
  336. texture_height = (int)pow((float)2.0f,
  337. (float)((log((float)tmp_height)/log(2.0f))+1.0-(log((float)m_row_num)/log(2.0f))));
  338. if(texture_height<32)
  339.     texture_height=32;
  340. if(texture_height>1024)
  341. texture_height=1024;
  343. pTexture = new BYTE[texture_height*textuere_width*3];
  344. if(pTexture)
  345. {
  346.     gluScaleImage(GL_RGB, tmp_width, tmp_height, GL_UNSIGNED_BYTE, pTmpData, textuere_width, texture_height, GL_UNSIGNED_BYTE, pTexture);
  348.             glBindTexture(GL_TEXTURE_2D, m_textureID);
  349.             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, textuere_width, texture_height, 0, GL_RGB, GL_UNSIGNED_BYTE, (GLubyte*) pTexture);
  350. delete[] pTmpData;
  351.             delete[] pTexture;
  352. }
  353.         else
  354.         {
  355.             return false;
  356.         }
  357.     }
  358.     else
  359.     {
  360.         return false;
  361.     }
  362.     return true;
  363. }
  364. //-------------------------------------------------------------
  365. //this function loads *.bmp file and returns width and height 
  366. //pointer to the picture storage (rgbrgbrgb...), 
  367. //size of this storage is bmpWidth*bmpHeight*3*sizeof(unsigned char)
  368. //this memory shoud be free after using; 
  369. //this function is used in CBackground::CreateTexture()
  370. //private
  371. unsigned char *CBackground::LoadFromBmp(char *filename, int* bmpWidth, int* bmpHeight)
  372. {
  373.     LPRGBQUAD   ptrToPalette;  
  374.     char*       ptrToPixels;   
  375.     long        bitmapRow, bitmapColumn;  
  376. LPBITMAPINFOHEADER PtrToBmpHdr;
  377. LPBITMAPFILEHEADER PtrToFileHdr;
  378. unsigned char *Texels;
  379. unsigned char *texture_pixels;
  381. int    size_texture;
  382. unsigned char *ptex;
  384. int    length;
  385. char  *texture_file;
  386. UINT  nBytesRead;
  387. int    fh;
  388. char errorstr[_MAX_PATH+25]="Can't open bmp file ";
  390.    /* Open file for input: */
  391. if( (fh = _open(filename, _O_RDONLY )) == -1 )  
  392. {
  393. ::MessageBox(NULL, strcat(errorstr,filename),"Error",MB_OK);
  394.         return NULL;
  395. }
  396. length = _filelength(fh);
  398. texture_file = (char*)malloc(length);
  400. if(texture_file == NULL)
  401. ::MessageBox(NULL, "Can not load picture. nPicture is too large.","Error",MB_OK);
  403. if( ( nBytesRead = _read( fh, texture_file, length ) ) <= 0 ) 
  404. {
  405. _close( fh );
  406. ::MessageBox(NULL, "Read texture file","Error",MB_OK);
  407. exit(-3);
  408. }
  409. _close( fh );
  411. PtrToFileHdr = (LPBITMAPFILEHEADER)texture_file;
  412. PtrToBmpHdr = (LPBITMAPINFOHEADER)(texture_file+sizeof(BITMAPFILEHEADER));
  413.   
  414. if (!PtrToBmpHdr) 
  415. {
  416. DWORD err = GetLastError();
  417. goto ErrorExit;
  418. }
  420.     Texels = (unsigned char *)malloc(PtrToBmpHdr->biWidth * 3);
  422.     ptrToPalette = (LPRGBQUAD) ((LPSTR) PtrToBmpHdr + PtrToBmpHdr->biSize);
  423.     ptrToPixels  = (char*) PtrToBmpHdr + (PtrToBmpHdr->biSize + 
  424.                            PtrToBmpHdr->biClrUsed * sizeof(RGBQUAD));
  426. if ( PtrToBmpHdr->biBitCount == 4) 
  427. {
  428.             ptrToPixels += ((PtrToBmpHdr->biHeight - 1) * (long )((PtrToBmpHdr->biWidth/2+3) & ~3));
  429. } 
  430. else 
  431. {
  432. if ( PtrToBmpHdr->biBitCount == 8) 
  433. {
  434.             ptrToPixels += ((PtrToBmpHdr->biHeight - 1) * (long )((PtrToBmpHdr->biWidth+3) & ~3));
  435. } 
  436. else 
  437. {
  438. if ( PtrToBmpHdr->biBitCount == 24) 
  439. {
  440. ptrToPixels += ((PtrToBmpHdr->biHeight - 1) * (long )((PtrToBmpHdr->biWidth*3+3) & ~3));
  441. }
  442. }
  443. }
  444. size_texture = PtrToBmpHdr->biWidth*PtrToBmpHdr->biHeight;
  445. ptex = (unsigned char*)malloc(3*size_texture);
  446. if (ptex == NULL) 
  447. {
  448. goto ErrorExit;
  449. }
  451. *bmpWidth = PtrToBmpHdr->biWidth;
  452. *bmpHeight = PtrToBmpHdr->biHeight;
  453.   /*if ( ((*bmpWidth-1) & *bmpWidth)||((*bmpHeight-1) & *bmpHeight) )
  454.   ::MessageBox(NULL, "Texture dimension has to be power of 2","Error",MB_OK);
  455.   */  
  456. texture_pixels = ptex;
  458.     for (bitmapRow = 0;  bitmapRow < PtrToBmpHdr->biHeight; bitmapRow++) 
  459. {
  460. LPSTR   rowPtr;
  461. rowPtr = (LPSTR)ptrToPixels;
  463.         for (bitmapColumn = 0; bitmapColumn < PtrToBmpHdr->biWidth; ) 
  464. {
  465.             unsigned char p;
  466. if ( PtrToBmpHdr->biBitCount == 4) 
  467. {
  468. p = *rowPtr;
  469. rowPtr++;
  470. Texels[bitmapColumn*3  ] = ptrToPalette[p>>4].rgbRed;
  471. Texels[bitmapColumn*3+1] = ptrToPalette[p>>4].rgbGreen;
  472. Texels[bitmapColumn*3+2] = ptrToPalette[p>>4].rgbBlue;
  473. bitmapColumn++;
  474. Texels[bitmapColumn*3  ] = ptrToPalette[p&0xf].rgbRed;
  475. Texels[bitmapColumn*3+1] = ptrToPalette[p&0xf].rgbGreen;
  476. Texels[bitmapColumn*3+2] = ptrToPalette[p&0xf].rgbBlue;
  477. bitmapColumn++;
  478. } 
  479. else 
  480. if ( PtrToBmpHdr->biBitCount == 8) 
  481. {
  482. p = *rowPtr;
  483. rowPtr++;
  484. Texels[bitmapColumn*3  ] = ptrToPalette[p].rgbRed;
  485. Texels[bitmapColumn*3+1] = ptrToPalette[p].rgbGreen;
  486. Texels[bitmapColumn*3+2] = ptrToPalette[p].rgbBlue;
  487. bitmapColumn++;
  488. } 
  489. else 
  490. if ( PtrToBmpHdr->biBitCount == 24) 
  491. {
  492. Texels[bitmapColumn*3+2] = *rowPtr++;
  493. Texels[bitmapColumn*3+1] = *rowPtr++;
  494. Texels[bitmapColumn*3  ] = *rowPtr++;
  495. bitmapColumn++;
  496. }
  497. }
  498.         
  499. if (PtrToBmpHdr->biBitCount==4) 
  500. {
  501. ptrToPixels -= ((PtrToBmpHdr->biWidth >> 1)+3) & ~3;
  502. } 
  503. else 
  504. {
  505. if(PtrToBmpHdr->biBitCount==8) 
  506. {
  507. ptrToPixels -= (PtrToBmpHdr->biWidth+3) & ~3;
  508. } 
  509. else 
  510. {
  511. if(PtrToBmpHdr->biBitCount==24) 
  512. {
  513. ptrToPixels -= ((PtrToBmpHdr->biWidth*3+3) & ~3);
  514. }
  515. }
  516. }
  517. memcpy( ptex, &Texels[0], 3 * PtrToBmpHdr->biWidth);
  518. ptex += 3 * PtrToBmpHdr->biWidth;
  519.     } 
  521. free(texture_file); 
  522. free(Texels);
  524. return texture_pixels;
  525.     
  526. ErrorExit:
  527. free(texture_file);
  528. return NULL;
  529. }