PNG图片数据解析

PNG是一种非常流行的图片格式，它不仅支持透明效果，而且图片数据经过了压缩处理，所以广泛用于web等应用。

PNG的文件格式：

　　PNG文件中的数据，总是以一个固定的8个字节开头：

　　　　（图片来自http://blog.csdn.net/bisword/article/details/2777121）

　　除此之外，PNG的其他数据都是以数据块的方式组织，它们被分为标准数据块和辅助数据块，其中的辅助数据块是可选的。关键数据块包含我们必须的图片信息，我们之后要重点解析的也是关键数据块。

　　（图片来自http://blog.csdn.net/bisword/article/details/2777121）

每种数据块的结构：

　　　　（图片来自http://blog.csdn.net/bisword/article/details/2777121）

　　Length：该数据块的中Chunk Data的长度；

　　Chunk Type Code：数据类型，就是指上面提到的IHDR，IEND等；

　　Chunk Data：数据区域，如果是IDAT，就表示存储的还未解压的图片数据；

　　CRC：循环冗余效验码；

具体实现：（实现中没有处理png数据中变形的情况，部分头中的宏定义来自libpng，实例不具备实用性，仅作参考）

头文件：

  1 #ifndef __PNG__
  2 #define __PNG__
  3 
  4 #include <stdio.h>
  5 #include <stdlib.h>
  6 #include <math.h>
  7 #include "zlib/zlib.h"
  8 
  9 /**
 10  * 类型标志
 11  */
 12 #define PNG_FLAG_HEX "89504E470D0A1A0A"
 13 
 14 /**
 15  * 数据块类型
 16  */
 17 #define DATA_CHUNK_TYPE_IHDR "IHDR"
 18 #define DATA_CHUNK_TYPE_IDAT "IDAT"
 19 #define DATA_CHUNK_TYPE_IEND "IEND"
 20 #define DATA_CHUNK_TYPE_tEXt "tEXt"
 21 #define DATA_CHUNK_TYPE_iTXt "iTXt"
 22 
 23 /**
 24  * 过滤方式
 25  */
 26 #define DATA_FILTER_TYPE_DEFAULT 0
 27 #define DATA_FILTER_TYPE_ADD_ROW 1
 28 #define DATA_FILTER_TYPE_ADD_UP  2
 29 #define DATA_FILTER_TYPE_AVERGE  3
 30 #define DATA_FILTER_TYPE_PAETH   4
 31 
 32 /* color type masks */
 33 #define PNG_COLOR_MASK_PALETTE    1
 34 #define PNG_COLOR_MASK_COLOR      2
 35 #define PNG_COLOR_MASK_ALPHA      4
 36 
 37 /* color types.  Note that not all combinations are legal */
 38 #define PNG_COLOR_TYPE_GRAY           0
 39 #define PNG_COLOR_TYPE_PALETTE    (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
 40 #define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)
 41 #define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
 42 #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
 43 
 44 #define RGB_USE_ALPHA(vr, vg, vb, va) \
 45     (unsigned)(((unsigned)((unsigned char)(vr) * ((unsigned char)(va) + 1)) >> 8) | \
 46     ((unsigned)((unsigned char)(vg) * ((unsigned char)(va) + 1) >> 8) << 8) | \
 47     ((unsigned)((unsigned char)(vb) * ((unsigned char)(va) + 1) >> 8) << 16) | \
 48     ((unsigned)(unsigned char)(va) << 24))
 49 
 50 /**
 51  * 一次解压图片数据的限制
 52  */
 53 #define DECOMPRESSION_MAX_BYTES 8192
 54 
 55 /**
 56  * 数据块信息
 57  */
 58 typedef struct _DataChunkHeader 
 59 {
 60     // 数据长度
 61     unsigned char length[4];
 62     // 数据类型
 63     unsigned char type[4];
 64 } DataChunkHeader;
 65 
 66 /**
 67  * IHDR数据
 68  */
 69 typedef struct _IDHRData
 70 {
 71     unsigned char width[4];
 72     unsigned char height[4];
 73     unsigned char bitDepth[1];
 74     unsigned char colorType[1];
 75     unsigned char compressionMethod[1];
 76     unsigned char filterMethod[1];
 77     unsigned char interlaceMethod[1];
 78 } IDHRData;
 79 
 80 /**
 81  * PNG图片类
 82  */
 83 class PNG
 84 {
 85 public:
 86     PNG();
 87     PNG(const char* filePath);
 88 
 89     ~PNG();
 90 
 91     int getWindth();
 92     int getHeight();
 93 
 94     /**
 95      * 获取图片宽度
 96      */
 97     unsigned char* getImageData();
 98 
 99 private:
100     int m_width;
101     int m_height;
102 
103     unsigned char m_bitDepth;
104     unsigned char m_colorType;
105     unsigned char m_compressionMethod;
106     unsigned char m_filterMethod;
107     unsigned char m_interlaceMethod;
108     unsigned char m_chanels;
109 
110     unsigned char* m_imageData;
111 
112     /**
113      * 从文件加载图片数据
114      */
115     bool loadImageDataFromFile(const char* filePath);
116 
117     /**
118      * 解析数值
119      */
120     int parseNumber(const unsigned char* data, int len);
121 
122     /**
123      * 解压数据
124      */
125     int decompressData(z_stream* zStream, unsigned char* data, int dataLen, int leftLen, FILE *pFile);
126 
127     /**
128      * 生成图片数据
129      */
130     void generateImageData(unsigned char* data, unsigned long dataLen);
131 
132     /**
133      * 默认的过滤方式
134      */
135     void defaultFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);
136 
137     /**
138      * 当前行相加的过滤方式
139      */
140     void addCurrentRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);
141 
142     /**
143      * 前一行相加的过滤方式
144      */
145     void addUpRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);
146 
147     /**
148      * 平均的过滤方式
149      */
150     void avergeFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);
151 
152     /**
153      * paeth的过滤方式
154      */
155     void paethFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);
156 
157     /**
158      * 解析IHDR数据
159      */
160     void parseIHDRData(DataChunkHeader& dataChunkHeader, FILE* pFile);
161 
162     /**
163      * 解析IDAT数据
164      */
165     void parseIDATData(DataChunkHeader& dataChunkHeader, FILE* pFile);
166 
167     /**
168      * 解析IEND数据
169      */
170     void parseIENDData(DataChunkHeader& dataChunkHeader, FILE *pFile);
171 
172     /**
173      * 解析其他数据
174      */
175     void parseCommonData(DataChunkHeader& dataChunkHeader, FILE *pFile);
176 };
177 
178 #endif

