CCTexture2D(CCTexture2D类可以方便的从图片，文本或raw数据文件中创建OpenGL所用贴图 initWithData drawAtPoint initWithString)

http://blog.csdn.net/honghaier/article/details/8068895

#ifndef __CCTEXTURE2D_H__

#define __CCTEXTURE2D_H__

#include <string>

#include "cocoa/CCObject.h"

#include "cocoa/CCGeometry.h"

#include "ccTypes.h"

#ifdef EMSCRIPTEN

#include "base_nodes/CCGLBufferedNode.h"

#endif // EMSCRIPTEN

CCTexture2D:

.hcopy

1. #ifndef __CCTEXTURE2D_H__  
2. #define __CCTEXTURE2D_H__  
3.   
4. #include <string>  
5. #include "cocoa/CCObject.h"  
6. #include "cocoa/CCGeometry.h"  
7. #include "ccTypes.h"  
8.   
9. NS_CC_BEGIN  
10. class CCImage;  
11.   
12. //纹理格式:即每个纹理中的像素单位分别是怎么为颜色值进行实际内存分配的。这个非常重要，我们在进行游戏开发的过程中，会常常与各种图片类型打交通。每种图片往往也有各自的像素格式。但当它们一旦加载到游戏中后，就会根据我们的要求变成以下某种类型的纹理。不同的纹理格式所占据的内存大小可能不同，我们要根据实际情况和需求来选择相应的纹理格式。比如我们用RGBA8888纹理格式来创建纹理，它占据的内存容量很大，如果我们要显示的纹理中没有ALPHA值，那就不应该使用带ALPHA通道的纹理格式。我们就可以改成RGB565像素格式。  
13.   
14. typedef enum {      //枚举 图片格式  
15.     //32位真彩色，最真但最耗内存  
16.     kCCTexture2DPixelFormat_RGBA8888,  
17.     //24位真彩色，去掉了ALPHA通道  
18.     kCCTexture2DPixelFormat_RGB888,  
19.     //16位色，将RGB压缩在一个字中。绿色多了1位，因为人眼对绿色更敏感。  
20.     kCCTexture2DPixelFormat_RGB565,  
21.     //8位色，只存ALPHA值，做遮罩图用  
22.     kCCTexture2DPixelFormat_A8,  
23.     //8位色，只存灰度或者强度值，做灰度图用  
24.     kCCTexture2DPixelFormat_I8,  
25.     //16位色，只存ALPHA值与强度值，双功能  
26.     kCCTexture2DPixelFormat_AI88,  
27.     //16位色，RGBA四通道各占4位。  
28.     kCCTexture2DPixelFormat_RGBA4444,  
29.     //16位色，RGB三通道各占5位，多1位留做ALPHA镂空使用  
30.     kCCTexture2DPixelFormat_RGB5A1,      
31.     // PVR的PVRTC4压缩格式  
32.     kCCTexture2DPixelFormat_PVRTC4,  
33.     // PVRTC的PVRTC2压缩格式  
34.     kCCTexture2DPixelFormat_PVRTC2,  
35.   
36.     //默认格式RGBA8888  
37.     kCCTexture2DPixelFormat_Default = kCCTexture2DPixelFormat_RGBA8888,  
38.   
39.     // 为了兼容性而保留的枚举值  
40.     kTexture2DPixelFormat_RGBA8888 = kCCTexture2DPixelFormat_RGBA8888,  
41.     kTexture2DPixelFormat_RGB888 = kCCTexture2DPixelFormat_RGB888,  
42.     kTexture2DPixelFormat_RGB565 = kCCTexture2DPixelFormat_RGB565,  
43.     kTexture2DPixelFormat_A8 = kCCTexture2DPixelFormat_A8,  
44.     kTexture2DPixelFormat_RGBA4444 = kCCTexture2DPixelFormat_RGBA4444,  
45.     kTexture2DPixelFormat_RGB5A1 = kCCTexture2DPixelFormat_RGB5A1,  
46.     kTexture2DPixelFormat_Default = kCCTexture2DPixelFormat_Default  
47.   
48. } CCTexture2DPixelFormat;  
49.   
50. //需要使用Shader代码片段，这里声明一下  
51. class CCGLProgram;  
52.   
53. //定义了纹理的一些参数  
54. typedef struct _ccTexParams {  
55.     GLuint    minFilter;//纹理过滤器：缩小过滤器  
56.     GLuint    magFilter;//纹理过滤器：放大过滤器  
57.     GLuint    wrapS;//横向纹理寻址模式  
58.     GLuint    wrapT;//纵向纹理寻址模式  
59. } ccTexParams;  
60.   
61.   
62. // CCTexture2D类可以方便的从图片，文本或raw数据文件中创建OpenGL所用贴图，创建的贴图会自动转为2的幂次方大小，所以要注意对于贴图坐标的影响。  
63.   
64. class CC_DLL CCTexture2D : public CCObject  
65. {  
66. public:  
67. CCTexture2D();  
68.     virtual ~CCTexture2D();  
69.     //取得纹理的描述  
70.     const char* description(void);  
71.   
72.     //释放数据  
73. void releaseData(void *data);  
74.  //保存数据  
75.     void* keepData(void *data, unsigned int length);  
76.   
77.     //由数据指针和指定的像素格式，图片宽高，来生成OpenGL贴图。  
78.     bool initWithData(const void* data, CCTexture2DPixelFormat pixelFormat, unsigned int pixelsWide, unsigned int pixelsHigh, const CCSize& contentSize);  
79.   
80. //在指定的位置绘制贴图  
81. void drawAtPoint(const CCPoint& point);  
82.     //绘制贴图上的一个图像块  
83. void drawInRect(const CCRect& rect);  
84.   
85.     //由CCImage指针生成OpenGL贴图  
86.     bool initWithImage(CCImage * uiImage);  
87.   
88.     //由一个字符串生成OpenGL贴图。  
89.     bool initWithString(const char *text, const CCSize& dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment, const char *fontName, float fontSize);  
90.     //由一个字符串和指定的字体与大小生成OpenGL贴图  
91.     bool initWithString(const char *text, const char *fontName, float fontSize);  
92.   
93. //如果支持PVR的压缩格式  
94. #ifdef CC_SUPPORT_PVRTC      
95.     //由一个PVR压缩格式的数据生成OpenGL贴图  
96.     bool initWithPVRTCData(const void *data, int level, int bpp, bool hasAlpha, int length, CCTexture2DPixelFormat pixelFormat);  
97. #endif // CC_SUPPORT_PVRTC  
98.       
99.     //从普通PVR文件生成OpenGL贴图  
100.     bool initWithPVRFile(const char* file);  
101.   
102.    //设置贴图参数  
103.     void setTexParameters(ccTexParams* texParams);  
104.   
105.     //设置为抗锯齿的贴图过滤方式（线性过滤）  
106.     void setAntiAliasTexParameters();  
107.   
108.     //设置为非抗锯齿的贴图过滤方式（最近点采样）  
109.     void setAliasTexParameters();  
110.   
111.   
112.     //生成多级贴图: 由图片数据生成一系列尺寸为2的幂次方直至当前贴图大小的贴图。系统会根据距离自动选择纹理图片。可以解决大图片显示在小空间时的闪烁问题。  
113.     void generateMipmap();  
114.   
115.     //取得像素格式名称  
116.     const char* stringForFormat();  
117.   
118.     //返回当前贴图色深，即每个像素占多少位  
119.     unsigned int bitsPerPixelForFormat();    
120.   
121. //通过参数贴图格式返回纹理色深  
122. unsigned int bitsPerPixelForFormat(CCTexture2DPixelFormat format);  
123.   
124.   
125.     //静态函数，用于设置默认带ALPHA通道的贴图像素格式。则图片创建为贴图时，如果有ALPHA通道，则生成此默认贴图像素格式。  
126.     static void setDefaultAlphaPixelFormat(CCTexture2DPixelFormat format);  
127.   
128.     //静态函数，取得默认带ALPHA通道的贴图像素格式。  
129.     static CCTexture2DPixelFormat defaultAlphaPixelFormat();  
130.   
131.     //静态函数，设置载入PVR时是否开启ALPHA渐变，默认不开启，则ALPHA值只有是与否，无渐变。  
132.     static void PVRImagesHavePremultipliedAlpha(bool haveAlphaPremultiplied);  
133.   
134.     //取得图片大小（以像素为单位）  
135.     const CCSize& getContentSizeInPixels();  
136.     //是否有ALPHA渐变值  
137. bool hasPremultipliedAlpha();  
138. //是否有多级贴图  
139. //////
140. 对一张地图图形在屏幕上显示不清楚时，把地图图形分成若干个小图，分级调用。其特点是图形自动放大，显示清楚，图形不变形，可用鼠标器，键盘定点选图，及定区域自动选图，并可对一定条件下不规则图形进行处理。
     
141. //////
142.     bool hasMipmaps();  
143. private:  
144.     //加载一个带ALPHA渐变的图片生成OpenGL贴图  
145.     bool initPremultipliedATextureWithImage(CCImage * image, unsigned int pixelsWide, unsigned int pixelsHigh);  
146.       
147.     //ALPHA渐变开关  
148.     bool m_bPVRHaveAlphaPremultiplied;  
149.   
150.     //贴图格式变量及get接口  
151.     CC_PROPERTY_READONLY(CCTexture2DPixelFormat, m_ePixelFormat, PixelFormat)  
152.     //贴图宽度及get接口  
153.     CC_PROPERTY_READONLY(unsigned int, m_uPixelsWide, PixelsWide)  
154.     //贴图高度及get接口  
155.     CC_PROPERTY_READONLY(unsigned int, m_uPixelsHigh, PixelsHigh)  
156.   
157.     //OpenGL贴图索引及get接口  
158.     CC_PROPERTY_READONLY(GLuint, m_uName, Name)  
159.   
160.     //横向贴图坐标终点。因为图片如果不是2的幂次方，图片大小会小于贴图的大小，贴图一定是2的幂次方嘛，这时候横向的贴图坐标终点不是1.0。  
161.     CC_PROPERTY(GLfloat, m_fMaxS, MaxS)  
162.     //纵向贴图坐标终点。  
163.     CC_PROPERTY(GLfloat, m_fMaxT, MaxT)  
164.     //图片大小及get接口  
165.     CC_PROPERTY_READONLY(CCSize, m_tContentSize, ContentSize)  
166.   
167.     // ALPHA渐变开关  
168.     bool m_bHasPremultipliedAlpha;  
169.     // 多级纹理开关  
170.     bool m_bHasMipmaps;  
171.   
172.     //Shader代码片段指针  
173.     CC_PROPERTY(CCGLProgram*, m_pShaderProgram, ShaderProgram);  
174. };  
175.   
176. NS_CC_END  
177.   
178. #endif //__CCTEXTURE2D_H__  copy

