开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
Texture.cpp
资源名称：3dexplorerTest.rar　[点击查看]
上传用户：hkb425
上传日期：2007-06-16
资源大小：34191k
文件大小：15k
源码类别：

游戏引擎

开发平台：

Visual C++

Texture.cpp：源码内容
  1. // Texture.cpp: implementation of the CTexture class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Texture.h"
  8. //////////////////////////////////////////////////////////////////////
  9. // Construction/Destruction
  10. //////////////////////////////////////////////////////////////////////
  12. CTexture::CTexture()
  13. {
  14. }
  16. bool CTexture::MakeTextureBind(char* TextureFileName,unsigned int* TextureID,
  17.    bool bLinear,bool bMip)
  18. {
  19. bool status=true; // Status Indicator
  20. AUX_RGBImageRec *Image=NULL;
  22.      ///////////////////load wall tex
  23. if (Image=auxDIBImageLoad(TextureFileName))
  24. {
  26. /* for(int y=0;y<Image->sizeY;y+=2)
  27. for(int x=0;x<Image->sizeX;x++)
  28. {
  29. Image->data[y*Image->sizeY*3+x*3+0]=0;
  30. Image->data[y*Image->sizeY*3+x*3+1]=0;
  31. Image->data[y*Image->sizeY*3+x*3+2]=0;
  32. }*/
  34. glGenTextures(1, TextureID); // Create one Texture
  35.     glBindTexture(GL_TEXTURE_2D, *TextureID);
  36.         if(bLinear)
  37. {
  38. ///////////////////////////////
  39. if(bMip)
  40. {
  41.                 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  42.                 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  43.            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  44.          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  45.          gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, Image->sizeX, Image->sizeY, GL_RGB, GL_UNSIGNED_BYTE, Image->data);
  46. }
  47. else
  48. {
  49.                 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
  50.                 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
  51.                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  52.      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  53.              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, Image->sizeX, Image->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, Image->data);
  54. }
  55. }
  56. else
  57. {
  58. if(bMip)
  59. {
  60.            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  61.          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
  62.          gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, Image->sizeX, Image->sizeY, GL_RGB, GL_UNSIGNED_BYTE, Image->data);
  63. }
  64. else
  65. {
  66.                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  67.      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  68.              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, Image->sizeX, Image->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, Image->data);
  69. }
  70. }
  71. }
  72. else status=false;
  73. if (Image) { // If Texture Exists
  74. if (Image->data) delete Image->data; // If Texture Image Exists
  75. delete Image;
  76. }
  77. return status;
  78. }
  81. bool CTexture::MakeSkinTextureBind(char* TextureFileName,unsigned int* TextureID,
  82.    bool bLinear,bool bMip)
  83. {
  84. bool state=true; // Status Indicator
  85. unsigned char *Image=new unsigned char [256*256*3];
  86. FILE* file;
  87.     if((file= fopen(TextureFileName, "rb"))==NULL)
  88. {
  89.     state=false;
  90. return state;
  91. }
  92. char id[10],version;
  93. fread(id,     sizeof(char),10,  file);
  94. fread(&version,sizeof(char),1,  file);
  95. if ( strncmp( id, "Hunter3D00", 10 ) != 0 )
  96. {
  97.     fclose(file);
  98.     return false; // "Not a valid .skn file."
  99. }
  100. if ( version !=1 )
  101. {
  102.     fclose(file);
  103.     return false; // "Not a valid .skn file."
  104. }
  106. fread(Image,sizeof(unsigned char),256*256*3,file);
  108.     fclose(file);
  109.     file=NULL;
  111. glGenTextures(1, TextureID); // Create one Texture
  112. glBindTexture(GL_TEXTURE_2D, *TextureID);
  113.     if(bLinear)
  114. {
  115. if(bMip)
  116. {
  117.            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  118.          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  119.          gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, 256, 256, GL_RGB, GL_UNSIGNED_BYTE, Image);
  120. }
  121. else
  122. {
  123.                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  124.      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  125.              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,256,256, 0, GL_RGB, GL_UNSIGNED_BYTE, Image);
  126. }
  127. }
  128. else
  129. {
  130. if(bMip)
  131. {
  132.            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  133.          glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
  134.          gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, 256, 256, GL_RGB, GL_UNSIGNED_BYTE, Image);
  135. }
  136. else
  137. {
  138.                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  139.      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  140.              glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 256,256, 0, GL_RGB, GL_UNSIGNED_BYTE, Image);
  141. }
  142. }
  144.     delete [] Image; // If Texture Image Exists
  145. return state;
  146. }
  147. /////////////////////////////////////////////////
  148. bool CTexture::MakeAlphaTextureBind(char* TextureFileName,unsigned int* TextureID)
  149. {
  150. bool status=true; // Status Indicator
  151. AUX_RGBImageRec *Image=NULL; // Create Storage Space For The Texture
  152. unsigned char *alpha=NULL;
  154. ////////////////////////////////////
  155. if (Image=auxDIBImageLoad(TextureFileName)) 
  156. {
  157. alpha=new unsigned char[4*Image->sizeX*Image->sizeY]; // Create Memory For RGBA8-Texture
  158. for (int a=0; a<Image->sizeX*Image->sizeY; a++)
  159. {
  160. alpha[4*a]=Image->data[a*3]; // R
  161. alpha[4*a+1]=Image->data[a*3+1]; // G
  162. alpha[4*a+2]=Image->data[a*3+2]; // B
  163.             ////////////Get max
  164.             alpha[4*a+3]=(alpha[4*a+0]<alpha[4*a+1])?alpha[4*a+0]:alpha[4*a+1];
  165.             if(alpha[4*a+2]<alpha[4*a+3])alpha[4*a+3]=alpha[4*a+2];
  168. }
  170. ///////////////////////////////////////////////
  171. glGenTextures(1, TextureID); // Create One Textures
  173. // Create Linear Filtered RGBA8-Texture
  174. glBindTexture(GL_TEXTURE_2D, *TextureID);
  175.         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  176.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  177.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8, Image->sizeX, Image->sizeY, GL_RGBA, GL_UNSIGNED_BYTE, alpha);
  178. delete [] alpha;
  179. }
  180. else status=false;
  181. if (Image) { // If Texture Exists
  182. if (Image->data) delete Image->data; // If Texture Image Exists
  183. delete Image;
  184. Image=NULL;
  185. }
  186. ///////////////////////////////////
  187.     return status;
  188. }
  189. bool CTexture::MakeAlphaTextureBind(char* TextureFileName,char *AlphaFileName,unsigned int* TextureID)
  190. {
  191. bool status=true; // Status Indicator
  192. AUX_RGBImageRec *Image=NULL; // Create Storage Space For The Texture
  193. unsigned char *alpha=NULL;
  195. ////////////////////////////////////
  196. if (Image=auxDIBImageLoad(TextureFileName)) 
  197. {
  198. alpha=new unsigned char[4*Image->sizeX*Image->sizeY]; // Create Memory For RGBA8-Texture
  199. for (int a=0; a<Image->sizeX*Image->sizeY; a++)
  200. {
  201. alpha[4*a]=Image->data[a*3]; // R
  202. alpha[4*a+1]=Image->data[a*3+1]; // G
  203. alpha[4*a+2]=Image->data[a*3+2]; // B
  204. }
  205. /////////////////make alpha chanal
  206.         if(AlphaFileName==NULL)return false;
  207.     FILE* file;
  208.         if((file= fopen(AlphaFileName, "rb"))==NULL)
  209.        return false;
  210. fseek(file,54,SEEK_SET);
  211. unsigned char temp[3];
  212. for ( a=0; a<Image->sizeX*Image->sizeY; a++)
  213. {
  214. fread(temp,sizeof(unsigned char),3,file);
  215.             alpha[4*a+3]=(temp[0]>temp[1])?temp[0]:temp[1];
  216.             if(temp[2]>alpha[4*a+3])alpha[4*a+3]=temp[2];
  217. //          alpha[4*a+3]=(temp[0]+temp[1]+temp[2])/3;
  218. if(alpha[4*a+3]>50)alpha[4*a+3]=255;
  219. }
  220. fclose(file);
  221. ///////////////////////////////////////////////
  222. glGenTextures(1, TextureID); // Create One Textures
  223. // Create Linear Filtered RGBA8-Texture
  224. glBindTexture(GL_TEXTURE_2D, *TextureID);
  225.         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  226.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  227.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8, Image->sizeX, Image->sizeY, GL_RGBA, GL_UNSIGNED_BYTE, alpha);
  228. delete [] alpha;
  229. }
  230. else status=false;
  231. if (Image) { // If Texture Exists
  232. if (Image->data) delete Image->data; // If Texture Image Exists
  233. delete Image;
  234. Image=NULL;
  235. }
  236. ///////////////////////////////////
  237.     return status;
  238. }
  239. bool CTexture::MakeTGAAlphaBind(char* TextureFileName,unsigned int* TextureID)
  240. {
  241. FILE * fTGA; // File pointer to texture file
  242. fTGA = fopen(TextureFileName, "rb"); // Open file for reading
  243.     TGAHeader tgaheader; // TGA header
  244. Texture texture;
  246. if(fTGA == NULL) // If it didn't open....
  247. {
  248. MessageBox(NULL, "Could not open texture file", "ERROR", MB_OK); // Display an error message
  249. return false; // Exit function
  250. }
  251. if(fread(&tgaheader, sizeof(TGAHeader), 1, fTGA) == 0) // Attempt to read 12 byte header from file
  252. {
  253. MessageBox(NULL, "Could not read file header", "ERROR", MB_OK); // If it fails, display an error message 
  254. if(fTGA != NULL) // Check to seeiffile is still open
  255. {
  256. fclose(fTGA); // If it is, close it
  257. }
  258. return false; // Exit function
  259. }
  261.     GLubyte uTGAcompare[12] = {0,0,2, 0,0,0,0,0,0,0,0,0}; // Uncompressed TGA Header
  262.     GLubyte cTGAcompare[12] = {0,0,10,0,0,0,0,0,0,0,0,0}; // Compressed TGA Header
  263. if(memcmp(uTGAcompare, &tgaheader, sizeof(tgaheader)) == 0) // See if header matches the predefined header of 
  264. { // an Uncompressed TGA image
  265. LoadUncompressedTGA(&texture, TextureFileName, fTGA); // If so, jump to Uncompressed TGA loading code
  266. }
  267. else if(memcmp(cTGAcompare, &tgaheader, sizeof(tgaheader)) == 0) // See if header matches the predefined header of
  268. { // an RLE compressed TGA image
  269. LoadCompressedTGA(&texture, TextureFileName, fTGA); // If so, jump to Compressed TGA loading code
  270. }
  271. else // If header matches neither type
  272. {
  273. MessageBox(NULL, "TGA file be type 2 or type 10 ", "Invalid Image", MB_OK); // Display an error
  274. fclose(fTGA);
  275. return false; // Exit function
  276. }
  277.     //////////////////////////////////////////////////////////
  278. glGenTextures(1, TextureID); // Create One Textures
  279. // Create Linear Filtered RGBA8-Texture
  280. glBindTexture(GL_TEXTURE_2D, *TextureID);
  281.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  282.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  283.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8, texture.width, texture.height, texture.type, GL_UNSIGNED_BYTE, texture.imageData);
  285. delete [] texture.imageData;
  286. return true;
  287. }
  288. bool CTexture::LoadUncompressedTGA(Texture * texture, char * filename, FILE * fTGA)
  289. {
  290.     TGA tga;
  292. if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0) // Read TGA header
  293. {
  294. MessageBox(NULL, "Could not read info header", "ERROR", MB_OK); // Display error
  295. if(fTGA != NULL) // if file is still open
  296. {
  297. fclose(fTGA); // Close it
  298. }
  299. return false; // Return failular
  300. }
  301. texture->width  = tga.header[1] * 256 + tga.header[0]; // Determine The TGA Width (highbyte*256+lowbyte)
  302. texture->height = tga.header[3] * 256 + tga.header[2]; // Determine The TGA Height (highbyte*256+lowbyte)
  303. texture->bpp = tga.header[4]; // Determine the bits per pixel
  304. tga.Width = texture->width; // Copy width into local structure
  305. tga.Height = texture->height; // Copy height into local structure
  306. tga.Bpp = texture->bpp; // Copy BPP into local structure
  307. if((texture->width <= 0) || (texture->height <= 0) || ((texture->bpp != 24) && (texture->bpp !=32))) // Make sure all information is valid
  308. {
  309. MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK); // Display Error
  310. if(fTGA != NULL) // Check if file is still open
  311. {
  312. fclose(fTGA); // If so, close it
  313. }
  314. return false; // Return failed
  315. }
  316. if(texture->bpp == 24) //If the BPP of the image is 24...
  317. {
  318. texture->type = GL_RGB; // Set Image type to GL_RGB
  319. }
  320. else // Else if its 32 BPP
  321. {
  322. texture->type = GL_RGBA; // Set image type to GL_RGBA
  323. }
  324. tga.bytesPerPixel = (tga.Bpp / 8); // Compute the number of BYTES per pixel
  325. tga.imageSize = (tga.bytesPerPixel * tga.Width * tga.Height); // Compute the total amout ofmemory needed to store data
  326. texture->imageData =new  GLubyte[tga.imageSize]; // Allocate that much memory
  327. if(texture->imageData == NULL) // If no space was allocated
  328. {
  329. MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK); // Display Error
  330. fclose(fTGA); // Close the file
  331. return false; // Return failed
  332. }
  333. if(fread(texture->imageData, 1, tga.imageSize, fTGA) != tga.imageSize) // Attempt to read image data
  334. {
  335. MessageBox(NULL, "Could not read image data", "ERROR", MB_OK); // Display Error
  336. if(texture->imageData != NULL) // If imagedata has data in it
  337. {
  338. free(texture->imageData); // Delete data from memory
  339. }
  340. fclose(fTGA); // Close file
  341. return false; // Return failed
  342. }
  343. for(GLuint cswap = 0;  cswap < (int)tga.imageSize; cswap += tga.bytesPerPixel) // Swap color bytes from BGR to RGB
  344. {
  345. tga.temp = texture->imageData[cswap];
  346. texture->imageData[cswap] = texture->imageData[cswap + 2];
  347. texture->imageData[cswap + 2] = tga.temp;
  348. }
  349. fclose(fTGA);
  351.     return true;
  352. }
  353. bool CTexture::LoadCompressedTGA(Texture * texture, char * filename, FILE * fTGA)
  354. {
  356.     return false;
  357. }
  359. bool  CTexture::MakeScreenTextureBind(unsigned int* TextureID)
  360. {
  361. //
  362. if(glIsTexture(* TextureID)==GL_TRUE)
  363. {
  364. //    glBindTexture(GL_TEXTURE_2D, *TextureID);
  365. // glCopyTexSubImage2D(GL_TEXTURE_2D, 0,  0,0,   0,0,  512,512 );
  366. }
  367. else
  368. {
  369. GLint Viewport[4];
  370.         glGetIntegerv(GL_VIEWPORT, Viewport);
  371. int newWidth=128;
  373.         unsigned char *pData=new unsigned char[newWidth*newWidth*3+6]; // +6 for safe
  374. /////////////找到pData(x,y)对应屏幕上的象素点(sx,sy)
  375. int sx,sy;  //标记新的位置
  376.         unsigned char temp[6];
  377. for(int y=0;y<newWidth;y++)
  378. for(int x=0;x<newWidth;x++)
  379. {
  380.     sx=int(float(x*Viewport[2])/newWidth);
  381.     sy=int(float(y*Viewport[3])/newWidth);
  383.          glReadPixels(sx,sy,1,1,
  384.                  GL_RGB,GL_UNSIGNED_BYTE,temp);
  386.                 pData[y*newWidth*3+x*3+0]=unsigned char(temp[0]*0.8f);
  387.                 pData[y*newWidth*3+x*3+1]=unsigned char(temp[1]*0.8f);
  388.                 pData[y*newWidth*3+x*3+2]=unsigned char(temp[2]*0.8f);
  389. }
  391.         ////////////////////////////////////////////////////////////
  392. glGenTextures(1, TextureID); // Create one Texture
  393.     glBindTexture(GL_TEXTURE_2D, *TextureID);
  395.         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  396.   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  397.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, newWidth,newWidth, 0, GL_RGB, GL_UNSIGNED_BYTE,pData);
  399. delete [] pData;
  400. }
  401.     return true;
  402. }
  404. CTexture::~CTexture()
  405. {
  407. }