cpp文件：

  1 #include "png.h"
  2 #include "utils/cUtil.h"
  3 #include <stdlib.h>
  4 
  5 #include <windows.h>
  6 
  7 /**
  8  * 默认构造函数
  9  */
 10 PNG::PNG()
 11 {
 12     this->m_width = 0;
 13     this->m_height = 0;
 14 
 15     this->m_imageData = 0;
 16 }
 17 
 18 /**
 19  * 构造函数
 20  * @param filePath 图片路径
 21  */
 22 PNG::PNG(const char *filePath)
 23 {
 24     this->m_width = 0;
 25     this->m_height = 0;
 26 
 27     this->loadImageDataFromFile(filePath);
 28 }
 29 
 30 /**
 31  * 析构函数
 32  */
 33 PNG::~PNG()
 34 {
 35 
 36 }
 37 
 38 /**
 39  * 从文件加载图片数据
 40  */
 41 bool PNG::loadImageDataFromFile(const char* filePath)
 42 {
 43     FILE* pFile = fopen(filePath, "rb");
 44     if (!pFile)
 45         return false;
 46 
 47     // 解析PNG标志
 48     char flag[8];
 49     char hexFlag[17];
 50     fread(flag, 1, 8, pFile);
 51     toHexStr(flag, 8, hexFlag);
 52     if (strcmp(hexFlag, PNG_FLAG_HEX) != 0)
 53         return false;
 54 
 55     // 解析图片数据
 56     DataChunkHeader dataChunkHeader;
 57     char dataChunkHeaderType[5];
 58     do {
 59         fread(&dataChunkHeader, 1, sizeof(DataChunkHeader), pFile);
 60 
 61         memcpy(dataChunkHeaderType, dataChunkHeader.type, 4);
 62         dataChunkHeaderType[4] = '\0';
 63 
 64         // IHDR
 65         if ( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IHDR) == 0 ) {
 66             this->parseIHDRData(dataChunkHeader, pFile);
 67         }
 68         // IDAT
 69         else if ( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IDAT) == 0 ) {
 70             this->parseIDATData(dataChunkHeader, pFile);
 71         }
 72         // IEND
 73         else if ( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IEND) == 0 ) {
 74             this->parseIENDData(dataChunkHeader, pFile);
 75         }
 76         // 其他数据
 77         else {
 78             this->parseCommonData(dataChunkHeader, pFile);
 79         }
 80     } while( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IEND) != 0 );
 81 
 82     int i = 1;
 83 
 84     return true;
 85 }
 86 
 87 /**
 88  * 解析数值
 89  */
 90 int PNG::parseNumber(const unsigned char* data, int len)
 91 {
 92     char localNum[4];
 93 
 94     bool isLittleEndian = checkEndian();
 95     for (int i = 0; i<4; i++) {
 96         char ch;
 97 
 98         if (isLittleEndian) {
 99             if (i <= len-1)
100                 ch = data[len - 1 - i];
101             else
102                 ch = '\0';
103         }
104         else {
105             if (i <= len-1)
106                 ch = data[i];
107             else
108                 ch = '\0';
109         }
110         localNum[i] = ch;
111     }
112 
113     int num;
114     memcpy(&num, localNum, 4);
115     return num;
116 }
117 
118 /**
119  * 解析IHDR数据
120  */
121 void PNG::parseIHDRData(DataChunkHeader& dataChunkHeader, FILE* pFile)
122 {
123     int dataLen = this->parseNumber(dataChunkHeader.length, 4);
124 
125     IDHRData idhrData;
126     char crc[4];
127 
128     fread(&idhrData, 1, sizeof(IDHRData), pFile);
129     fread(crc, 1, 4, pFile);
130 
131     this->m_width              = this->parseNumber(idhrData.width, 4);
132     this->m_height              = this->parseNumber(idhrData.height, 4);
133     this->m_bitDepth          = this->parseNumber(idhrData.bitDepth, 1);
134     this->m_colorType          = this->parseNumber(idhrData.colorType, 1);
135     this->m_compressionMethod = this->parseNumber(idhrData.compressionMethod, 1);
136     this->m_filterMethod      = this->parseNumber(idhrData.filterMethod, 1);
137     this->m_interlaceMethod   = this->parseNumber(idhrData.interlaceMethod, 1);
138     this->m_chanels              = 0;
139 
140     switch (this->m_colorType) {
141         case PNG_COLOR_TYPE_GRAY:
142         case PNG_COLOR_TYPE_PALETTE:
143             this->m_chanels = 1;
144         break;
145         case PNG_COLOR_TYPE_RGB:
146             this->m_chanels = 3;
147         break;
148         case PNG_COLOR_TYPE_GRAY_ALPHA:
149             this->m_chanels = 2;
150         break;
151         case PNG_COLOR_TYPE_RGB_ALPHA:
152             this->m_chanels = 4;
153         break;
154         default:
155             this->m_chanels = 0;
156         break;
157    }
158 }
159 
160 /**
161  * 解压数据
162  */
163 int PNG::decompressData(z_stream* zStream, unsigned char* data, int dataLen, int leftLen, FILE *pFile)
164 {
165     int result = 0;
166 
167     int leftBytesCount = leftLen;
168     int avail_out = -1;
169     do {
170         if (zStream->avail_in == 0) {
171             if (avail_out == 0) 
172                 break;
173             else {
174                 if (leftBytesCount == 0) {
175                     DataChunkHeader dataChunkHeader;
176                     fread(&dataChunkHeader, 1, sizeof(DataChunkHeader), pFile);
177 
178                     int newDataLen = this->parseNumber(dataChunkHeader.length, 4);
179                     unsigned char* newData = new unsigned char[dataLen + newDataLen];
180                     char crc[4];
181 
182                     fread(newData + dataLen, 1, newDataLen, pFile);
183                     fread(crc, 1, 4, pFile);
184                     memcpy(newData, data, dataLen);
185 
186                     delete data;
187                     data = newData;
188 
189                     zStream->next_in = newData + dataLen;
190                     zStream->avail_in = newDataLen;
191 
192                     dataLen = dataLen + newDataLen;
193                     
194                     return this->decompressData(zStream, data, dataLen, 0, pFile);
195                 }
196             }
197 
198             // 导出数据是否超过限制
199             if (leftBytesCount > DECOMPRESSION_MAX_BYTES)
200                 zStream->avail_in = DECOMPRESSION_MAX_BYTES;
201             else
202                 zStream->avail_in = leftBytesCount;
203 
204             leftBytesCount -= zStream->avail_in;
205         }
206         
207         if (avail_out > 0)
208             zStream->avail_out = avail_out;
209         else
210             zStream->avail_out = m_width * 4 + 1;
211 
212         result = inflate(zStream, Z_NO_FLUSH);
213         if (result != Z_OK)
214             break;
215 
216         avail_out = zStream->avail_out;
217     } while (zStream->avail_in >= 0);
218 
219     return result;
220 }
221 
222 /**
223  * 生成图片数据
224  */
225 void PNG::generateImageData(unsigned char* data, unsigned long dataLen)
226 {
227     // 行字节数
228     int rowBytes = this->m_chanels * this->m_width;
229 
230     // 初始化图片数据
231     this->m_imageData = new unsigned char[rowBytes * this->m_height];
232 
233     unsigned char* pImageData = this->m_imageData;
234     unsigned char* pRowData = data;
235 
236     for (int rowIndex = 0; rowIndex < this->m_height; rowIndex++) {
237         // 过滤类型
238         unsigned char filterType = pRowData[0]; 
239 
240         pRowData += 1;
241 
242         switch (filterType) {
243             // 不需要过滤处理
244             case DATA_FILTER_TYPE_DEFAULT:
245                 this->defaultFilterType(pImageData, pRowData, rowBytes);
246             break;
247             // 当前行相加
248             case DATA_FILTER_TYPE_ADD_ROW:
249                 this->addCurrentRowFilterType(pImageData, pRowData, rowBytes);
250             break;
251             // 和前一行相加
252             case DATA_FILTER_TYPE_ADD_UP:
253                 this->addUpRowFilterType(pImageData, pRowData, rowBytes);
254             break;
255             // 求平均
256             case DATA_FILTER_TYPE_AVERGE:
257                 this->avergeFilterType(pImageData, pRowData, rowBytes);
258             break;
259             // Paeth
260             case DATA_FILTER_TYPE_PAETH:
261                 this->paethFilterType(pImageData, pRowData, rowBytes);
262             break;
263             // 类型错误
264             default:
265             break;
266         }
267 
268         pImageData += rowBytes;
269         pRowData += rowBytes;
270 
271         char text[100];
272         sprintf(text, "filter type:%d, rowIndex:%d \n", filterType, rowIndex);
273         OutputDebugString(text);
274     }
275 
276     int channel = rowBytes / this->m_width;
277     if (channel == 4) {
278         unsigned int *tmp = (unsigned int *)this->m_imageData;
279 
280         for (unsigned short i = 0; i < this->m_height; i++) {
281             for (unsigned int j = 0; j < rowBytes; j+=4) {
282                 unsigned int offset = i * rowBytes + j;
283 
284                 *tmp++ = RGB_USE_ALPHA(
285                     this->m_imageData[offset], 
286                     this->m_imageData[offset+1], 
287                     this->m_imageData[offset+2],
288                     this->m_imageData[offset+3] 
289                 );
290             }
291         }
292     }
293 }
294 
295 /**
296  * 默认的过滤方式
297  */
298 void PNG::defaultFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
299 {
300     for (int i = 0; i < rowBytes; i++) {
301         *pImageData++ = *pRowData++;
302     }
303 }
304 
305 /**
306  * 当前行相加的过滤方式
307  */
308 void PNG::addCurrentRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
309 {
310     for (int i = 0; i < rowBytes; i++) {
311         if (i == 0) {
312             memcpy(pImageData, pRowData, 4);
313             i += 3;
314             pImageData += 4;
315             pRowData += 4;
316         }
317         else {
318             *pImageData++ = (unsigned char)(((int)*(pRowData++) + (int)*(pImageData-4)) & 0xFF);
319         }
320     }
321 }
322 
323 /**
324  * 前一行相加的过滤方式
325  */
326 void PNG::addUpRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
327 {
328     for (int i = 0; i < rowBytes; i++) {
329         *pImageData++ = (unsigned char)(((int)*(pRowData++) + (int)*(pImageData-rowBytes)) & 0xFF);
330     }
331 }
332 
333 /**
334  * 平均的过滤方式
335  */
336 void PNG::avergeFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
337 {
338     for (int i = 0; i < rowBytes; i++) {
339         int averge = 0;
340 
341         if (i <= 3) {
342             averge = ((int)*(pImageData-rowBytes)) / 2;
343 
344             *pImageData++ = (unsigned char)((averge + (int)*(pRowData++)) & 0xFF);
345         }
346         else {
347             averge = (((int)*(pImageData-4)) + ((int)*(pImageData-rowBytes))) / 2;
348 
349             *pImageData++ = (unsigned char)((averge + (int)*(pRowData++)) & 0xFF);
350         }
351     }
352 }
353 
354 /**
355  * paeth的过滤方式
356  */
357 int Paeth(int a, int b, int c)
358 {
359     int p  = a + b - c;
360     int pa = abs(p - a);
361     int pb = abs(p - b);
362     int pc = abs(p - c);
363     
364     int Paeth;
365     if(pa <= pb && pa <= pc)
366         Paeth = a;
367     else if (pb <= pc) 
368         Paeth = b;
369     else 
370         Paeth = c;
371     return Paeth ;
372 }
373 void PNG::paethFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
374 {
375     for (int i = 0; i < rowBytes; i++) {
376         if (i <= 3) {
377             *pImageData++ = (unsigned char)(((int)*(pRowData++) + (int)*(pImageData-rowBytes)) & 0xFF);
378         }
379         else {
380             unsigned char left = *(pImageData - 4);
381             unsigned char up = *(pImageData - rowBytes);
382             unsigned char leftUp = *(pImageData - rowBytes - 4);
383 
384             int value = Paeth((int)left, (int)up, (int)leftUp);
385             
386             *pImageData++ = (unsigned char)(((int)*(pRowData++) + value) & 0xFF);
387         }
388     }
389 }
390 
391 /**
392  * 解析IDAT数据
393  */
394 void PNG::parseIDATData(DataChunkHeader& dataChunkHeader, FILE* pFile)
395 {
396     // 解压后的图片数据
397     unsigned char* imageData = new unsigned char[m_width * m_height * 4];
398 
399     int dataLen = this->parseNumber(dataChunkHeader.length, 4);
400     // 解压前的图片数据
401     unsigned char* data = new unsigned char[dataLen];
402     char crc[4];
403     // 提取数据
404     fread(data, 1, dataLen, pFile);
405     fread(crc, 1, 4, pFile);
406 
407     // 存放临时的解压数据
408     unsigned long decompressDataLen = m_width * m_height * 4 + m_height;
409     unsigned char* decompressData = new unsigned char[decompressDataLen];
410 
411     z_stream* zStream = new z_stream();
412     zStream->next_in = data;
413     zStream->next_out = decompressData;
414 
415     inflateInit(zStream);
416 
417     // 解压数据
418     this->decompressData(zStream, data, dataLen, dataLen, pFile);
419     // 生成图片数据
420     this->generateImageData(decompressData, decompressDataLen);
421 
422     /*
423     int result = 0;
424     // 开始解压数据
425     int leftBytesCount = dataLen;
426     int avail_out = -1;
427     do {
428         if (zStream->avail_in == 0) {
429             if (avail_out == 0)
430                 break;
431             else {
432                 if (leftBytesCount == 0) {
433 
434                 }
435             }
436 
437             // 导出数据是否超过限制
438             if (leftBytesCount > DECOMPRESSION_MAX_BYTES)
439                 zStream->avail_in = DECOMPRESSION_MAX_BYTES;
440             else
441                 zStream->avail_in = leftBytesCount;
442 
443             leftBytesCount = dataLen - zStream->avail_in;
444         }
445         
446         if (avail_out > 0)
447             zStream->avail_out = avail_out;
448         else
449             zStream->avail_out = m_width * 4 + 1;
450 
451         result = inflate(zStream, Z_NO_FLUSH);
452         if (result != Z_OK)
453             break;
454 
455         avail_out = zStream->avail_out;
456     } while (zStream->avail_in >= 0);
457     // 数据解压是否成功
458     if (result == Z_STREAM_END) {
459         int i = 1;
460     }
461     */
462 }
463 
464 /**
465  * 解析IEND数据
466  */
467 void PNG::parseIENDData(DataChunkHeader& dataChunkHeader, FILE *pFile)
468 {
469     char crc[4];
470     fread(crc, 1, 4, pFile);
471 }
472 
473 /**
474  * 解析其他数据
475  */
476 void PNG::parseCommonData(DataChunkHeader& dataChunkHeader, FILE *pFile)
477 {
478     int dataLen = this->parseNumber(dataChunkHeader.length, 4);
479     fseek(pFile, dataLen + 4, SEEK_CUR);
480 }
481 
482 /**
483  * 获取图片宽度
484  */
485 unsigned char* PNG::getImageData()
486 {
487     return this->m_imageData;
488 }
489 
490 /**
491  * 获取图片宽度
492  */
493 int PNG::getWindth()
494 {
495     return this->m_width;
496 }
497 
498 /**
499  * 获取图片高度
500  */
501 int PNG::getHeight()
502 {
503     return this->m_height;
504 }

