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

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


#ifndef __CCTEXTURE2D_H__

#define __CCTEXTURE2D_H__


#include

#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   
  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 charstringForFormat();  
  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. #if CC_ENABLE_CACHE_TEXTURE_DATA  
  4.     #include "CCTextureCache.h"  
  5. #endif  
  6.   
  7. //静态全局的默认贴图像素格式。缺省为kCCTexture2DPixelFormat_Default,即RGBA8888。  
  8. static CCTexture2DPixelFormat g_defaultAlphaPixelFormat = kCCTexture2DPixelFormat_Default;  
  9.   
  10. //静态全局的PVR是否有ALPHA渐变的开关变量,默认为否。  
  11. static bool PVRHaveAlphaPremultiplied_ = false;  
  12.   
  13. //构造函数。  
  14. CCTexture2D::CCTexture2D()  
  15. : m_uPixelsWide(0)  
  16. , m_uPixelsHigh(0)  
  17. , m_uName(0)  
  18. , m_fMaxS(0.0)  
  19. , m_fMaxT(0.0)  
  20. , m_bHasPremultipliedAlpha(false)  
  21. , m_bHasMipmaps(false)  
  22. , m_bPVRHaveAlphaPremultiplied(true)  
  23. , m_pShaderProgram(NULL)  
  24. {  
  25. }  

  26. //设置用到的Shader代码片段。  
  27. void CCTexture2D::setShaderProgram(CCGLProgram* pShaderProgram)  
  28. {  
  29.     CC_SAFE_RETAIN(pShaderProgram);  
  30.     CC_SAFE_RELEASE(m_pShaderProgram);  
  31.     m_pShaderProgram = pShaderProgram;  
  32. }  

  33. //由数据指针创建指定大小和格式的贴图。取得创建成功后图片在贴图中的实际区域 。  
  34. bool CCTexture2D::initWithData(const void *data, CCTexture2DPixelFormat pixelFormat, unsigned int pixelsWide, unsigned int pixelsHigh, const CCSize& contentSize)  
  35. {  
  36. //如果是RGBA8888格式或者大小正好就是2的幂次方。像素数据按四字节(DWORD)对齐。否则按1字节(BYTE)进行对齐。  
  37.     if( pixelFormat == kCCTexture2DPixelFormat_RGBA8888 || ( ccNextPOT(pixelsWide)==pixelsWide && ccNextPOT(pixelsHigh)==pixelsHigh) )  
  38.     {  
  39.         glPixelStorei(GL_UNPACK_ALIGNMENT,4);  
  40.     }  
  41.     else  
  42.     {  
  43.         glPixelStorei(GL_UNPACK_ALIGNMENT,1);  
  44.     }  
  45. //产生一个OpenGL的贴图索引。  
  46. glGenTextures(1, &m_uName);  
  47. //将此贴图绑定为GL_TEXTURE_2D纹理。  
  48.     ccGLBindTexture2D(m_uName);  
  49. //设置OpenGL中的贴图的过滤参数。  
  50.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );  
  51. glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );  
  52. //设置贴图的横向纹理寻址模式为边缘截取模式。总是忽略边界。  
  53. glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );  
  54. //设置贴图的纵向纹理寻址模式为边缘截取模式。总是忽略边界。  
  55.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );  
  56.   
  57. //这里根据不同的像素格式来生成不同的OpenGL所用的贴图。注意:传入的宽和高在成功生成贴图后会返回实际贴图的宽和高。如果图片不是2的幂次方,这个数值会改成2的幂次方。比如你传入的图片宽高是148x245,则调用完成后宽高会转成256x256。  
  58.     switch(pixelFormat)  
  59.     {  
  60.     case kCCTexture2DPixelFormat_RGBA8888:  
  61.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);  
  62.         break;  
  63.     case kCCTexture2DPixelFormat_RGB888:  
  64.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGB, GL_UNSIGNED_BYTE, data);  
  65.         break;  
  66.     case kCCTexture2DPixelFormat_RGBA4444:  
  67.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, data);  
  68.         break;  
  69.     case kCCTexture2DPixelFormat_RGB5A1:  
  70.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, data);  
  71.         break;  
  72.     case kCCTexture2DPixelFormat_RGB565:  
  73.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, data);  
  74.         break;  
  75.     case kCCTexture2DPixelFormat_AI88:  
  76.         glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, data);  
  77.         break;  
  78.     case kCCTexture2DPixelFormat_A8:  
  79.         glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data);  
  80.         break;  
  81.     case kCCTexture2DPixelFormat_I8:  
  82.         glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, (GLsizei)pixelsWide, (GLsizei)pixelsHigh, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);  
  83.         break;  
  84.     default:  
  85.         CCAssert(0, "NSInternalInconsistencyException");  
  86.   
  87.     }  
  88. //图片大小  
  89.     m_tContentSize = contentSize;  
  90. //保存实际的贴图宽高  
  91. m_uPixelsWide = pixelsWide;  
  92. m_uPixelsHigh = pixelsHigh;  
  93. //保存贴图的像素格式  
  94. m_ePixelFormat = pixelFormat;  
  95. //计算图片处于贴图中的横向和纵向的纹理坐标终点。  
  96.     m_fMaxS = contentSize.width / (float)(pixelsWide);  
  97.     m_fMaxT = contentSize.height / (float)(pixelsHigh);  
  98. //默认不使用ALPHA渐变通道。  
  99. m_bHasPremultipliedAlpha = false;  
  100. //默认不使用多级纹理。  
  101.     m_bHasMipmaps = false;  
  102.   
  103.     //设置使用kCCShader_PositionTexture对应类型的Shader。此Shader的顶点格式由位置和纹理坐标组成。  
  104. setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTexture));  
  105.   
  106.     return true;  
  107. }  
  108.   

  109.   
  110. // 由CCImage对象来初始化纹理生成OpenGL贴图。  
  111. bool CCTexture2D::initWithImage(CCImage *uiImage)  
  112. {  
  113.     //参数有效性判断。  
  114.     if (uiImage == NULL)  
  115.     {  
  116.         CCLOG("cocos2d: CCTexture2D. Can't create Texture. UIImage is nil");  
  117.         this->release();  
  118.         return false;  
  119.     }  
  120.     //取得图片的宽高  
  121.     unsigned int imageWidth = uiImage->getWidth();  
  122.     unsigned int imageHeight = uiImage->getHeight();  
  123.     //取得引擎的配置信息  
  124.     CCConfiguration *conf = CCConfiguration::sharedConfiguration();  
  125.     //取得配置信息中指定的最大纹理大小  
  126. unsigned maxTextureSize = conf->getMaxTextureSize();  
  127. //如果当前图片大于指定的最大纹理大小,提示错误警告交释放当前纹理返回NULL。  
  128.     if (imageWidth > maxTextureSize || imageHeight > maxTextureSize)   
  129.     {  
  130.         CCLOG("cocos2d: WARNING: Image (%u x %u) is bigger than the supported %u x %u", imageWidth, imageHeight, maxTextureSize, maxTextureSize);  
  131.         this->release();  
  132.         return NULL;  
  133.     }  
  134.       
  135.     //总是按加载ALPHA渐变的图片方式来生成OpenGL贴图  
  136.     return initPremultipliedATextureWithImage(uiImage, imageWidth, imageHeight);  
  137. }  
  138. //加载一个带ALPHA渐变的图片生成OpenGL贴图  
  139. bool CCTexture2D::initPremultipliedATextureWithImage(CCImage *image, unsigned int width, unsigned int height)  
  140. {  
  141. //取得图片的相关信息  
  142. //定义指针变量指向图片像素数据。  
  143.     unsigned char*            tempData = image->getData();  
  144.     //定义无符号int指针变量,也是为了指向32位色深的图片像素数据,以便使指针直接对应指定的一个像素数据位置。  
  145.     unsigned int*             inPixel32 = NULL;  
  146.     //定义无符号char指针变量,也是为了指向8位色深的图片像素数据,以便使指针直接对应指定的一个像素数据位置。  
  147.     unsigned char*            inPixel8 = NULL;  
  148.     //定义无符号short指针变量,指向16位色深的贴图像素数据,以便使指针直接对应指定的一个像素数据位置。  
  149.     unsigned short*           outPixel16 = NULL;  
  150.     //定义bool变量hasAlpha取得图片是否有Alpha通道。  
  151.     bool                      hasAlpha = image->hasAlpha();  
  152.     //定义变量imageSize保存图片大小。  
  153.     CCSize                    imageSize = CCSizeMake((float)(image->getWidth()), (float)(image->getHeight()));  
  154.     //定义变量pixelFormat用来保存贴图的像素格式。  
  155.     CCTexture2DPixelFormat    pixelFormat;  
  156.     //定义变量bpp保存图片的色深。  
  157.     size_t                    bpp = image->getBitsPerComponent();  
  158.   
  159. // 如果有ALPHA通道,使用默认的RGBA8888格式。  
  160. if(hasAlpha)  
  161.     {  
  162.         pixelFormat = g_defaultAlphaPixelFormat;  
  163.     }  
  164.     else  
  165.     {    //如果没有ALPHA通道  
  166.          //如果色深大于等于8,则转为RGB888格式,否则转为RGB565格式。这里有点问题,感觉应该按色深大于16来进行判断。即24和32位都转为RGB888,而16位及以下转为RGB565。  
  167.         if (bpp >= 8)  
  168.         {  
  169.             pixelFormat = kCCTexture2DPixelFormat_RGB888;  
  170.         }  
  171.         else   
  172.         {  
  173.             pixelFormat = kCCTexture2DPixelFormat_RGB565;  
  174.         }  
  175.           
  176.     }  
  177.       
  178.     // 取得数据的长度  
  179.     unsigned int length = width * height;  
  180.     //根据图片的不同格式和要创建的纹理格式,将数据填充到纹理中。  
  181.     if (pixelFormat == kCCTexture2DPixelFormat_RGB565)  
  182. {  
  183.  //根据是否有ALPHA通道来分别进行填充处理  
  184.         if (hasAlpha)  
  185.         {  
  186.              // 转换RGBA8888到RGB565  
  187.             // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRRGGGGGGBBBBB"  
  188.             //一个像素占2个字节,所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
  189.             tempData = new unsigned char[width * height * 2];  
  190.              //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
  191.             outPixel16 = (unsigned short*)tempData;  
  192.              //因为有alpha,则图片是32位RGBA8888格式。取得图像的像素数据地址返回给unsigned int指针,则inPixel32指向了贴图中第一个像素的数据位置。  
  193.             inPixel32 = (unsigned int*)image->getData();  
  194.             //遍历图片中所有的像素,逐像素处理。  
  195.             for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
  196.             {   //将inPixel32指向的unsigned int数据通过取出R,G,B各8位数据值,然后组成RGB565值。放入outPixel16指向的unsigned short数据中。  
  197.                 *outPixel16++ =   
  198.                 ((((*inPixel32 >>  0) & 0xFF) >> 3) << 11) |  // R  
  199.                 ((((*inPixel32 >>  8) & 0xFF) >> 2) << 5)  |  // G  
  200.                 ((((*inPixel32 >> 16) & 0xFF) >> 3) << 0);    // B  
  201.             }  
  202.         }  
  203.         else   
  204.         {    // 转换RGB888到RGB565  
  205.             // Convert "RRRRRRRRRGGGGGGGGBBBBBBBB" to "RRRRRGGGGGGBBBBB"  
  206.             //一个像素占2个字节,所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
  207.             tempData = new unsigned char[width * height * 2];  
  208.             //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
  209.             outPixel16 = (unsigned short*)tempData;  
  210.             //如果图像的格式为RGB888。取得图像的像素数据地址返回给unsigned char指针,则inPixel8指向了贴图中第一个像素的R值位置。  
  211.             inPixel8 = (unsigned char*)image->getData();  
  212.             //遍历图片中所有的像素,逐像素处理。  
  213.             for(unsigned int i = 0; i < length; ++i)  
  214.             {   //inPixel8指向的是unsigned char值,通过++操作来取出R,G,B数据值,然后组成RGB565值。放入outPixel16指向的unsigned short数据中。  
  215.   
  216.                 *outPixel16++ =   
  217.                 (((*inPixel8++ & 0xFF) >> 3) << 11) |  // R  
  218.                 (((*inPixel8++ & 0xFF) >> 2) << 5)  |  // G  
  219.                 (((*inPixel8++ & 0xFF) >> 3) << 0);    // B  
  220.             }  
  221.         }      
  222.     }  
  223.     else if (pixelFormat == kCCTexture2DPixelFormat_RGBA4444)  
  224.     {   // 转换RGBA8888到RGBA4444  
  225.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRGGGGBBBBAAAA"  
  226.         //取得图像的像素数据地址返回给unsigned int指针,则inPixel32指向了贴图中第一个像素的数据位置。  
  227.         inPixel32 = (unsigned int*)image->getData();    
  228.          //一个像素占2个字节,所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
  229.         tempData = new unsigned char[width * height * 2];  
  230.         //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
  231.         outPixel16 = (unsigned short*)tempData;  
  232.         //遍历图片中所有的像素,逐像素处理。  
  233.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
  234.         {   //将inPixel32指向的unsigned int数据通过取出R,G,B,A各8位数据值,然后组成RGBA4444值。放入outPixel16指向的unsigned short数据中。  
  235.             *outPixel16++ =   
  236.             ((((*inPixel32 >> 0) & 0xFF) >> 4) << 12) | // R  
  237.             ((((*inPixel32 >> 8) & 0xFF) >> 4) <<  8) | // G  
  238.             ((((*inPixel32 >> 16) & 0xFF) >> 4) << 4) | // B  
  239.             ((((*inPixel32 >> 24) & 0xFF) >> 4) << 0);  // A  
  240.         }  
  241.     }  
  242.     else if (pixelFormat == kCCTexture2DPixelFormat_RGB5A1)  
  243.     {   // 转换RGBA8888到RGBA5551  
  244.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRRGGGGGBBBBBA"  
  245.         inPixel32 = (unsigned int*)image->getData();     
  246.          //一个像素占2个字节,所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。  
  247.         tempData = new unsigned char[width * height * 2];  
  248.         //将贴图像素数据的地址返回给unsigned short指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。  
  249.         outPixel16 = (unsigned short*)tempData;  
  250.         //遍历图片中所有的像素,逐像素处理。  
  251.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
  252.         {   //将inPixel32指向的unsigned int数据通过取出R,G,B,A各8位数据值,然后组成RGB5A1值。放入outPixel16指向的unsigned short数据中。  
  253.             *outPixel16++ =   
  254.             ((((*inPixel32 >> 0) & 0xFF) >> 3) << 11) | // R  
  255.             ((((*inPixel32 >> 8) & 0xFF) >> 3) <<  6) | // G  
  256.             ((((*inPixel32 >> 16) & 0xFF) >> 3) << 1) | // B  
  257.             ((((*inPixel32 >> 24) & 0xFF) >> 7) << 0);  // A  
  258.         }  
  259.     }  
  260.     else if (pixelFormat == kCCTexture2DPixelFormat_A8)  
  261.     {   // 转换RGBA8888到A8,同理,不再赘述  
  262.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "AAAAAAAA"  
  263.         inPixel32 = (unsigned int*)image->getData();  
  264.         tempData = new unsigned char[width * height];  
  265.         unsigned char *outPixel8 = tempData;  
  266.           
  267.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
  268.         {  
  269.             *outPixel8++ = (*inPixel32 >> 24) & 0xFF;  // A  
  270.         }  
  271.     }  
  272.       
  273.     if (hasAlpha && pixelFormat == kCCTexture2DPixelFormat_RGB888)  
  274.     {   // 转换RGBA8888到RGB888,同理,不再赘述  
  275.         // Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRRRRRGGGGGGGGBBBBBBBB"  
  276.         inPixel32 = (unsigned int*)image->getData();  
  277.         tempData = new unsigned char[width * height * 3];  
  278.         unsigned char *outPixel8 = tempData;  
  279.           
  280.         for(unsigned int i = 0; i < length; ++i, ++inPixel32)  
  281.         {  
  282.             *outPixel8++ = (*inPixel32 >> 0) & 0xFF; // R  
  283.             *outPixel8++ = (*inPixel32 >> 8) & 0xFF; // G  
  284.             *outPixel8++ = (*inPixel32 >> 16) & 0xFF; // B  
  285.         }  
  286.     }  
  287.     //因为最终相应像素格式的数据都存放在tempData中,所以这里通过像素数据来生成OpenGL贴图。  
  288.     initWithData(tempData, pixelFormat, width, height, imageSize);  
  289.     //如果是以上相应格式,则tempData都是新申请的内存块,则在这里释放申请的内存。  
  290.     if (tempData != image->getData())  
  291.     {  
  292.         delete [] tempData;  
  293.     }  
  294. //取得是否有ALPHA渐变通道数据  
  295.     m_bHasPremultipliedAlpha = image->isPremultipliedAlpha();  
  296.     return true;  
  297. }  
  298.   

  299. // 从字符串中创建OpenGL 贴图,可指定更多参数。  
  300. //参1:字符串  
  301. //参2:返回参数,代表在屏幕上占用的区域大小  
  302. //参3:文字的横向对齐方式  
  303. //参4:文字的纵向对齐方式  
  304. //参5:字体名称  
  305. //参6:字体大小  
  306. bool CCTexture2D::initWithString(const char *text, const CCSize& dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment, const char *fontName, float fontSize)  
  307. {  
  308.     //如果定义使用可变纹理  
  309. #if CC_ENABLE_CACHE_TEXTURE_DATA  
  310.     // cache the texture data  
  311.     VolatileTexture::addStringTexture(this, text, dimensions, hAlignment, vAlignment, fontName, fontSize);  
  312. #endif  
  313.     //定义一个CCImage实例对象  
  314.     CCImage image;  
  315.     //定义一个CCImage进行由字符串创建图片时指定的文字对齐方式的变量eAlign  
  316.     CCImage::ETextAlign eAlign;  
  317.     //如果文字纵向对齐方式为顶部对齐。  
  318.     if (kCCVerticalTextAlignmentTop == vAlignment)  
  319.     {      
  320.         //根据文字横向对齐方式的不同分别对eAlign进行设置。  
  321.         eAlign = (kCCTextAlignmentCenter == hAlignment) ? CCImage::kAlignTop  
  322.             : (kCCTextAlignmentLeft == hAlignment) ? CCImage::kAlignTopLeft : CCImage::kAlignTopRight;  
  323.     }  
  324.     //如果文字纵向对齐方式为居中对齐。  
  325.     else if (kCCVerticalTextAlignmentCenter == vAlignment)  
  326.     {  
  327.         //根据文字横向对齐方式的不同分别对eAlign进行设置。  
  328.         eAlign = (kCCTextAlignmentCenter == hAlignment) ? CCImage::kAlignCenter  
  329.             : (kCCTextAlignmentLeft == hAlignment) ? CCImage::kAlignLeft : CCImage::kAlignRight;  
  330.     }  
  331.     //如果文字纵向对齐方式为底部对齐。  
  332.     else if (kCCVerticalTextAlignmentBottom == vAlignment)  
  333.     {  
  334.         //根据文字横向对齐方式的不同分别对eAlign进行设置。  
  335.         eAlign = (kCCTextAlignmentCenter == hAlignment) ? CCImage::kAlignBottom  
  336.             : (kCCTextAlignmentLeft == hAlignment) ? CCImage::kAlignBottomLeft : CCImage::kAlignBottomRight;  
  337.     }  
  338.     else  
  339.     {  
  340.          //其它对齐方式不应存在,故打印错误。  
  341.         CCAssert(false"Not supported alignment format!");  
  342.     }  
  343.     //调用CCImage的成员函数由字符串创建出图片数据。  
  344.     if (!image.initWithString(text, (int)dimensions.width, (int)dimensions.height, eAlign, fontName, (int)fontSize))  
  345.     {  
  346.         return false;  
  347.     }  
  348.     //再由CCImage实例对象来创建出OpenGL贴图,初始化纹理。  
  349.     return initWithImage(&image);  
  350. }  
  351.   
  352.   
  353. // 在指定的位置绘制贴图。  
  354. void CCTexture2D::drawAtPoint(const CCPoint& point)  
  355. {   //定义贴图中图像区域的UV坐标。从左上至右下。  
  356.     GLfloat    coordinates[] = {      
  357.         0.0f,    m_fMaxT,  
  358.         m_fMaxS,m_fMaxT,  
  359.         0.0f,    0.0f,  
  360.         m_fMaxS,0.0f };  
  361.     //取得贴图中图像区域的宽高  
  362.     GLfloat    width = (GLfloat)m_uPixelsWide * m_fMaxS,  
  363.         height = (GLfloat)m_uPixelsHigh * m_fMaxT;  
  364.     //定义对应的顶点坐标  
  365.     GLfloat        vertices[] = {      
  366.         point.x,            point.y,  
  367.         width + point.x,    point.y,  
  368.         point.x,            height  + point.y,  
  369.         width + point.x,    height  + point.y };  
  370.     //Shader中使用位置和纹理坐标通道。  
  371.     ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords );  
  372.     //后面的代码便用Shader进行渲染  
  373.     m_pShaderProgram->use();  
  374.     //设置Shader使用的最终结果矩阵  
  375.     m_pShaderProgram->setUniformForModelViewProjectionMatrix();  
  376.     //将贴图绑定  
  377.     ccGLBindTexture2D( m_uName );  
  378.   
  379.     //将vertices设置为顶点位置参数  
  380.     glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices);  
  381.     //将coordinates设置为顶点的纹理坐标参数  
  382.     glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, coordinates);  
  383.     //绘制三角形,参1为绘图方式,参2为顶点起始索引,参3为三角形面数。  
  384.     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);  
  385. }  
  386. //绘制纹理上的一个区域。  
  387. void CCTexture2D::drawInRect(const CCRect& rect)  
  388. {   //定义贴图中图像区域的UV坐标。从左上至右下。  
  389.     GLfloat    coordinates[] = {      
  390.         0.0f,    m_fMaxT,  
  391.         m_fMaxS,m_fMaxT,  
  392.         0.0f,    0.0f,  
  393.         m_fMaxS,0.0f };  
  394.     //绘制到的区域  
  395.     GLfloat    vertices[] = {    rect.origin.x,        rect.origin.y,                            /*0.0f,*/  
  396.         rect.origin.x + rect.size.width,        rect.origin.y,                            /*0.0f,*/  
  397.         rect.origin.x,                            rect.origin.y + rect.size.height,        /*0.0f,*/  
  398.         rect.origin.x + rect.size.width,        rect.origin.y + rect.size.height,        /*0.0f*/ };  
  399.     //Shader中使用位置和纹理坐标通道。  
  400.     ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords );  
  401.     //后面的代码便用Shader进行渲染  
  402.     m_pShaderProgram->use();  
  403.     //设置Shader使用的最终结果矩阵  
  404.     m_pShaderProgram->setUniformForModelViewProjectionMatrix();  
  405.     //将贴图绑定  
  406.     ccGLBindTexture2D( m_uName );  
  407.     //将vertices设置为顶点位置参数  
  408.     glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices);  
  409.     //将coordinates设置为顶点的纹理坐标参数  
  410.     glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, coordinates);  
  411.     //绘制三角形,参1为绘图方式,参2为顶点起始索引,参3为三角形面数。  
  412.     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);  
  413. }  
  414.   
  415. #ifdef CC_SUPPORT_PVRTC  
  416.   
  417. // 如果支持PVR文件的压缩格式。提供的读取PVR压缩文件的函数。     
  418. bool CCTexture2D::initWithPVRTCData(const void *data, int level, int bpp, bool hasAlpha, int length, CCTexture2DPixelFormat pixelFormat)  
  419. {  
  420.     if( !(CCConfiguration::sharedConfiguration()->supportsPVRTC()) )  
  421.     {  
  422.         CCLOG("cocos2d: WARNING: PVRTC images is not supported.");  
  423.         this->release();  
  424.         return false;  
  425.     }  
  426. //产生一个OpenGL的贴图索引。  
  427. glGenTextures(1, &m_uName);  
  428.     //绑定纹理  
  429.     glBindTexture(GL_TEXTURE_2D, m_uName);  
  430.     //设置纹理抗锯齿  
  431.     this->setAntiAliasTexParameters();  
  432.     //贴图格式  
  433.     GLenum format;  
  434.     //数据大小  
  435.     GLsizei size = length * length * bpp / 8;  
  436.     //根据是否有Alpha来取得贴图格式  
  437.     if(hasAlpha) {  
  438.         format = (bpp == 4) ? GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG : GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;  
  439.     } else {  
  440.         format = (bpp == 4) ? GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG : GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;  
  441.     }  
  442.     if(size < 32) {  
  443.         size = 32;  
  444.     }  
  445.     //加载压缩纹理。  
  446.     glCompressedTexImage2D(GL_TEXTURE_2D, level, format, length, length, 0, size, data);  
  447.     //设置其它属性。  
  448.     m_tContentSize = CCSizeMake((float)(length), (float)(length));  
  449.     m_uPixelsWide = length;  
  450.     m_uPixelsHigh = length;  
  451.     m_fMaxS = 1.0f;  
  452.     m_fMaxT = 1.0f;  
  453.     m_bHasPremultipliedAlpha = PVRHaveAlphaPremultiplied_;  
  454.     m_ePixelFormat = pixelFormat;  
  455.   
  456.     return true;  
  457. }  
  458. #endif // CC_SUPPORT_PVRTC  
  459. //加载PVR普通文件的函数。  
  460. bool CCTexture2D::initWithPVRFile(const char* file)  
  461. {  
  462.     bool bRet = false;  
  463.     // nothing to do with CCObject::init  
  464.       
  465.     CCTexturePVR *pvr = new CCTexturePVR;  
  466.     bRet = pvr->initWithContentsOfFile(file);  
  467.           
  468.     if (bRet)  
  469.     {  
  470.         pvr->setRetainName(true); // don't dealloc texture on release  
  471.           
  472.         m_uName = pvr->getName();  
  473.         m_fMaxS = 1.0f;  
  474.         m_fMaxT = 1.0f;  
  475.         m_uPixelsWide = pvr->getWidth();  
  476.         m_uPixelsHigh = pvr->getHeight();  
  477.         m_tContentSize = CCSizeMake((float)m_uPixelsWide, (float)m_uPixelsHigh);  
  478.         m_bHasPremultipliedAlpha = PVRHaveAlphaPremultiplied_;  
  479.         m_ePixelFormat = pvr->getFormat();  
  480.         m_bHasMipmaps = pvr->getNumberOfMipmaps() > 1;         
  481.   
  482.         pvr->release();  
  483.     }  
  484.     else  
  485.     {  
  486.         CCLOG("cocos2d: Couldn't load PVR image %s", file);  
  487.     }  
  488.   
  489.     return bRet;  
  490. }  
  491.       
  492. //生成多级纹理。  
  493. void CCTexture2D::generateMipmap()  
  494. {  
  495.     CCAssert( m_uPixelsWide == ccNextPOT(m_uPixelsWide) && m_uPixelsHigh == ccNextPOT(m_uPixelsHigh), "Mimpap texture only works in POT textures");  
  496.     ccGLBindTexture2D( m_uName );  
  497.     glGenerateMipmap(GL_TEXTURE_2D);  
  498.     m_bHasMipmaps = true;  
  499. }  

  500. //设置纹理参数。  
  501. void CCTexture2D::setTexParameters(ccTexParams *texParams)  
  502. {  
  503.     CCAssert( (m_uPixelsWide == ccNextPOT(m_uPixelsWide) || texParams->wrapS == GL_CLAMP_TO_EDGE) &&  
  504.         (m_uPixelsHigh == ccNextPOT(m_uPixelsHigh) || texParams->wrapT == GL_CLAMP_TO_EDGE),  
  505.         "GL_CLAMP_TO_EDGE should be used in NPOT dimensions");  
  506.   
  507.     ccGLBindTexture2D( m_uName );  
  508.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texParams->minFilter );  
  509.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texParams->magFilter );  
  510.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texParams->wrapS );  
  511.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texParams->wrapT );  
  512. }  
  513. //设置为非抗锯齿纹理模式  
  514. void CCTexture2D::setAliasTexParameters()  
  515. {   //绑定纹理  
  516.     ccGLBindTexture2D( m_uName );  
  517.     //设置多级纹理  
  518.     if( ! m_bHasMipmaps )  
  519.     {     
  520.         //设置最小滤波方式为最近点采样,这种方式最快,但有锯齿。  
  521.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );  
  522.     }  
  523.     else  
  524.     {    //设置最小滤波方式为多级纹理方式。  
  525.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST );  
  526.     }  
  527.     //设置放大滤波方式为最近点采样  
  528.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );  
  529. }  
  530. //设置为抗锯齿纹理模式  
  531. void CCTexture2D::setAntiAliasTexParameters()  
  532. {   //绑定纹理  
  533.     ccGLBindTexture2D( m_uName );  
  534.     //设置多级纹理  
  535.     if( ! m_bHasMipmaps )  
  536.     {  
  537.         //设置最小滤波方式为线性过滤,这种方式纹理会有一定程度模糊。  
  538.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );  
  539.     }  
  540.     else  
  541.     {   //设置最小滤波方式为多级纹理方式。  
  542.         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );  
  543.     }  
  544.     //设置放大滤波方式为最近点采样  
  545.     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );  
  546. }  
  547. //取得纹理格式的名字字符串  
  548. const char* CCTexture2D::stringForFormat()  
  549. {  
  550.     switch (m_ePixelFormat)   
  551.     {  
  552.         case kCCTexture2DPixelFormat_RGBA8888:  
  553.             return  "RGBA8888";  
  554.   
  555.         case kCCTexture2DPixelFormat_RGB888:  
  556.             return  "RGB888";  
  557.   
  558.         case kCCTexture2DPixelFormat_RGB565:  
  559.             return  "RGB565";  
  560.   
  561.         case kCCTexture2DPixelFormat_RGBA4444:  
  562.             return  "RGBA4444";  
  563.   
  564.         case kCCTexture2DPixelFormat_RGB5A1:  
  565.             return  "RGB5A1";  
  566.   
  567.         case kCCTexture2DPixelFormat_AI88:  
  568.             return  "AI88";  
  569.   
  570.         case kCCTexture2DPixelFormat_A8:  
  571.             return  "A8";  
  572.   
  573.         case kCCTexture2DPixelFormat_I8:  
  574.             return  "I8";  
  575.   
  576.         case kCCTexture2DPixelFormat_PVRTC4:  
  577.             return  "PVRTC4";  
  578.   
  579.         case kCCTexture2DPixelFormat_PVRTC2:  
  580.             return  "PVRTC2";  
  581.   
  582.         default:  
  583.             CCAssert(false , "unrecognised pixel format");  
  584.             CCLOG("stringForFormat: %ld, cannot give useful result", (long)m_ePixelFormat);  
  585.             break;  
  586.     }  
  587.   
  588.     return  NULL;  
  589. }  
  590.   
  591.   
  592. //取得相应纹理格式的色深。  
  593. unsigned int CCTexture2D::bitsPerPixelForFormat(CCTexture2DPixelFormat format)  
  594. {  
  595.     unsigned int ret=0;  
  596.   
  597.     switch (format) {  
  598.         case kCCTexture2DPixelFormat_RGBA8888:  
  599.             ret = 32;//32位真彩色  
  600.             break;  
  601.         case kCCTexture2DPixelFormat_RGB888:  
  602.             // 看起来是用24位,但内部实际是用DWORD来存数据的,所以还是32位。只不过Alpha通道没用。  
  603.             ret = 32;  
  604.             break;  
  605.         case kCCTexture2DPixelFormat_RGB565:  
  606.             ret = 16;  
  607.             break;  
  608.         case kCCTexture2DPixelFormat_RGBA4444:  
  609.             ret = 16;  
  610.             break;  
  611.         case kCCTexture2DPixelFormat_RGB5A1:  
  612.             ret = 16;  
  613.             break;  
  614.         case kCCTexture2DPixelFormat_AI88:  
  615.             ret = 16;  
  616.             break;  
  617.         case kCCTexture2DPixelFormat_A8:  
  618.             ret = 8;  
  619.             break;  
  620.         case kCCTexture2DPixelFormat_I8:  
  621.             ret = 8;  
  622.             break;  
  623.         case kCCTexture2DPixelFormat_PVRTC4:  
  624.             ret = 4;  
  625.             break;  
  626.         case kCCTexture2DPixelFormat_PVRTC2:  
  627.             ret = 2;  
  628.             break;  
  629.         default:  
  630.             ret = -1;  
  631.             CCAssert(false , "unrecognised pixel format");  
  632.             CCLOG("bitsPerPixelForFormat: %ld, cannot give useful result", (long)format);  
  633.             break;  
  634.     }  
  635.     return ret;  
  636. }  

  637. NS_CC_END  


你可能感兴趣的:(CCTexture2D(CCTexture2D类可以方便的从图片,文本或raw数据文件中创建OpenGL所用贴图 initWithData drawAtPoint initWithString))