1. .cpp
2. 
   
3. //这里定义是否使用可变纹理  
4. #if CC_ENABLE_CACHE_TEXTURE_DATA  
5.     #include "CCTextureCache.h"  
6. #endif  
7.   
8. //静态全局的默认贴图像素格式。缺省为kCCTexture2DPixelFormat_Default，即RGBA8888。  
9. static CCTexture2DPixelFormat g_defaultAlphaPixelFormat = kCCTexture2DPixelFormat_Default;  
10.   
11. //静态全局的PVR是否有ALPHA渐变的开关变量，默认为否。  
12. static bool PVRHaveAlphaPremultiplied_ = false;  
13.   
14. //构造函数。  
15. CCTexture2D::CCTexture2D()  
16. : m_uPixelsWide(0)  
17. , m_uPixelsHigh(0)  
18. , m_uName(0)  
19. , m_fMaxS(0.0)  
20. , m_fMaxT(0.0)  
21. , m_bHasPremultipliedAlpha(false)  
22. , m_bHasMipmaps(false)  
23. , m_bPVRHaveAlphaPremultiplied(true)  
24. , m_pShaderProgram(NULL)  
25. {  
26. }  
27. 
    
28. //设置用到的Shader代码片段。  
29. void CCTexture2D::setShaderProgram(CCGLProgram* pShaderProgram)  
30. {  
31.     CC_SAFE_RETAIN(pShaderProgram);  
32.     CC_SAFE_RELEASE(m_pShaderProgram);  
33.     m_pShaderProgram = pShaderProgram;  
34. }  
35. 
    
