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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
texture.cpp
资源名称：Engine_v0.2.tar.gz　[点击查看]
上传用户：qccn516
上传日期：2013-05-02
资源大小：3382k
文件大小：28k
源码类别：

游戏引擎

开发平台：

Visual C++

texture.cpp：源码内容
  1. /* Texture
  2.  *
  3.  * Copyright (C) 2003-2004, Alexander Zaprjagaev <frustum@frustum.org>
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include <png.h>
  23. #include <setjmp.h>
  24. extern "C" {
  25. #include <jpeglib.h>
  26. }
  28. #include "engine.h"
  29. #include "texture.h"
  31. #ifdef _WIN32
  32. #pragma comment (lib,"libjpeg.lib")
  33. #pragma comment (lib,"libpng.lib")
  34. #pragma comment (lib,"zlib.lib")
  35. #endif
  37. /*
  38.  */
  39. Texture::Texture(int width,int height,GLuint target,int flag) : width(width), height(height), depth(1), target(target), flag(flag) {
  40. glGenTextures(1,&id);
  41. glBindTexture(target,id);
  42. if(flag & LUMINANCE) format = GL_LUMINANCE;
  43. else if(flag & LUMINANCE_ALPHA) format = GL_LUMINANCE_ALPHA;
  44. else if(flag & RGB) format = GL_RGB;
  45. else if(flag & RGBA) format = GL_RGBA;
  46. else fprintf(stderr,"Texture::Texture(): unknown formatn");
  47. GLuint type;
  48. GLuint internalformat;
  49. if(flag & FLOAT) {
  50. type = GL_FLOAT;
  51. if(format == GL_RGB) internalformat = GL_FLOAT_RGB_NV;
  52. else if(format == GL_RGBA) internalformat = GL_FLOAT_RGBA_NV;
  53. else {
  54. fprintf(stderr,"Texture::Texture(): FLOAT flag is accessible only for RGB or RGBA formatsn");
  55. return;
  56. }
  57. } else {
  58. type = GL_UNSIGNED_BYTE;
  59. internalformat = format;
  60. }
  61. if(flag & CLAMP) {
  62. glTexParameteri(target,GL_TEXTURE_WRAP_S,GL_CLAMP);
  63. glTexParameteri(target,GL_TEXTURE_WRAP_T,GL_CLAMP);
  64. glTexParameteri(target,GL_TEXTURE_WRAP_R,GL_CLAMP);
  65. } else if(flag & CLAMP_TO_EDGE) {
  66. glTexParameteri(target,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
  67. glTexParameteri(target,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
  68. glTexParameteri(target,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
  69. }
  70. if(flag & NEAREST) {
  71. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  72. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  73. } else if(flag & LINEAR) {
  74. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  75. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  76. } else if(flag & NEAREST_MIPMAP_NEAREST){
  77. glTexParameteri(target,GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
  78. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  79. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
  80. } else if(flag & LINEAR_MIPMAP_NEAREST) {
  81. glTexParameteri(target,GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
  82. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  83. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  84. } else if(flag & LINEAR_MIPMAP_LINEAR) {
  85. glTexParameteri(target,GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
  86. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  87. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  88. }
  89. if(flag & ANISOTROPY_1) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,1.0);
  90. else if(flag & ANISOTROPY_2) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,2.0);
  91. else if(flag & ANISOTROPY_4) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,4.0);
  92. else if(flag & ANISOTROPY_8) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,8.0);
  93. else if(flag & ANISOTROPY_16) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,16.0);
  94. if(target == TEXTURE_2D) glTexImage2D(target,0,internalformat,width,height,0,format,type,NULL);
  95. else if(target == TEXTURE_RECT) glTexImage2D(target,0,internalformat,width,height,0,format,type,NULL);
  96. else if(target == TEXTURE_CUBE) {
  97. glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X,0,internalformat,width,height,0,format,type,NULL);
  98. glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X,0,internalformat,width,height,0,format,type,NULL);
  99. glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y,0,internalformat,width,height,0,format,type,NULL);
  100. glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,0,internalformat,width,height,0,format,type,NULL);
  101. glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z,0,internalformat,width,height,0,format,type,NULL);
  102. glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,0,internalformat,width,height,0,format,type,NULL);
  103. }
  104. else if(target == TEXTURE_3D) glTexImage3D(target,0,internalformat,width,height,depth,0,format,type,NULL);
  105. }
  107. /*
  108.  */
  109. Texture::Texture(const char *name,GLuint target,int flag) {
  110. load(name,target,flag);
  111. }
  113. /*
  114.  */
  115. Texture::~Texture() {
  116. glDeleteTextures(1,&id);
  117. }
  119. /*
  120.  */
  121. void Texture::load(const char *name,GLuint target,int flag) {
  122. width = 0;
  123. height = 0;
  124. depth = 1;
  125. this->target = target;
  126. this->flag = flag;
  127. glGenTextures(1,&id);
  128. glBindTexture(target,id);
  129. if(flag & LUMINANCE) format = GL_LUMINANCE;
  130. else if(flag & LUMINANCE_ALPHA) format = GL_LUMINANCE_ALPHA;
  131. else if(flag & RGB) format = GL_RGB;
  132. else if(flag & RGBA) format = GL_RGBA;
  133. else fprintf(stderr,"Texture::Texture(): unknown formatn");
  134. if(flag & FLOAT) fprintf(stderr,"Texture::Texture(): FLOAT flag is not accessible for "%s" filen",name);
  135. if(flag & CLAMP) {
  136. glTexParameteri(target,GL_TEXTURE_WRAP_S,GL_CLAMP);
  137. glTexParameteri(target,GL_TEXTURE_WRAP_T,GL_CLAMP);
  138. glTexParameteri(target,GL_TEXTURE_WRAP_R,GL_CLAMP);
  139. } else if(flag & CLAMP_TO_EDGE) {
  140. glTexParameteri(target,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
  141. glTexParameteri(target,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
  142. glTexParameteri(target,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
  143. }
  144. if(flag & NEAREST) {
  145. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  146. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  147. } else if(flag & LINEAR) {
  148. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  149. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  150. } else if(flag & NEAREST_MIPMAP_NEAREST){
  151. glTexParameteri(target,GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
  152. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  153. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
  154. } else if(flag & LINEAR_MIPMAP_NEAREST) {
  155. glTexParameteri(target,GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
  156. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  157. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
  158. } else if(flag & LINEAR_MIPMAP_LINEAR) {
  159. glTexParameteri(target,GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
  160. glTexParameteri(target,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  161. glTexParameteri(target,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  162. }
  163. if(flag & ANISOTROPY_2) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,2.0);
  164. else if(flag & ANISOTROPY_4) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,4.0);
  165. else if(flag & ANISOTROPY_8) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,8.0);
  166. else if(flag & ANISOTROPY_16) glTexParameterf(target,GL_TEXTURE_MAX_ANISOTROPY_EXT,16.0);
  167. if(target == TEXTURE_2D || target == TEXTURE_RECT) {
  168. unsigned char *data = load(name,width,height);
  169. if(data && format != GL_RGBA) {
  170. if(format == GL_LUMINANCE) data = rgba2luminance(data,width,height);
  171. else if(format == GL_LUMINANCE_ALPHA) data = rgba2luminance_alpha(data,width,height);
  172. else if(format == GL_RGB) data = rgba2rgb(data,width,height);
  173. }
  174. glTexImage2D(target,0,format,width,height,0,format,GL_UNSIGNED_BYTE,data);
  175. if(data) delete data;
  176. } else if(target == TEXTURE_CUBE) {
  177. GLuint targets[6] = {
  178. GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
  179. GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
  180. GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
  181. };
  182. char *suffix[6] = { "px", "nx", "py", "ny", "pz", "nz" };
  183. for(int i = 0; i < 6; i++) {
  184. char buf[1024];
  185. sprintf(buf,name,suffix[i]);
  186. unsigned char *data = load(buf,width,height);
  187. if(data && format != GL_RGBA) {
  188. if(format == GL_LUMINANCE) data = rgba2luminance(data,width,height);
  189. else if(format == GL_LUMINANCE_ALPHA) data = rgba2luminance_alpha(data,width,height);
  190. else if(format == GL_RGB) data = rgba2rgb(data,width,height);
  191. }
  192. glTexImage2D(targets[i],0,format,width,height,0,format,GL_UNSIGNED_BYTE,data);
  193. if(data) delete data;
  194. }
  195. } else if(target == TEXTURE_3D) {
  196. int fmt;
  197. unsigned char *data = load_3d(name,width,height,depth,fmt);
  198. if(fmt == LUMINANCE) format = GL_LUMINANCE;
  199. else if(fmt == LUMINANCE_ALPHA) format = GL_LUMINANCE_ALPHA;
  200. else if(fmt == RGBA) format = GL_RGBA;
  201. else format = GL_RGB;
  202. glTexImage3D(target,0,format,width,height,depth,0,format,GL_UNSIGNED_BYTE,data);
  203. if(data) delete data;
  204. }
  205. }
  207. /*
  208.  */
  209. void Texture::enable() {
  210. glEnable(target);
  211. }
  213. /*
  214.  */
  215. void Texture::disable() {
  216. glDisable(target);
  217. }
  219. /*
  220.  */
  221. void Texture::bind() {
  222. glBindTexture(target,id);
  223. }
  225. /*
  226.  */
  227. void Texture::copy(GLuint target) {
  228. if(target == 0) glCopyTexSubImage2D(this->target,0,0,0,0,0,width,height);
  229. else glCopyTexSubImage2D(target,0,0,0,0,0,width,height);
  230. }
  232. /*
  233.  */
  234. void Texture::render(float x0,float y0,float x1,float y1) {
  235. glBegin(GL_QUADS);
  236. if(target == TEXTURE_RECT) {
  237. glTexCoord2f(0,0);
  238. glVertex2f(x0,y0);
  239. glTexCoord2f(width,0);
  240. glVertex2f(x1,y0);
  241. glTexCoord2f(width,height);
  242. glVertex2f(x1,y1);
  243. glTexCoord2f(0,height);
  244. glVertex2f(x0,y1);
  245. } else {
  246. glTexCoord2f(0,0);
  247. glVertex2f(x0,y0);
  248. glTexCoord2f(1,0);
  249. glVertex2f(x1,y0);
  250. glTexCoord2f(1,1);
  251. glVertex2f(x1,y1);
  252. glTexCoord2f(0,1);
  253. glVertex2f(x0,y1);
  254. }
  255. glEnd();
  256. }
  258. /*****************************************************************************/
  259. /*                                                                           */
  260. /* IO functions                                                              */
  261. /*                                                                           */
  262. /*****************************************************************************/
  264. /* images
  265.  */
  266. unsigned char *Texture::load(const char *name,int &width,int &height) {
  267. char *ext = strrchr(name,'.');
  268. if(!ext) {
  269. fprintf(stderr,"Texture::load(): unknown format of "%s" file",name);
  270. return NULL;
  271. }
  272. unsigned char *data = NULL;
  273. if(!strcmp(ext,".tga")) data = load_tga(name,width,height);
  274. else if(!strcmp(ext,".png")) data = load_png(name,width,height);
  275. else if(!strcmp(ext,".jpg")) data = load_jpeg(name,width,height);
  276. else if(!strcmp(ext,".dds")) data = load_dds(name,width,height);
  277. else fprintf(stderr,"Texture::load(): unknown format of "%s" file",name);
  278. return data;
  279. }
  281. int Texture::save(const char *name,const unsigned char *data,int width,int height) {
  282. char *ext = strrchr(name,'.');
  283. if(!ext) {
  284. fprintf(stderr,"Texture::save(): unknown format of "%s" file",name);
  285. return 0;
  286. }
  287. int ret = 0;
  288. if(!strcmp(ext,".tga")) ret = save_tga(name,data,width,height);
  289. else if(!strcmp(ext,".jpg")) ret = save_jpeg(name,data,width,height,80);
  290. else fprintf(stderr,"Texture::save(): unknown format of "%s" file",name);
  291. return ret;
  292. }
  294. /*****************************************************************************/
  295. /*                                                                           */
  296. /* load and save                                                             */
  297. /*                                                                           */
  298. /*****************************************************************************/
  300. /* load tga image
  301.  * only for 24 and 32 bits per pixel
  302.  */
  303. unsigned char *Texture::load_tga(const char *name,int &width,int &height) {
  304. int i,j,k,l,components,size;
  305. unsigned char rep,*data,*buf,*ptr,info[18];
  306. FILE *file = fopen(name,"rb");
  307. if(!file) {
  308. fprintf(stderr,"Texture::load_tga(): error open "%s" filen",name);
  309. return NULL;
  310. }
  311. fread(&info,1,18,file);
  312. width = info[12] + info[13] * 256;
  313. height = info[14] + info[15] * 256;
  314. switch(info[16]) {
  315. case 32: components = 4; break;
  316. case 24: components = 3; break;
  317. default: fclose(file); return NULL;
  318. }
  319. size = width * height * components;
  320. buf = new unsigned char[size];
  321. data = new unsigned char[width * height * 4];
  322. if(!data || !buf) {
  323. fclose(file);
  324. return NULL;
  325. }
  326. fseek(file,info[0],SEEK_CUR);
  327. switch(info[2]) {
  328. case 2: fread(buf,1,size,file); break;
  329.         case 10:
  330. i = 0;
  331. ptr = buf;
  332. while(i < size) {
  333. fread(&rep,1,1,file);
  334. if(rep & 0x80) {
  335. rep ^= 0x80;
  336. fread(ptr,1,components,file);
  337. ptr += components;
  338. for(j = 0; j < rep * components; j++) {
  339. *ptr = *(ptr - components);
  340. ptr ++;
  341. }
  342. i += components * (rep + 1);
  343. } else {
  344. k = components * (rep + 1);
  345. fread(ptr,1,k,file);
  346. ptr += k;
  347. i += k;
  348. }
  349. }
  350. break;
  351. default:
  352. fclose(file);
  353. delete buf;
  354. delete data;
  355. return NULL;
  356. }
  357. for(i = 0, j = 0; i < size; i += components, j += 4) {
  358. data[j] = buf[i + 2];
  359. data[j + 1] = buf[i + 1];
  360. data[j + 2] = buf[i];
  361. if(components == 4) data[j + 3] = buf[i + 3];
  362. else data[j + 3] = 255;
  363. }
  364. if(!(info[17] & 0x20)) {
  365. for(j = 0, k = width * 4; j < height / 2; j++) {
  366. for(i = 0; i < width * 4; i++) {
  367. l = data[j * k + i];
  368. data[j * k + i] = data[(height - j - 1) * k + i];
  369. data[(height - j - 1) * k + i] = l;
  370. }
  371. }
  372. }
  373. fclose(file);
  374. delete buf;
  375. return data;
  376. }
  378. /* save tga image
  379.  */
  380. int Texture::save_tga(const char *name,const unsigned char *data,int width,int height) {
  381. int i,j;
  382. unsigned char *buf;
  383. FILE *file = fopen(name,"wb");
  384. if(!file) {
  385. fprintf(stderr,"Texture::save_tga(): error create "%s" filen",name);
  386. return 0;
  387. }
  388. buf = new unsigned char[18 + width * height * 4];
  389. memset(buf,0,18);
  390. buf[2] = 2;
  391. buf[12] = width % 256;
  392. buf[13] = width / 256;
  393. buf[14] = height % 256;
  394. buf[15] = height / 256;
  395. buf[16] = 32;
  396. buf[17] = 0x28;
  397. memcpy(buf + 18,data,width * height * 4);
  398. for(i = 18; i < 18 + width * height * 4; i += 4) {
  399. j = buf[i];
  400. buf[i] = buf[i + 2];
  401. buf[i + 2] = j;
  402. }
  403. fwrite(buf,1,18 + width * height * 4,file);
  404. fclose(file);
  405. delete buf;
  406. return 1;
  407. }
  409. /* load png image
  410.  */
  411. unsigned char *Texture::load_png(const char *name,int &width,int &height) {
  412. FILE *file = fopen(name,"rb");
  413. if(!file) {
  414. fprintf(stderr,"Texture::load_png(): error open "%s" filen",name);
  415. return NULL;
  416. }
  417. png_byte sig[8];
  418. fread(sig,8,1,file);
  419. if(!png_check_sig(sig,8)) {
  420. fprintf(stderr,"Texture::load_png(): wrong signature in "%s" filen",name);
  421. fclose(file);
  422. return NULL;
  423. }
  424. png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
  425. if(!png_ptr) {
  426. fclose(file);
  427. return NULL;
  428. }
  429. png_infop info_ptr = png_create_info_struct(png_ptr);
  430. if(!info_ptr) {
  431. png_destroy_read_struct(&png_ptr,0,0);
  432. fclose(file);
  433. return NULL;
  434. }
  435. png_init_io(png_ptr,file);
  436. png_set_sig_bytes(png_ptr,8);
  437. png_read_info(png_ptr,info_ptr);
  438. unsigned long w,h;
  439. int bit_depth,color_type;
  440. png_get_IHDR(png_ptr,info_ptr,&w,&h,&bit_depth,&color_type,0,0,0);
  441. if(bit_depth == 16) png_set_strip_16(png_ptr);
  442. if(color_type == PNG_COLOR_TYPE_PALETTE) png_set_expand(png_ptr);
  443. if(bit_depth < 8) png_set_expand(png_ptr);
  444. if(png_get_valid(png_ptr,info_ptr,PNG_INFO_tRNS)) png_set_expand(png_ptr);
  445. if(color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr);
  446. double gamma;
  447. if(png_get_gAMA(png_ptr,info_ptr,&gamma)) png_set_gamma(png_ptr,(double)2.2,gamma);
  448. png_read_update_info(png_ptr,info_ptr);
  449. png_get_IHDR(png_ptr,info_ptr,&w,&h,&bit_depth,&color_type,0,0,0);
  450. png_uint_32 row_bytes = png_get_rowbytes(png_ptr,info_ptr);
  451. png_uint_32 channels = png_get_channels(png_ptr,info_ptr);
  452. png_byte *img = new png_byte[row_bytes * h];
  453. png_byte **row = new png_byte*[h];
  454. for(int i = 0; i < (int)h; i++) row[i] = img + row_bytes * i;
  455. png_read_image(png_ptr,row);
  456. png_read_end(png_ptr,NULL);
  457. png_destroy_read_struct(&png_ptr,0,0);
  458. fclose(file);
  459. delete row;
  460. width = w;
  461. height = h;
  462. unsigned char *data = new unsigned char[width * height * 4];
  463. unsigned char *ptr = data;
  464. for(int i = 0; i < height; i++) {
  465. for(int j = 0; j < width; j++) {
  466. int k = row_bytes * i + j * channels;
  467. *ptr++ = img[k + 0];
  468. *ptr++ = img[k + 1];
  469. *ptr++ = img[k + 2];
  470. if(channels == 4) *ptr++ = img[k + 3];
  471. else *ptr++ = 255;
  472. }
  473. }
  474. delete img;
  475. return data;
  476. }
  478. /* load jpeg image
  479.  */
  480. struct my_error_mgr {
  481. struct jpeg_error_mgr pub;
  482. jmp_buf setjmp_buffer;
  483. };
  485. typedef struct my_error_mgr *my_error_ptr;
  487. static void my_error_exit(j_common_ptr cinfo) {
  488. my_error_ptr myerr = (my_error_ptr)cinfo->err;
  489. (*cinfo->err->output_message)(cinfo);
  490. longjmp(myerr->setjmp_buffer,1);
  491. }
  493. unsigned char *Texture::load_jpeg(const char *name,int &width,int &height) {
  494. struct jpeg_decompress_struct cinfo;
  495. struct my_error_mgr jerr;
  496. FILE *file;
  497. JSAMPARRAY buffer;
  498. int row_stride;
  499. long cont;
  500. JSAMPLE *data_buffer;
  501. int i,j;
  502. unsigned char *data;
  503. file = fopen(name,"rb");
  504. if(!file) {
  505. fprintf(stderr,"Texture::load_jpeg(): error open "%s" filen",name);
  506. return NULL;
  507. }
  508. cinfo.err = jpeg_std_error(&jerr.pub);
  509. jerr.pub.error_exit = my_error_exit;
  510. if(setjmp(jerr.setjmp_buffer)) {
  511. jpeg_destroy_decompress(&cinfo);
  512. fclose(file);
  513. return NULL;
  514. }
  515. jpeg_create_decompress(&cinfo);
  516. jpeg_stdio_src(&cinfo,file);
  517. jpeg_read_header(&cinfo,TRUE);
  518. jpeg_start_decompress(&cinfo);
  519. row_stride = cinfo.output_width * cinfo.output_components;
  520. buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo,JPOOL_IMAGE,row_stride,1);
  521. data_buffer = new JSAMPLE[cinfo.image_width * cinfo.image_height * cinfo.output_components];
  522. cont = 0;
  523. while(cinfo.output_scanline < cinfo.output_height) {
  524. jpeg_read_scanlines(&cinfo,buffer,1);
  525. memcpy(data_buffer + cinfo.image_width * cinfo.output_components * cont,buffer[0],row_stride);
  526. cont++;
  527. }
  528. jpeg_finish_decompress(&cinfo);
  529. jpeg_destroy_decompress(&cinfo);
  530. width = cinfo.image_width;
  531. height = cinfo.image_height;
  532. data = new unsigned char[width * height * 4];
  533. switch(cinfo.output_components) {
  534. case 1:
  535. for(i = 0, j = 0; i < width * height; i++, j += 4) {
  536. data[j] = data[j + 1] = data[j + 2] = data_buffer[i];
  537. data[j + 3] = 255;
  538. }
  539. break;
  540. case 3:
  541. for(i = 0, j = 0; i < width * height * 3; i += 3, j += 4) {
  542. data[j] = data_buffer[i];
  543. data[j + 1] = data_buffer[i + 1];
  544. data[j + 2] = data_buffer[i + 2];
  545. data[j + 3] = 255;
  546. }
  547. break;
  548. default:
  549. delete data;
  550. delete data_buffer;
  551. return NULL;
  552. }
  553. delete data_buffer;
  554. fclose(file);
  555. return data;
  556. }
  558. /* save jpeg image
  559.  */
  560. int Texture::save_jpeg(const char *name,const unsigned char *data,int width,int height,int quality) {
  561. struct jpeg_compress_struct cinfo;
  562. struct jpeg_error_mgr jerr;
  563. JSAMPROW row_pointer[1];
  564. int i,j,row_stride;
  565. unsigned char *data_buffer;
  566. FILE *file = fopen(name,"wb");
  567. if(!file) {
  568. fprintf(stderr,"Texture::load_jpeg(): error create "%s" filen",name);
  569. return 0;
  570. }
  571. data_buffer = new unsigned char[width * height * 3];
  572. for(i = 0, j = 0; i < width * height * 4; i += 4, j += 3) {
  573. data_buffer[j + 0] = data[i + 0];
  574. data_buffer[j + 1] = data[i + 1];
  575. data_buffer[j + 2] = data[i + 2];
  576. }
  577. cinfo.err = jpeg_std_error(&jerr);
  578. jpeg_create_compress(&cinfo);
  579. jpeg_stdio_dest(&cinfo,file);
  580. cinfo.image_width = width;
  581. cinfo.image_height = height;
  582. cinfo.input_components = 3;
  583. cinfo.in_color_space = JCS_RGB;
  584. jpeg_set_defaults(&cinfo);
  585. jpeg_set_quality(&cinfo,quality,TRUE);
  586. jpeg_start_compress(&cinfo,TRUE);
  587. row_stride = width * 3;
  588. while(cinfo.next_scanline < cinfo.image_height) {
  589. row_pointer[0] = &data_buffer[cinfo.next_scanline * row_stride];
  590. jpeg_write_scanlines(&cinfo,row_pointer,1);
  591. }
  592. jpeg_finish_compress(&cinfo);
  593. jpeg_destroy_compress(&cinfo);
  594. delete data_buffer;
  595. fclose(file);
  596. return 1;
  597. }
  599. /* load DDS image
  600.  */
  601. struct dds_colorkey {
  602. unsigned int dwColorSpaceLowValue;
  603. unsigned int dwColorSpaceHighValue;
  604. };
  606. struct dds_header {
  607. unsigned int magic;
  608. unsigned int dwSize;
  609. unsigned int dwFlags;
  610. unsigned int dwHeight;
  611. unsigned int dwWidth;
  612. long lPitch;
  613. unsigned int dwDepth;
  614. unsigned int dwMipMapCount;
  615. unsigned int dwAlphaBitDepth;
  616. unsigned int dwReserved;
  617. void *lpSurface;
  618. dds_colorkey ddckCKDestOverlay;
  619. dds_colorkey ddckCKDestBlt;
  620. dds_colorkey ddckCKSrcOverlay;
  621. dds_colorkey ddckCKSrcBlt;
  622. unsigned int dwPFSize;
  623. unsigned int dwPFFlags;
  624. unsigned int dwFourCC;
  625. unsigned int dwRGBBitCount;
  626. unsigned int dwRBitMask;
  627. unsigned int dwGBitMask;
  628. unsigned int dwBBitMask;
  629. unsigned int dwRGBAlphaBitMask;
  630. unsigned int dwCaps;
  631. unsigned int dwCaps2;
  632. unsigned int dwCaps3;
  633. unsigned int dwVolumeDepth;
  634. unsigned int dwTextureStage;
  635. };
  637. struct dds_color {
  638. unsigned char r;
  639. unsigned char g;
  640. unsigned char b;
  641. };
  643. enum {
  644. DDS_ERROR = -1,
  645. DDS_RGB,
  646. DDS_RGBA,
  647. DDS_DXT1,
  648. DDS_DXT2,
  649. DDS_DXT3,
  650. DDS_DXT4,
  651. DDS_DXT5
  652. };
  654. enum {
  655. DDPF_ALPHAPIXELS = 0x01,
  656. DDPF_FOURCC = 0x04,
  657. DDPF_RGB = 0x40,
  658. DDPF_RGBA = 0x41
  659. };
  661. unsigned char *Texture::load_dds(const char *name,int &width,int &height) {
  662. FILE *file = fopen(name,"rb");
  663. if(!file) {
  664. fprintf(stderr,"Texture::load_dds(): error open "%s" filen",name);
  665. return NULL;
  666. }
  667. dds_header header;
  668. fread(&header,sizeof(dds_header),1,file);
  669. if(header.magic != ('D' | 'D' << 8 | 'S' << 16 | ' ' << 24)) {
  670. fprintf(stderr,"Texture::load_dds(): wrong magic in "%s" filen",name);
  671. fclose(file);
  672. return NULL;
  673. }
  674. width = header.dwWidth;
  675. height = header.dwHeight;
  676. int format = DDS_ERROR;
  677. if(header.dwPFFlags & DDPF_FOURCC) {
  678. switch(header.dwFourCC) {
  679. case ('D' | 'X' << 8 | 'T' << 16 | '1' << 24): format = DDS_DXT1; break;
  680. case ('D' | 'X' << 8 | 'T' << 16 | '2' << 24): format = DDS_DXT2; break;
  681. case ('D' | 'X' << 8 | 'T' << 16 | '3' << 24): format = DDS_DXT3; break;
  682. case ('D' | 'X' << 8 | 'T' << 16 | '4' << 24): format = DDS_DXT4; break;
  683. case ('D' | 'X' << 8 | 'T' << 16 | '5' << 24): format = DDS_DXT5; break;
  684. }
  685. }
  686. else if(header.dwPFFlags == DDPF_RGB && header.dwRGBBitCount == 24) format = DDS_RGB;
  687. else if(header.dwPFFlags == DDPF_RGBA && header.dwRGBBitCount == 32) format = DDS_RGBA;
  688. else {
  689. fprintf(stderr,"Texture::load_dds(): unknown format of "%s" filen",name);
  690. fclose(file);
  691. return NULL;
  692. }
  693. if(format == DDS_DXT2 || format == DDS_DXT4) {
  694. fprintf(stderr,"Texture::load_dds(): DXT2 or DXT4 is not supported in "%s" filen",name);
  695. fclose(file);
  696. return NULL;
  697. }
  698. unsigned char *data = new unsigned char[width * height * 4];
  699. if(format == DDS_RGB) {
  700. unsigned char *buf = new unsigned char[width * height * 3];
  701. fread(buf,width * height * 3,1,file);
  702. unsigned char *src = buf;
  703. unsigned char *dest = data;
  704. for(int y = 0; y < height; y++) {
  705. for(int x = 0; x < width; x++) {
  706. *dest++ = *src++;
  707. *dest++ = *src++;
  708. *dest++ = *src++;
  709. *dest++ = 255;
  710. }
  711. }
  712. delete buf;
  713. } else if(format == DDS_RGBA) {
  714. unsigned char *buf = new unsigned char[width * height * 4];
  715. fread(buf,width * height * 4,1,file);
  716. unsigned char *src = buf;
  717. unsigned char *dest = data;
  718. for(int y = 0; y < height; y++) {
  719. for(int x = 0; x < width; x++) {
  720. *dest++ = *src++;
  721. *dest++ = *src++;
  722. *dest++ = *src++;
  723. *dest++ = *src++;
  724. }
  725. }
  726. delete buf;
  727. } else {
  728. unsigned char *buf = new unsigned char[width * height];
  729. unsigned char *src = buf;
  730. fread(buf,width * height,1,file);
  731. for(int y = 0; y < height; y += 4) {
  732. for(int x = 0; x < width; x += 4) {
  733. unsigned long long alpha = 0;
  734. unsigned int a0 = 0;
  735. unsigned int a1 = 0;
  736. if(format == DDS_DXT3) {
  737. alpha = *(unsigned long long*)src;
  738. src += 8;
  739. } else if(format == DDS_DXT5) {
  740. alpha=  (*(unsigned long long*)src) >> 16;
  741. a0 = src[0];
  742. a1 = src[1];
  743. src += 8;
  744. }
  745. unsigned int c0 = *(unsigned short*)(src + 0);
  746. unsigned int c1 = *(unsigned short*)(src + 2);
  747. src += 4;
  748. dds_color color[4];
  749. color[0].r = ((c0 >> 11) & 0x1f) << 3;
  750. color[0].g = ((c0 >> 5) & 0x3f) << 2;
  751. color[0].b = (c0 & 0x1f) << 3;
  752. color[1].r = ((c1 >> 11) & 0x1f) << 3;
  753. color[1].g = ((c1 >> 5) & 0x3f) << 2;
  754. color[1].b = (c1 & 0x1f) << 3;
  755. if(c0 > c1) {
  756. color[2].r = (color[0].r * 2 + color[1].r) / 3;
  757. color[2].g = (color[0].g * 2 + color[1].g) / 3;
  758. color[2].b = (color[0].b * 2 + color[1].b) / 3;
  759. color[3].r = (color[0].r + color[1].r * 2) / 3;
  760. color[3].g = (color[0].g + color[1].g * 2) / 3;
  761. color[3].b = (color[0].b + color[1].b * 2) / 3;
  762. } else {
  763. color[2].r = (color[0].r + color[1].r) / 2;
  764. color[2].g = (color[0].g + color[1].g) / 2;
  765. color[2].b = (color[0].b + color[1].b) / 2;
  766. color[3].r = 0;
  767. color[3].g = 0;
  768. color[3].b = 0;
  769. }
  770. for(int i = 0; i < 4; i++) {
  771. unsigned int index = *src++;
  772. unsigned char *dest = data + (width * (y + i) + x) * 4;
  773. for(int j = 0; j < 4; j++) {
  774. *dest++ = color[index & 0x03].r;
  775. *dest++ = color[index & 0x03].g;
  776. *dest++ = color[index & 0x03].b;
  777. if(format == DDS_DXT1) {
  778. *dest++ = ((index & 0x03) == 3 && c0 <= c1) ? 0 : 255;
  779. } else if(format == DDS_DXT3) {
  780. *dest++ = (alpha & 0x0f) << 4;
  781. alpha >>= 4;
  782. } else if(format == DDS_DXT5) {
  783. unsigned int a = alpha & 0x07;
  784. if(a == 0) *dest++ = a0;
  785. else if(a == 1) *dest++ = a1;
  786. else if(a0 > a1) *dest++ = ((8 - a) * a0 + (a - 1) * a1) / 7;
  787. else if(a > 5) *dest++ = (a == 6) ? 0 : 255;
  788. else *dest++ = ((6 - a) * a0 + (a - 1) * a1) / 5;
  789. alpha >>= 3;
  790. } else *dest++ = 255;
  791. index >>= 2;
  792. }
  793. }
  794. }
  795. }
  796. delete buf;
  797. }
  798. fclose(file);
  799. return data;
  800. }
  802. /*****************************************************************************/
  803. /*                                                                           */
  804. /* converters                                                                */
  805. /*                                                                           */
  806. /*****************************************************************************/
  808. unsigned char *Texture::rgba2rgb(unsigned char *data,int width,int height) {
  809. unsigned char *dest = new unsigned char[width * height * 3];
  810. unsigned char *d = dest;
  811. unsigned char *s = data;
  812. for(int i = 0; i < width * height; i++) {
  813. *d++ = *s++;
  814. *d++ = *s++;
  815. *d++ = *s++;
  816. s++;
  817. }
  818. delete data;
  819. return dest;
  820. }
  822. unsigned char *Texture::rgba2luminance(unsigned char *data,int width,int height) {
  823. unsigned char *dest = new unsigned char[width * height];
  824. unsigned char *d = dest;
  825. unsigned char *s = data;
  826. for(int i = 0; i < width * height; i++) {
  827. *d++ = *s++;
  828. s += 3;
  829. }
  830. delete data;
  831. return dest;
  832. }
  834. unsigned char *Texture::rgba2luminance_alpha(unsigned char *data,int width,int height) {
  835. unsigned char *dest = new unsigned char[width * height * 2];
  836. unsigned char *d = dest;
  837. unsigned char *s = data;
  838. for(int i = 0; i < width * height; i++) {
  839. *d++ = *s++;
  840. s += 2;
  841. *d++ = *s++;
  842. }
  843. delete data;
  844. return dest;
  845. }
  847. /*****************************************************************************/
  848. /*                                                                           */
  849. /* 3d textures                                                               */
  850. /*                                                                           */
  851. /*****************************************************************************/
  853. unsigned char *Texture::load_3d(const char *name,int &width,int &height,int &depth,int &format) {
  854. FILE *file = fopen(name,"rb");
  855. if(!file) {
  856. fprintf(stderr,"Texture::load_3d(): error open "%s" filen",name);
  857. return NULL;
  858. }
  859. int magic;
  860. fread(&magic,sizeof(int),1,file);
  861. if(magic != ('3' | 'D' << 8 | 'T' << 16 | 'X' << 24)) {
  862. fprintf(stderr,"Texture::load_3d(): wrong magic in "%s" filen",name);
  863. fclose(file);
  864. return NULL;
  865. }
  866. fread(&width,sizeof(int),1,file);
  867. fread(&height,sizeof(int),1,file);
  868. fread(&depth,sizeof(int),1,file);
  869. fread(&format,sizeof(int),1,file);
  870. int size = width * height * depth;
  871. if(format == LUMINANCE) size *= 1;
  872. else if(format == LUMINANCE_ALPHA) size *= 2;
  873. else if(format == RGB) size *= 3;
  874. else if(format == RGBA) size *= 4;
  875. else {
  876. fprintf(stderr,"Texture::load_3d(): unknown format of "%s" filen",name);
  877. fclose(file);
  878. return NULL;
  879. }
  880. unsigned char *data = new unsigned char[size];
  881. fread(data,sizeof(unsigned char),size,file);
  882. fclose(file);
  883. return data;
  884. }
  886. /*
  887.  */
  888. int Texture::save_3d(const char *name,const unsigned char *data,int width,int height,int depth,int format) {
  889. FILE *file = fopen(name,"wb");
  890. if(!file) {
  891. fprintf(stderr,"Texture::save_3d(): error create "%s" filen",name);
  892. return 0;
  893. }
  894. int magic = ('3' | 'D' << 8 | 'T' << 16 | 'X' << 24);
  895. fwrite(&magic,sizeof(int),1,file);
  896. fwrite(&width,sizeof(int),1,file);
  897. fwrite(&height,sizeof(int),1,file);
  898. fwrite(&depth,sizeof(int),1,file);
  899. fwrite(&format,sizeof(int),1,file);
  900. int size = width * height * depth;
  901. if(format == LUMINANCE) size *= 1;
  902. else if(format == LUMINANCE_ALPHA) size *= 2;
  903. else if(format == RGB) size *= 3;
  904. else if(format == RGBA) size *= 4;
  905. else fprintf(stderr,"Texture::save_3d(): unknown formatn");
  906. fwrite(data,sizeof(unsigned char),size,file);
  907. fclose(file);
  908. return 1;
  909. }