如果需要绘制图片，可以使用opengl库

参考代码：

 1 glViewport(0, 0, winWidth, winHeight);    
 2 
 3 glMatrixMode(GL_PROJECTION);            
 4 glLoadIdentity();                        
 5 glOrtho(0.0f, winWidth - 1.0, 0.0, winHeight - 1.0, -10.0, 10.0);
 6 
 7 glMatrixMode(GL_MODELVIEW);    
 8 glLoadIdentity();        
 9 
10 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
11 
12 glEnable(GL_TEXTURE_2D);
13 
14 int width = png->getWindth();
15 int height = png->getHeight();
16 unsigned char* data = png->getImageData();
17 
18 GLuint name1;
19 glGenTextures(1, &name1);
20 glBindTexture(GL_TEXTURE_2D, name1);
21 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
22 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
23 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,      GL_REPEAT);
24 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,      GL_REPEAT);
25 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,GL_RGBA, GL_UNSIGNED_BYTE, data); 
26 glBegin(GL_POLYGON);
27     glTexCoord2f(1, 1);
28     glVertex3d(800, 800, 2);
29     glTexCoord2f(0, 1);
30     glVertex3d(0, 800, 2);
31     glTexCoord2f(0, 0);
32     glVertex3d(0, 0, 2);
33     glTexCoord2f(1, 0);
34     glVertex3d(800, 0, 2);
35 glEnd();

posted on 2014-12-30 11:34 黑铁时代阅读(3508) 评论(0) 编辑收藏举报