36. //由数据指针创建指定大小和格式的贴图。取得创建成功后图片在贴图中的实际区域 。  
37. bool CCTexture2D::initWithData(const void *data, CCTexture2DPixelFormat pixelFormat, unsigned int pixelsWide, unsigned int pixelsHigh, const CCSize& contentSize)  
38. {  
39. //如果是RGBA8888格式或者大小正好就是2的幂次方。像素数据按四字节(DWORD)对齐。否则按1字节(BYTE)进行对齐。  
40.     if( pixelFormat == kCCTexture2DPixelFormat_RGBA8888 || ( ccNextPOT(pixelsWide)==pixelsWide && ccNextPOT(pixelsHigh)==pixelsHigh) )  
41.     {  
42.         glPixelStorei(GL_UNPACK_ALIGNMENT,4);  
43.     }  
44.     else  
45.     {  
46.         glPixelStorei(GL_UNPACK_ALIGNMENT,1);  
47.     }  
48. //产生一个OpenGL的贴图索引。  
49. glGenTextures(1, &m_uName);  
50. //将此贴图绑定为GL_TEXTURE_2D纹理。  
51.     ccGLBindTexture2D(m_uName);  
52. //设置OpenGL中的贴图的过滤参数。  
53.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );  
54. glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );  
55. //设置贴图的横向纹理寻址模式为边缘截取模式。总是忽略边界。  
56. glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );  
57. //设置贴图的纵向纹理寻址模式为边缘截取模式。总是忽略边界。  
58.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );  
59.   
60. //这里根据不同的像素格式来生成不同的OpenGL所用的贴图。注意：传入的宽和高在成功生成贴图后会返回实际贴图的宽和高。如果图片不是2的幂次方，这个数值会改成2的幂次方。比如你传入的图片宽高是148x245，则调用完成后宽高会转成256x256。  
61.     switch(pixelFormat)  
62.     {  
63.     case kCCTexture2DPixelFormat_RGBA8888:  
64.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);  
65.         break;  
66.     case kCCTexture2DPixelFormat_RGB888:  
67.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGB, GL_UNSIGNED_BYTE, data);  
68.         break;  
69.     case kCCTexture2DPixelFormat_RGBA4444:  
70.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, data);  
71.         break;  
72.     case kCCTexture2DPixelFormat_RGB5A1:  
73.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, data);  
74.         break;  
75.     case kCCTexture2DPixelFormat_RGB565:  
76.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, data);  
77.         break;  
78.     case kCCTexture2DPixelFormat_AI88:  
79.         glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, data);  
80.         break;  
81.     case kCCTexture2DPixelFormat_A8:  
82.         glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data);  
83.         break;  
84.     case kCCTexture2DPixelFormat_I8:  
85.         glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);  
86.         break;  
87.     default:  
88.         CCAssert(0, "NSInternalInconsistencyException");  
89.   
90.     }  
91. //图片大小  
92.     m_tContentSize = contentSize;  
93. //保存实际的贴图宽高  
94. m_uPixelsWide = pixelsWide;  
95. m_uPixelsHigh = pixelsHigh;  
96. //保存贴图的像素格式  
97. m_ePixelFormat = pixelFormat;  
98. //计算图片处于贴图中的横向和纵向的纹理坐标终点。  
99.     m_fMaxS = contentSize.width / (float)(pixelsWide);  
100.     m_fMaxT = contentSize.height / (float)(pixelsHigh);  
101. //默认不使用ALPHA渐变通道。  
102. m_bHasPremultipliedAlpha = false;  
103. //默认不使用多级纹理。  
104.     m_bHasMipmaps = false;  
105.   
106.     //设置使用kCCShader_PositionTexture对应类型的Shader。此Shader的顶点格式由位置和纹理坐标组成。  
107. setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTexture));  
108.   
109.     return true;  
110. }  
111.   
112. 
     
113.   
114. // 由CCImage对象来初始化纹理生成OpenGL贴图。  
115. bool CCTexture2D::initWithImage(CCImage *uiImage)  
116. {  
117.     //参数有效性判断。  
118.     if (uiImage == NULL)  
119.     {  
120.         CCLOG("cocos2d: CCTexture2D. Can't create Texture. UIImage is nil");  
121.         this->release();  
122.         return false;  
123.     }  
124.     //取得图片的宽高  
125.     unsigned int imageWidth = uiImage->getWidth();  
126.     unsigned int imageHeight = uiImage->getHeight();  
127.     //取得引擎的配置信息  
128.     CCConfiguration *conf = CCConfiguration::sharedConfiguration();  
129.     //取得配置信息中指定的最大纹理大小  
130. unsigned maxTextureSize = conf->getMaxTextureSize();  
131. //如果当前图片大于指定的最大纹理大小，提示错误警告交释放当前纹理返回NULL。  
132.     if (imageWidth > maxTextureSize || imageHeight > maxTextureSize)   
133.     {  
134.         CCLOG("cocos2d: WARNING: Image (%u x %u) is bigger than the supported %u x %u", imageWidth, imageHeight, maxTextureSize, maxTextureSize);  
135.         this->release();  
136.         return NULL;  
137.     }  
138.       
139.     //总是按加载ALPHA渐变的图片方式来生成OpenGL贴图  
140.     return initPremultipliedATextureWithImage(uiImage, imageWidth, imageHeight);  
141. }  
142. //加载一个带ALPHA渐变的图片生成OpenGL贴图  
143. bool CCTexture2D::initPremultipliedATextureWithImage(CCImage *image, unsigned int width, unsigned int height)  
144. {  
145. //取得图片的相关信息  
146. //定义指针变量指向图片像素数据。  
147.     unsigned char*            tempData = image->getData();  
148.     //定义无符号int指针变量，也是为了指向32位色深的图片像素数据，以便使指针直接对应指定的一个像素数据位置。  
149.     unsigned int*             inPixel32 = NULL;  
150.     //定义无符号char指针变量，也是为了指向8位色深的图片像素数据，以便使指针直接对应指定的一个像素数据位置。  
151.     unsigned char*            inPixel8 = NULL;  
152.     //定义无符号short指针变量，指向16位色深的贴图像素数据，以便使指针直接对应指定的一个像素数据位置。  
153.     unsigned short*           outPixel16 = NULL;  
154.     //定义bool变量hasAlpha取得图片是否有Alpha通道。  
155.     bool                      hasAlpha = image->hasAlpha();  
156.     //定义变量imageSize保存图片大小。  
157.     CCSize                    imageSize = CCSizeMake((float)(image->getWidth()), (float)(image->getHeight()));  
158.     //定义变量pixelFormat用来保存贴图的像素格式。  
159.     CCTexture2DPixelFormat    pixelFormat;  
160.     //定义变量bpp保存图片的色深。  
161.     size_t                    bpp = image->getBitsPerComponent();  
162.   
163. // 如果有ALPHA通道，使用默认的RGBA8888格式。  
164. if(hasAlpha)  
165.     {  
166.         pixelFormat = g_defaultAlphaPixelFormat;  
167.     }  
168.     else  
169.     {    //如果没有ALPHA通道  
170.          //如果色深大于等于8，则转为RGB888格式，否则转为RGB565格式。这里有点问题，感觉应该按色深大于16来进行判断。即24和32位都转为RGB888，而16位及以下转为RGB565。  
171.         if (bpp >= 8)  
172.         {  
173.             pixelFormat = kCCTexture2DPixelFormat_RGB888;  
174.         }  
175.         else   
176.         {  
177.             pixelFormat = kCCTexture2DPixelFormat_RGB565;  
178.         }  
179.           
180.     }  
181.       
182.     // 取得数据的长度  
183.     unsigned int length = width * height;  
184.     //根据图片的不同格式和要创建的纹理格式，将数据填充到纹理中。  
185.     if (pixelFormat == kCCTexture2DPixelFormat_RGB565)  
186. {  
187.  //根据是否有ALPHA通道来分别进行填充处理  
188.         if (hasAlpha)  
189.         {  
190.              // 转换RGBA8888到RGB565  
191.             // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRRGGGGGGBBBBB"  
192.             //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
193.             tempData = new unsigned char[width * height * 2];  
194.              //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
195.             outPixel16 = (unsigned short*)tempData;  
196.              //因为有alpha，则图片是32位RGBA8888格式。取得图像的像素数据地址返回给unsigned int指针，则inPixel32指向了贴图中第一个像素的数据位置。  
197.             inPixel32 = (unsigned int*)image->getData();  
198.             //遍历图片中所有的像素，逐像素处理。  
199.             for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
200.             {   //将inPixel32指向的unsigned int数据通过取出R,G,B各8位数据值，然后组成RGB565值。放入outPixel16指向的unsigned short数据中。  
201.                 *outPixel16++ =   
202.                 ((((*inPixel32 >>  0) & 0xFF) >> 3) << 11) |  // R  
203.                 ((((*inPixel32 >>  8) & 0xFF) >> 2) << 5)  |  // G  
204.                 ((((*inPixel32 >> 16) & 0xFF) >> 3) << 0);    // B  
205.             }  
206.         }  
207.         else   
208.         {    // 转换RGB888到RGB565  
209.             // Convert "RRRRRRRRRGGGGGGGGBBBBBBBB" to "RRRRRGGGGGGBBBBB"  
210.             //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
211.             tempData = new unsigned char[width * height * 2];  
212.             //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
213.             outPixel16 = (unsigned short*)tempData;  
214.             //如果图像的格式为RGB888。取得图像的像素数据地址返回给unsigned char指针，则inPixel8指向了贴图中第一个像素的R值位置。  
215.             inPixel8 = (unsigned char*)image->getData();  
216.             //遍历图片中所有的像素，逐像素处理。  
217.             for(unsigned int i = 0; i < length; ++i)  
218.             {   //inPixel8指向的是unsigned char值，通过++操作来取出R,G,B数据值，然后组成RGB565值。放入outPixel16指向的unsigned short数据中。  
219.   
220.                 *outPixel16++ =   
221.                 (((*inPixel8++ & 0xFF) >> 3) << 11) |  // R  
222.                 (((*inPixel8++ & 0xFF) >> 2) << 5)  |  // G  
223.                 (((*inPixel8++ & 0xFF) >> 3) << 0);    // B  
224.             }  
225.         }      
226.     }  
227.     else if (pixelFormat == kCCTexture2DPixelFormat_RGBA4444)  
228.     {   // 转换RGBA8888到RGBA4444  
229.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRGGGGBBBBAAAA"  
230.         //取得图像的像素数据地址返回给unsigned int指针，则inPixel32指向了贴图中第一个像素的数据位置。  
231.         inPixel32 = (unsigned int*)image->getData();    
232.          //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
233.         tempData = new unsigned char[width * height * 2];  
234.         //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
235.         outPixel16 = (unsigned short*)tempData;  
236.         //遍历图片中所有的像素，逐像素处理。  
237.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
238.         {   //将inPixel32指向的unsigned int数据通过取出R,G,B,A各8位数据值，然后组成RGBA4444值。放入outPixel16指向的unsigned short数据中。  
239.             *outPixel16++ =   
240.             ((((*inPixel32 >> 0) & 0xFF) >> 4) << 12) | // R  
241.             ((((*inPixel32 >> 8) & 0xFF) >> 4) <<  8) | // G  
242.             ((((*inPixel32 >> 16) & 0xFF) >> 4) << 4) | // B  
243.             ((((*inPixel32 >> 24) & 0xFF) >> 4) << 0);  // A  
244.         }  
245.     }  
246.     else if (pixelFormat == kCCTexture2DPixelFormat_RGB5A1)  
247.     {   // 转换RGBA8888到RGBA5551  
248.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRRGGGGGBBBBBA"  
249.         inPixel32 = (unsigned int*)image->getData();     
250.          //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
251.         tempData = new unsigned char[width * height * 2];  
252.         //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
253.         outPixel16 = (unsigned short*)tempData;  
254.         //遍历图片中所有的像素，逐像素处理。  
255.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
256.         {   //将inPixel32指向的unsigned int数据通过取出R,G,B,A各8位数据值，然后组成RGB5A1值。放入outPixel16指向的unsigned short数据中。  
257.             *outPixel16++ =   
258.             ((((*inPixel32 >> 0) & 0xFF) >> 3) << 11) | // R  
259.             ((((*inPixel32 >> 8) & 0xFF) >> 3) <<  6) | // G  
260.             ((((*inPixel32 >> 16) & 0xFF) >> 3) << 1) | // B  
261.             ((((*inPixel32 >> 24) & 0xFF) >> 7) << 0);  // A  
262.         }  
263.     }  
264.     else if (pixelFormat == kCCTexture2DPixelFormat_A8)  
265.     {   // 转换RGBA8888到A8，同理，不再赘述  
266.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "AAAAAAAA"  
267.         inPixel32 = (unsigned int*)image->getData();  
268.         tempData = new unsigned char[width * height];  
269.         unsigned char *outPixel8 = tempData;  
270.           
271.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
272.         {  
273.             *outPixel8++ = (*inPixel32 >> 24) & 0xFF;  // A  
274.         }  
275.     }  
276.       
277.     if (hasAlpha && pixelFormat == kCCTexture2DPixelFormat_RGB888)  
278.     {   // 转换RGBA8888到RGB888，同理，不再赘述  
279.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRRRRRGGGGGGGGBBBBBBBB"  
280.         inPixel32 = (unsigned int*)image->getData();  
281.         tempData = new unsigned char[width * height * 3];  
282.         unsigned char *outPixel8 = tempData;  
283.           
284.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
285.         {  
286.             *outPixel8++ = (*inPixel32 >> 0) & 0xFF; // R  
287.             *outPixel8++ = (*inPixel32 >> 8) & 0xFF; // G  
288.             *outPixel8++ = (*inPixel32 >> 16) & 0xFF; // B  
289.         }  
290.     }  
291.     //因为最终相应像素格式的数据都存放在tempData中，所以这里通过像素数据来生成OpenGL贴图。  
292.     initWithData(tempData, pixelFormat, width, height, imageSize);  
293.     //如果是以上相应格式，则tempData都是新申请的内存块，则在这里释放申请的内存。  
294.     if (tempData != image->getData())  
295.     {  
296.         delete [] tempData;  
297.     }  
298. //取得是否有ALPHA渐变通道数据  
299.     m_bHasPremultipliedAlpha = image->isPremultipliedAlpha();  
300.     return true;  
301. }  
302.   
303. 
     
304. // 从字符串中创建OpenGL 贴图,可指定更多参数。  
305. //参1:字符串  
306. //参2:返回参数，代表在屏幕上占用的区域大小  
307. //参3:文字的横向对齐方式  
308. //参4:文字的纵向对齐方式  
309. //参5:字体名称  
310. //参6:字体大小  
311. bool CCTexture2D::initWithString(const char *text, const CCSize& dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment, const char *fontName, float fontSize)  
312. {  
313.     //如果定义使用可变纹理  
314. #if CC_ENABLE_CACHE_TEXTURE_DATA  
315.     // cache the texture data  
316.     VolatileTexture::addStringTexture(this, text, dimensions, hAlignment, vAlignment, fontName, fontSize);  
317. #endif  
318.     //定义一个CCImage实例对象  
319.     CCImage image;  
320.     //定义一个CCImage进行由字符串创建图片时指定的文字对齐方式的变量eAlign  
321.     CCImage::ETextAlign eAlign;  
322.     //如果文字纵向对齐方式为顶部对齐。  
323.     if (kCCVerticalTextAlignmentTop == vAlignment)  
324.     {      
325.         //根据文字横向对齐方式的不同分别对eAlign进行设置。  
326.         eAlign = (kCCTextAlignmentCenter == hAlignment) ? CCImage::kAlignTop  
327.             : (kCCTextAlignmentLeft == hAlignment) ? CCImage::kAlignTopLeft : CCImage::kAlignTopRight;  
328.     }  
329.     //如果文字纵向对齐方式为居中对齐。  
330.     else if (kCCVerticalTextAlignmentCenter == vAlignment)  
331.     {  
332.         //根据文字横向对齐方式的不同分别对eAlign进行设置。  
333.         eAlign = (kCCTextAlignmentCenter == hAlignment) ? CCImage::kAlignCenter  
334.             : (kCCTextAlignmentLeft == hAlignment) ? CCImage::kAlignLeft : CCImage::kAlignRight;  
335.     }  
336.     //如果文字纵向对齐方式为底部对齐。  
337.     else if (kCCVerticalTextAlignmentBottom == vAlignment)  
338.     {  
339.         //根据文字横向对齐方式的不同分别对eAlign进行设置。  
340.         eAlign = (kCCTextAlignmentCenter == hAlignment) ? CCImage::kAlignBottom  
341.             : (kCCTextAlignmentLeft == hAlignment) ? CCImage::kAlignBottomLeft : CCImage::kAlignBottomRight;  
342.     }  
343.     else  
344.     {  
345.          //其它对齐方式不应存在，故打印错误。  
346.         CCAssert(false, "Not supported alignment format!");  
347.     }  
348.     //调用CCImage的成员函数由字符串创建出图片数据。  
349.     if (!image.initWithString(text, (int)dimensions.width, (int)dimensions.height, eAlign, fontName, (int)fontSize))  
350.     {  
351.         return false;  
352.     }  
353.     //再由CCImage实例对象来创建出OpenGL贴图，初始化纹理。  
354.     return initWithImage(&image);  
355. }  
356.   
357.   
358. // 在指定的位置绘制贴图。  
359. void CCTexture2D::drawAtPoint(const CCPoint& point)  
360. {   //定义贴图中图像区域的UV坐标。从左上至右下。  
361.     GLfloat    coordinates[] = {      
362.         0.0f,    m_fMaxT,  
363.         m_fMaxS,m_fMaxT,  
364.         0.0f,    0.0f,  
365.         m_fMaxS,0.0f };  
366.     //取得贴图中图像区域的宽高  
367.     GLfloat    width = (GLfloat)m_uPixelsWide * m_fMaxS,  
368.         height = (GLfloat)m_uPixelsHigh * m_fMaxT;  
369.     //定义对应的顶点坐标  
370.     GLfloat        vertices[] = {      
371.         point.x,            point.y,  
372.         width + point.x,    point.y,  
373.         point.x,            height  + point.y,  
374.         width + point.x,    height  + point.y };  
375.     //Shader中使用位置和纹理坐标通道。  
376.     ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords );  
377.     //后面的代码便用Shader进行渲染  
378.     m_pShaderProgram->use();  
379.     //设置Shader使用的最终结果矩阵  
380.     m_pShaderProgram->setUniformForModelViewProjectionMatrix();  
381.     //将贴图绑定  
382.     ccGLBindTexture2D( m_uName );  
383.   
384.     //将vertices设置为顶点位置参数  
385.     glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices);  
386.     //将coordinates设置为顶点的纹理坐标参数  
387.     glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, coordinates);  
388.     //绘制三角形，参1为绘图方式，参2为顶点起始索引，参3为三角形面数。  
389.     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);  
390. }  
391. //绘制纹理上的一个区域。  
392. void CCTexture2D::drawInRect(const CCRect& rect)  
393. {   //定义贴图中图像区域的UV坐标。从左上至右下。  
394.     GLfloat    coordinates[] = {      
395.         0.0f,    m_fMaxT,  
396.         m_fMaxS,m_fMaxT,  
397.         0.0f,    0.0f,  
398.         m_fMaxS,0.0f };  
399.     //绘制到的区域  
400.     GLfloat    vertices[] = {    rect.origin.x,        rect.origin.y,                            /*0.0f,*/  
401.         rect.origin.x + rect.size.width,        rect.origin.y,                            /*0.0f,*/  
402.         rect.origin.x,                            rect.origin.y + rect.size.height,        /*0.0f,*/  
403.         rect.origin.x + rect.size.width,        rect.origin.y + rect.size.height,        /*0.0f*/ };  
404.     //Shader中使用位置和纹理坐标通道。  
405.     ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords );  
406.     //后面的代码便用Shader进行渲染  
407.     m_pShaderProgram->use();  
408.     //设置Shader使用的最终结果矩阵  
409.     m_pShaderProgram->setUniformForModelViewProjectionMatrix();  
410.     //将贴图绑定  
411.     ccGLBindTexture2D( m_uName );  
412.     //将vertices设置为顶点位置参数  
413.     glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices);  
414.     //将coordinates设置为顶点的纹理坐标参数  
415.     glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, coordinates);  
416.     //绘制三角形，参1为绘图方式，参2为顶点起始索引，参3为三角形面数。  
417.     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);  
418. }  
419.   
420. #ifdef CC_SUPPORT_PVRTC  
421.   
422. // 如果支持PVR文件的压缩格式。提供的读取PVR压缩文件的函数。     
423. bool CCTexture2D::initWithPVRTCData(const void *data, int level, int bpp, bool hasAlpha, int length, CCTexture2DPixelFormat pixelFormat)  
424. {  
425.     if( !(CCConfiguration::sharedConfiguration()->supportsPVRTC()) )  
426.     {  
427.         CCLOG("cocos2d: WARNING: PVRTC images is not supported.");  
428.         this->release();  
429.         return false;  
430.     }  
431. //产生一个OpenGL的贴图索引。  
432. glGenTextures(1, &m_uName);  
433.     //绑定纹理  
434.     glBindTexture(GL_TEXTURE_2D, m_uName);  
435.     //设置纹理抗锯齿  
436.     this->setAntiAliasTexParameters();  
437.     //贴图格式  
438.     GLenum format;  
439.     //数据大小  
440.     GLsizei size = length * length * bpp / 8;  
441.     //根据是否有Alpha来取得贴图格式  
442.     if(hasAlpha) {  
443.         format = (bpp == 4) ? GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG : GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;  
444.     } else {  
445.         format = (bpp == 4) ? GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG : GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;  
446.     }  
447.     if(size < 32) {  
448.         size = 32;  
449.     }  
450.     //加载压缩纹理。  
451.     glCompressedTexImage2D(GL_TEXTURE_2D, level, format, length, length, 0, size, data);  
452.     //设置其它属性。  
453.     m_tContentSize = CCSizeMake((float)(length), (float)(length));  
454.     m_uPixelsWide = length;  
455.     m_uPixelsHigh = length;  
456.     m_fMaxS = 1.0f;  
457.     m_fMaxT = 1.0f;  
458.     m_bHasPremultipliedAlpha = PVRHaveAlphaPremultiplied_;  
459.     m_ePixelFormat = pixelFormat;  
460.   
461.     return true;  
462. }  
463. #endif // CC_SUPPORT_PVRTC  
464. //加载PVR普通文件的函数。  
465. bool CCTexture2D::initWithPVRFile(const char* file)  
466. {  
467.     bool bRet = false;  
468.     // nothing to do with CCObject::init  
469.       
470.     CCTexturePVR *pvr = new CCTexturePVR;  
471.     bRet = pvr->initWithContentsOfFile(file);  
472.           
473.     if (bRet)  
474.     {  
475.         pvr->setRetainName(true); // don't dealloc texture on release  
476.           
477.         m_uName = pvr->getName();  
478.         m_fMaxS = 1.0f;  
479.         m_fMaxT = 1.0f;  
480.         m_uPixelsWide = pvr->getWidth();  
481.         m_uPixelsHigh = pvr->getHeight();  
482.         m_tContentSize = CCSizeMake((float)m_uPixelsWide, (float)m_uPixelsHigh);  
483.         m_bHasPremultipliedAlpha = PVRHaveAlphaPremultiplied_;  
484.         m_ePixelFormat = pvr->getFormat();  
485.         m_bHasMipmaps = pvr->getNumberOfMipmaps() > 1;         
486.   
487.         pvr->release();  
488.     }  
489.     else  
490.     {  
491.         CCLOG("cocos2d: Couldn't load PVR image %s", file);  
492.     }  
493.   
494.     return bRet;  
495. }  
496.       
497. //生成多级纹理。  
498. void CCTexture2D::generateMipmap()  
499. {  
500.     CCAssert( m_uPixelsWide == ccNextPOT(m_uPixelsWide) && m_uPixelsHigh == ccNextPOT(m_uPixelsHigh), "Mimpap texture only works in POT textures");  
501.     ccGLBindTexture2D( m_uName );  
502.     glGenerateMipmap(GL_TEXTURE_2D);  
503.     m_bHasMipmaps = true;  
504. }  
505. 
     
506. //设置纹理参数。  
507. void CCTexture2D::setTexParameters(ccTexParams *texParams)  
508. {  
509.     CCAssert( (m_uPixelsWide == ccNextPOT(m_uPixelsWide) || texParams->wrapS == GL_CLAMP_TO_EDGE) &&  
510.         (m_uPixelsHigh == ccNextPOT(m_uPixelsHigh) || texParams->wrapT == GL_CLAMP_TO_EDGE),  
511.         "GL_CLAMP_TO_EDGE should be used in NPOT dimensions");  
512.   
513.     ccGLBindTexture2D( m_uName );  
514.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texParams->minFilter );  
515.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texParams->magFilter );  
516.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texParams->wrapS );  
517.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texParams->wrapT );  
518. }  
519. //设置为非抗锯齿纹理模式  
520. void CCTexture2D::setAliasTexParameters()  
521. {   //绑定纹理  
522.     ccGLBindTexture2D( m_uName );  
523.     //设置多级纹理  
524.     if( ! m_bHasMipmaps )  
525.     {     
526.         //设置最小滤波方式为最近点采样,这种方式最快，但有锯齿。  
527.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );  
528.     }  
529.     else  
530.     {    //设置最小滤波方式为多级纹理方式。  
531.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST );  
532.     }  
533.     //设置放大滤波方式为最近点采样  
534.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );  
535. }  
536. //设置为抗锯齿纹理模式  
537. void CCTexture2D::setAntiAliasTexParameters()  
538. {   //绑定纹理  
539.     ccGLBindTexture2D( m_uName );  
540.     //设置多级纹理  
541.     if( ! m_bHasMipmaps )  
542.     {  
543.         //设置最小滤波方式为线性过滤,这种方式纹理会有一定程度模糊。  
544.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );  
545.     }  
546.     else  
547.     {   //设置最小滤波方式为多级纹理方式。  
548.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );  
549.     }  
550.     //设置放大滤波方式为最近点采样  
551.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );  
552. }  
553. //取得纹理格式的名字字符串  
554. const char* CCTexture2D::stringForFormat()  
555. {  
556.     switch (m_ePixelFormat)   
557.     {  
558.         case kCCTexture2DPixelFormat_RGBA8888:  
559.             return  "RGBA8888";  
560.   
561.         case kCCTexture2DPixelFormat_RGB888:  
562.             return  "RGB888";  
563.   
564.         case kCCTexture2DPixelFormat_RGB565:  
565.             return  "RGB565";  
566.   
567.         case kCCTexture2DPixelFormat_RGBA4444:  
568.             return  "RGBA4444";  
569.   
570.         case kCCTexture2DPixelFormat_RGB5A1:  
571.             return  "RGB5A1";  
572.   
573.         case kCCTexture2DPixelFormat_AI88:  
574.             return  "AI88";  
575.   
576.         case kCCTexture2DPixelFormat_A8:  
577.             return  "A8";  
578.   
579.         case kCCTexture2DPixelFormat_I8:  
580.             return  "I8";  
581.   
582.         case kCCTexture2DPixelFormat_PVRTC4:  
583.             return  "PVRTC4";  
584.   
585.         case kCCTexture2DPixelFormat_PVRTC2:  
586.             return  "PVRTC2";  
587.   
588.         default:  
589.             CCAssert(false , "unrecognised pixel format");  
590.             CCLOG("stringForFormat: %ld, cannot give useful result", (long)m_ePixelFormat);  
591.             break;  
592.     }  
593.   
594.     return  NULL;  
595. }  
596.   
597.   
598. //取得相应纹理格式的色深。  
599. unsigned int CCTexture2D::bitsPerPixelForFormat(CCTexture2DPixelFormat format)  
600. {  
601.     unsigned int ret=0;  
602.   
603.     switch (format) {  
604.         case kCCTexture2DPixelFormat_RGBA8888:  
605.             ret = 32;//32位真彩色  
606.             break;  
607.         case kCCTexture2DPixelFormat_RGB888:  
608.             // 看起来是用24位，但内部实际是用DWORD来存数据的，所以还是32位。只不过Alpha通道没用。  
609.             ret = 32;  
610.             break;  
611.         case kCCTexture2DPixelFormat_RGB565:  
612.             ret = 16;  
613.             break;  
614.         case kCCTexture2DPixelFormat_RGBA4444:  
615.             ret = 16;  
616.             break;  
617.         case kCCTexture2DPixelFormat_RGB5A1:  
618.             ret = 16;  
619.             break;  
620.         case kCCTexture2DPixelFormat_AI88:  
621.             ret = 16;  
622.             break;  
623.         case kCCTexture2DPixelFormat_A8:  
624.             ret = 8;  
625.             break;  
626.         case kCCTexture2DPixelFormat_I8:  
627.             ret = 8;  
628.             break;  
629.         case kCCTexture2DPixelFormat_PVRTC4:  
630.             ret = 4;  
631.             break;  
632.         case kCCTexture2DPixelFormat_PVRTC2:  
633.             ret = 2;  
634.             break;  
635.         default:  
636.             ret = -1;  
637.             CCAssert(false , "unrecognised pixel format");  
638.             CCLOG("bitsPerPixelForFormat: %ld, cannot give useful result", (long)format);  
639.             break;  
640.     }  
641.     return ret;  
642. }  
643. 
     
644. NS_CC_END