加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 百科 > 正文

深入分析Cocos2d-x 2.0中的“纹理”

发布时间：2020-12-14 19:05:28 所属栏目：百科 来源：网络整理
导读：我们来看一下cocos2d-x中的libcocos2d库，其下有许多目录，找到textures展开，可以看到有CCTexture2D,CCTextureAtlas,CCTextureCache,CCTexturePVR四个类。 这四个类的功能分别是： CCTexture2D : 纹理，即图片加载入内存后供CPU和GPU操作的贴图对象。 CCTex


我们来看一下cocos2d-x中的libcocos2d库，其下有许多目录，找到textures展开，可以看到有CCTexture2D,CCTextureAtlas,CCTextureCache,CCTexturePVR四个类。


这四个类的功能分别是：

CCTexture2D: 纹理，即图片加载入内存后供CPU和GPU操作的贴图对象。

CCTexturePVR:处理PVR文件生成纹理的类，提示：大家可以用它解析愤怒的小鸟中的图片。

CCTextureCache:纹理管理器，负责加载图片并对生成的纹理进行管理。通过“字典”来进行快速的查询。

CCTextureAtlas:纹理块管理器，如果图片是由多个小图块组成的，则纹理块管理器用来存储这些小图块的相关信息，以方便绘制相应图块。


为了让大家更好的学习纹理，在讲解纹理的代码之前我已经先给大家分析了本章用到的两个功能类：

CCImage和CCDictionary。这两个类分别在纹理模块中担任加载图片和管理纹理指针的作用。希望大家先顶一下这两篇贴子之后再开始下面的代码学习，你一定会感到非常容易。

一．CCTexture2D:

好，咱们现在开始看CCTexture2D:

源码 打印 ？
  1. #ifndef__CCTEXTURE2D_H__
  2. #define__CCTEXTURE2D_H__
  4. #include<string>
  5. #include"cocoa/CCObject.h"
  6. #include"cocoa/CCGeometry.h"
  7. #include"ccTypes.h"
  9. //Cocos2d命名空间
  10. NS_CC_BEGIN
  11. //需要用到CCImage，这里声明一下。
  12. classCCImage;
  14. //纹理格式:即每个纹理中的像素单位分别是怎么为颜色值进行实际内存分配的。这个非常重要，我们在进行游戏开发的过程中，会常常与各种图片类型打交通。每种图片往往也有各自的像素格式。但当它们一旦加载到游戏中后，就会根据我们的要求变成以下某种类型的纹理。不同的纹理格式所占据的内存大小可能不同，我们要根据实际情况和需求来选择相应的纹理格式。比如我们用RGBA8888纹理格式来创建纹理，它占据的内存容量很大，如果我们要显示的纹理中没有ALPHA值，那就不应该使用带ALPHA通道的纹理格式。我们就可以改成RGB565像素格式。
  16. typedefenum{
  18. //32位真彩色，最真但最耗内存
  19. kCCTexture2DPixelFormat_RGBA8888,
  20. //24位真彩色，去掉了ALPHA通道
  21. kCCTexture2DPixelFormat_RGB888,
  22. //16位色，将RGB压缩在一个字中。绿色多了1位，因为人眼对绿色更敏感。
  23. kCCTexture2DPixelFormat_RGB565,
  24. //8位色，只存ALPHA值，做遮罩图用
  25. kCCTexture2DPixelFormat_A8,
  26. //8位色，只存灰度或者强度值，做灰度图用
  27. kCCTexture2DPixelFormat_I8,
  28. //16位色，只存ALPHA值与强度值，双功能
  29. kCCTexture2DPixelFormat_AI88,
  30. //16位色，RGBA四通道各占4位。
  31. kCCTexture2DPixelFormat_RGBA4444,
  32. //16位色，RGB三通道各占5位，多1位留做ALPHA镂空使用
  33. kCCTexture2DPixelFormat_RGB5A1,
  34. //PVR的PVRTC4压缩格式
  35. kCCTexture2DPixelFormat_PVRTC4,
  36. //PVRTC的PVRTC2压缩格式
  37. kCCTexture2DPixelFormat_PVRTC2,
  39. //默认格式RGBA8888
  40. kCCTexture2DPixelFormat_Default=kCCTexture2DPixelFormat_RGBA8888,
  42. //为了兼容性而保留的枚举值
  43. kTexture2DPixelFormat_RGBA8888=kCCTexture2DPixelFormat_RGBA8888,
  44. kTexture2DPixelFormat_RGB888=kCCTexture2DPixelFormat_RGB888,
  45. kTexture2DPixelFormat_RGB565=kCCTexture2DPixelFormat_RGB565,
  46. kTexture2DPixelFormat_A8=kCCTexture2DPixelFormat_A8,
  47. kTexture2DPixelFormat_RGBA4444=kCCTexture2DPixelFormat_RGBA4444,
  48. kTexture2DPixelFormat_RGB5A1=kCCTexture2DPixelFormat_RGB5A1,
  49. kTexture2DPixelFormat_Default=kCCTexture2DPixelFormat_Default
  51. }CCTexture2DPixelFormat;
  53. //需要使用Shader代码片段，这里声明一下
  54. classCCGLProgram;
  56. //定义了纹理的一些参数
  57. typedefstruct_ccTexParams{
  58. GLuintminFilter;//纹理过滤器：缩小过滤器
  59. GLuintmagFilter;//纹理过滤器：放大过滤器
  60. GLuintwrapS;//横向纹理寻址模式
  61. GLuintwrapT;//纵向纹理寻址模式
  62. }ccTexParams;
  65. //CCTexture2D类可以方便的从图片，文本或raw数据文件中创建OpenGL所用贴图，创建的贴图会自动转为2的幂次方大小，所以要注意对于贴图坐标的影响。
  67. classCC_DLLCCTexture2D:publicCCObject
  68. {
  69. public:
  70. //构造
  71. CCTexture2D();
  72. //析构
  73. virtual~CCTexture2D();
  74. //取得纹理的描述
  75. constchar*description(void);
  77. //释放数据
  78. voidreleaseData(void*data);
  79. //保存数据
  80. void*keepData(void*data,unsignedintlength);
  82. //由数据指针和指定的像素格式，图片宽高，来生成OpenGL贴图。
  83. boolinitWithData(constvoid*data,CCTexture2DPixelFormatpixelFormat,unsignedintpixelsWide,unsignedintpixelsHigh,constCCSize&contentSize);
  85. //在指定的位置绘制贴图
  86. voiddrawAtPoint(constCCPoint&point);
  87. //纹制贴图上的一个图像块
  88. voiddrawInRect(constCCRect&rect);
  90. //由CCImage指针生成OpenGL贴图
  91. boolinitWithImage(CCImage*uiImage);
  93. //由一个字符串生成OpenGL贴图。
  94. boolinitWithString(constchar*text,constCCSize&dimensions,CCTextAlignmenthAlignment,CCVerticalTextAlignmentvAlignment,constchar*fontName,floatfontSize);
  95. //由一个字符串和指定的字体与大小生成OpenGL贴图
  96. boolinitWithString(constchar*text,floatfontSize);
  98. //如果支持PVR的压缩格式
  99. #ifdefCC_SUPPORT_PVRTC
  100. //由一个PVR压缩格式的数据生成OpenGL贴图
  101. boolinitWithPVRTCData(constvoid*data,intlevel,intbpp,boolhasAlpha,intlength,CCTexture2DPixelFormatpixelFormat);
  102. #endif//CC_SUPPORT_PVRTC
  104. //从普通PVR文件生成OpenGL贴图
  105. boolinitWithPVRFile(constchar*file);
  107. //设置贴图参数
  108. voidsetTexParameters(ccTexParams*texParams);
  110. //设置为抗锯齿的贴图过滤方式（线性过滤）
  111. voidsetAntiAliasTexParameters();
  113. //设置为非抗锯齿的贴图过滤方式（最近点采样）
  114. voidsetAliasTexParameters();
  117. //生成多级贴图:由图片数据生成一系列尺寸为2的幂次方直至当前贴图大小的贴图。系统会根据距离自动选择纹理图片。可以解决大图片显示在小空间时的闪烁问题。
  118. voidgenerateMipmap();
  120. //取得像素格式名称
  121. constchar*stringForFormat();
  123. //返回当前贴图色深，即每个像素占多少位
  124. unsignedintbitsPerPixelForFormat();
  126. //通过参数贴图格式返回纹理色深
  127. unsignedintbitsPerPixelForFormat(CCTexture2DPixelFormatformat);
  130. //静态函数，用于设置默认带ALPHA通道的贴图像素格式。则图片创建为贴图时，如果有ALPHA通道，则生成此默认贴图像素格式。
  131. staticvoidsetDefaultAlphaPixelFormat(CCTexture2DPixelFormatformat);
  133. //静态函数，取得默认带ALPHA通道的贴图像素格式。
  134. staticCCTexture2DPixelFormatdefaultAlphaPixelFormat();
  136. //静态函数，设置载入PVR时是否开启ALPHA渐变，默认不开启，则ALPHA值只有是与否，无渐变。
  137. staticvoidPVRImagesHavePremultipliedAlpha(boolhaveAlphaPremultiplied);
  139. //取得图片大小（以像素为单位）
  140. constCCSize&getContentSizeInPixels();
  141. //是否有ALPHA渐变值
  142. boolhasPremultipliedAlpha();
  143. //是否有多级贴图
  144. boolhasMipmaps();
  145. private:
  146. //加载一个带ALPHA渐变的图片生成OpenGL贴图
  147. boolinitPremultipliedATextureWithImage(CCImage*image,unsignedintpixelsHigh);
  149. //ALPHA渐变开关
  150. boolm_bPVRHaveAlphaPremultiplied;
  152. //贴图格式变量及get接口
  153. CC_PROPERTY_READONLY(CCTexture2DPixelFormat,m_ePixelFormat,PixelFormat)
  154. //贴图宽度及get接口
  155. CC_PROPERTY_READONLY(unsignedint,m_uPixelsWide,PixelsWide)
  156. //贴图高度及get接口
  157. CC_PROPERTY_READONLY(unsignedint,m_uPixelsHigh,PixelsHigh)
  159. //OpenGL贴图索引及get接口
  160. CC_PROPERTY_READONLY(GLuint,m_uName,Name)
  162. //横向贴图坐标终点。因为图片如果不是2的幂次方，图片大小会小于贴图的大小，贴图一定是2的幂次方嘛，这时候横向的贴图坐标终点不是1.0。
  163. CC_PROPERTY(GLfloat,m_fMaxS,MaxS)
  164. //纵向贴图坐标终点。
  165. CC_PROPERTY(GLfloat,m_fMaxT,MaxT)
  166. //图片大小及get接口
  167. CC_PROPERTY_READONLY(CCSize,m_tContentSize,ContentSize)
  169. //ALPHA渐变开关
  170. boolm_bHasPremultipliedAlpha;
  171. //多级纹理开关
  172. boolm_bHasMipmaps;
  174. //Shader代码片段指针
  175. CC_PROPERTY(CCGLProgram*,m_pShaderProgram,ShaderProgram);
  176. };
  178. NS_CC_END
  180. #endif//__CCTEXTURE2D_H__

再来看CCTexture2D.cpp：


源码 打印 ？
  1. #include"CCTexture2D.h"
  2. #include"ccConfig.h"
  3. #include"ccMacros.h"
  4. #include"CCConfiguration.h"
  5. #include"platform/platform.h"
  6. #include"platform/CCImage.h"
  7. #include"CCGL.h"
  8. #include"support/ccUtils.h"
  9. #include"platform/CCPlatformMacros.h"
  10. #include"textures/CCTexturePVR.h"
  11. #include"CCDirector.h"
  12. #include"shaders/CCGLProgram.h"
  13. #include"shaders/ccGLStateCache.h"
  14. #include"shaders/CCShaderCache.h"
  15. //这里定义是否使用可变纹理
  16. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  17. #include"CCTextureCache.h"
  18. #endif
  19. //Cocos2d-x命名空间
  20. NS_CC_BEGIN
  23. //静态全局的默认贴图像素格式。缺省为kCCTexture2DPixelFormat_Default，即RGBA8888。
  24. staticCCTexture2DPixelFormatg_defaultAlphaPixelFormat=kCCTexture2DPixelFormat_Default;
  26. //静态全局的PVR是否有ALPHA渐变的开关变量，默认为否。
  27. staticboolPVRHaveAlphaPremultiplied_=false;
  29. //构造函数。
  30. CCTexture2D::CCTexture2D()
  31. :m_uPixelsWide(0)
  32. ,m_uPixelsHigh(0)
  33. ,m_uName(0)
  34. ,m_fMaxS(0.0)
  35. ,m_fMaxT(0.0)
  36. ,m_bHasPremultipliedAlpha(false)
  37. ,m_bHasMipmaps(false)
  38. ,m_bPVRHaveAlphaPremultiplied(true)
  39. ,m_pShaderProgram(NULL)
  40. {
  41. }
  42. //析构
  43. CCTexture2D::~CCTexture2D()
  44. {
  45. //如果使用可变纹理，删除此可变纹理中的数据。
  46. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  47. VolatileTexture::removeTexture(this);
  48. #endif
  49. //打印日志。
  50. CCLOGINFO("cocos2d:deallocingCCTexture2D%u.",m_uName);
  51. //释放所用到的Shader代码片段
  52. CC_SAFE_RELEASE(m_pShaderProgram);
  53. //释放OpenGL所用到的贴图。
  54. if(m_uName)
  55. {
  56. ccGLDeleteTexture(m_uName);
  57. }
  58. }
  59. //取得当前纹理的贴图像素格式。
  60. CCTexture2DPixelFormatCCTexture2D::getPixelFormat()
  61. {
  62. returnm_ePixelFormat;
  63. }
  64. //取得贴图宽度。
  65. unsignedintCCTexture2D::getPixelsWide()
  66. {
  67. returnm_uPixelsWide;
  68. }
  69. //取得贴图高度。
  70. unsignedintCCTexture2D::getPixelsHigh()
  71. {
  72. returnm_uPixelsHigh;
  73. }
  74. //取得贴图索引。
  75. GLuintCCTexture2D::getName()
  76. {
  77. returnm_uName;
  78. }
  79. //取得图片大小（以点为单位）
  80. CCSizeCCTexture2D::getContentSize()
  81. {
  82. //CC_CONTENT_SCALE_FACTOR宏返回的是在不同屏幕下的点与像素的比率。Mac电脑上返回1.而使用Retina显示屏的iphone上返回2。
  83. CCSizeret;
  84. ret.width=m_tContentSize.width/CC_CONTENT_SCALE_FACTOR();
  85. ret.height=m_tContentSize.height/CC_CONTENT_SCALE_FACTOR();
  87. returnret;
  88. }
  89. //取得图片大小（以像素为单位）
  90. constCCSize&CCTexture2D::getContentSizeInPixels()
  91. {
  92. returnm_tContentSize;
  93. }
  94. //取得横向的贴图坐标终点
  95. GLfloatCCTexture2D::getMaxS()
  96. {
  97. returnm_fMaxS;
  98. }
  99. //设置横向的贴图坐标终点
  100. voidCCTexture2D::setMaxS(GLfloatmaxS)
  101. {
  102. m_fMaxS=maxS;
  103. }
  104. //取得纵向的贴图坐标终点
  105. GLfloatCCTexture2D::getMaxT()
  106. {
  107. returnm_fMaxT;
  108. }
  109. //设置纵向的贴图坐标终点
  110. voidCCTexture2D::setMaxT(GLfloatmaxT)
  111. {
  112. m_fMaxT=maxT;
  113. }
  114. //所用到的Shader代码片段。
  115. CCGLProgram*CCTexture2D::getShaderProgram(void)
  116. {
  117. returnm_pShaderProgram;
  118. }
  119. //设置用到的Shader代码片段。
  120. voidCCTexture2D::setShaderProgram(CCGLProgram*pShaderProgram)
  121. {
  122. CC_SAFE_RETAIN(pShaderProgram);
  123. CC_SAFE_RELEASE(m_pShaderProgram);
  124. m_pShaderProgram=pShaderProgram;
  125. }
  126. //释放数据
  127. voidCCTexture2D::releaseData(void*data)
  128. {
  129. free(data);
  130. }
  131. //保存数据
  132. void*CCTexture2D::keepData(void*data,unsignedintlength)
  133. {
  134. //这里只是使用CC_UNUSED_PARAM宏用一下length，没什么实际功能。作者给出这个函数是预备未来供子类重载。
  135. CC_UNUSED_PARAM(length);
  136. returndata;
  137. }
  138. //是否有ALPHA渐变的通道数据。
  139. boolCCTexture2D::hasPremultipliedAlpha()
  140. {
  141. returnm_bHasPremultipliedAlpha;
  142. }
  143. //由数据指针创建指定大小和格式的贴图。取得创建成功后图片在贴图中的实际区域。
  144. boolCCTexture2D::initWithData(constvoid*data,constCCSize&contentSize)
  145. {
  146. //如果是RGBA8888格式或者大小正好就是2的幂次方。像素数据按四字节(DWORD)对齐。否则按1字节(BYTE)进行对齐。
  147. if(pixelFormat==kCCTexture2DPixelFormat_RGBA8888||(ccNextPOT(pixelsWide)==pixelsWide&&ccNextPOT(pixelsHigh)==pixelsHigh))
  148. {
  149. glPixelStorei(GL_UNPACK_ALIGNMENT,4);
  150. }
  151. else
  152. {
  153. glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  154. }
  155. //产生一个OpenGL的贴图索引。
  156. glGenTextures(1,&m_uName);
  157. //将此贴图绑定为GL_TEXTURE_2D纹理。
  158. ccGLBindTexture2D(m_uName);
  159. //设置OpenGL中的贴图的过滤参数。
  160. glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  161. glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  162. //设置贴图的横向纹理寻址模式为边缘截取模式。总是忽略边界。
  163. glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
  164. //设置贴图的纵向纹理寻址模式为边缘截取模式。总是忽略边界。
  165. glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
  167. //这里根据不同的像素格式来生成不同的OpenGL所用的贴图。注意：传入的宽和高在成功生成贴图后会返回实际贴图的宽和高。如果图片不是2的幂次方，这个数值会改成2的幂次方。比如你传入的图片宽高是148x245，则调用完成后宽高会转成256x256。
  168. switch(pixelFormat)
  169. {
  170. casekCCTexture2DPixelFormat_RGBA8888:
  171. glTexImage2D(GL_TEXTURE_2D,GL_RGBA,(GLsizei)pixelsWide,(GLsizei)pixelsHigh,GL_UNSIGNED_BYTE,data);
  172. break;
  173. casekCCTexture2DPixelFormat_RGB888:
  174. glTexImage2D(GL_TEXTURE_2D,GL_RGB,data);
  175. break;
  176. casekCCTexture2DPixelFormat_RGBA4444:
  177. glTexImage2D(GL_TEXTURE_2D,GL_UNSIGNED_SHORT_4_4_4_4,data);
  178. break;
  179. casekCCTexture2DPixelFormat_RGB5A1:
  180. glTexImage2D(GL_TEXTURE_2D,GL_UNSIGNED_SHORT_5_5_5_1,data);
  181. break;
  182. casekCCTexture2DPixelFormat_RGB565:
  183. glTexImage2D(GL_TEXTURE_2D,GL_UNSIGNED_SHORT_5_6_5,data);
  184. break;
  185. casekCCTexture2DPixelFormat_AI88:
  186. glTexImage2D(GL_TEXTURE_2D,GL_LUMINANCE_ALPHA,data);
  187. break;
  188. casekCCTexture2DPixelFormat_A8:
  189. glTexImage2D(GL_TEXTURE_2D,GL_ALPHA,data);
  190. break;
  191. casekCCTexture2DPixelFormat_I8:
  192. glTexImage2D(GL_TEXTURE_2D,GL_LUMINANCE,data);
  193. break;
  194. default:
  195. CCAssert(0,"NSInternalInconsistencyException");
  197. }
  198. //图片大小
  199. m_tContentSize=contentSize;
  200. //保存实际的贴图宽高
  201. m_uPixelsWide=pixelsWide;
  202. m_uPixelsHigh=pixelsHigh;
  203. //保存贴图的像素格式
  204. m_ePixelFormat=pixelFormat;
  205. //计算图片处于贴图中的横向和纵向的纹理坐标终点。
  206. m_fMaxS=contentSize.width/(float)(pixelsWide);
  207. m_fMaxT=contentSize.height/(float)(pixelsHigh);
  208. //默认不使用ALPHA渐变通道。
  209. m_bHasPremultipliedAlpha=false;
  210. //默认不使用多级纹理。
  211. m_bHasMipmaps=false;
  213. //设置使用kCCShader_PositionTexture对应类型的Shader。此Shader的顶点格式由位置和纹理坐标组成。
  214. setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTexture));
  216. returntrue;
  217. }
  219. //取得纹理的描述
  220. constchar*CCTexture2D::description(void)
  221. {
  222. returnCCString::createWithFormat("<CCTexture2D|Name=%u|Dimensions=%ux%u|Coordinates=(%.2f,%.2f)>",m_fMaxT)->getCString();
  223. }
  225. //由CCImage对象来初始化纹理生成OpenGL贴图。
  226. boolCCTexture2D::initWithImage(CCImage*uiImage)
  227. {
  228. //参数有效性判断。
  229. if(uiImage==NULL)
  230. {
  231. CCLOG("cocos2d:CCTexture2D.Can'tcreateTexture.UIImageisnil");
  232. this->release();
  233. returnfalse;
  234. }
  235. //取得图片的宽高
  236. unsignedintimageWidth=uiImage->getWidth();
  237. unsignedintimageHeight=uiImage->getHeight();
  238. //取得引擎的配置信息
  239. CCConfiguration*conf=CCConfiguration::sharedConfiguration();
  240. //取得配置信息中指定的最大纹理大小
  241. unsignedmaxTextureSize=conf->getMaxTextureSize();
  242. //如果当前图片大于指定的最大纹理大小，提示错误警告交释放当前纹理返回NULL。
  243. if(imageWidth>maxTextureSize||imageHeight>maxTextureSize)
  244. {
  245. CCLOG("cocos2d:WARNING:Image(%ux%u)isbiggerthanthesupported%ux%u",imageWidth,imageHeight,maxTextureSize,maxTextureSize);
  246. this->release();
  247. returnNULL;
  248. }
  250. //总是按加载ALPHA渐变的图片方式来生成OpenGL贴图
  251. returninitPremultipliedATextureWithImage(uiImage,imageHeight);
  252. }
  253. //加载一个带ALPHA渐变的图片生成OpenGL贴图
  254. boolCCTexture2D::initPremultipliedATextureWithImage(CCImage*image,unsignedintwidth,unsignedintheight)
  255. {
  256. //取得图片的相关信息
  257. //定义指针变量指向图片像素数据。
  258. unsignedchar*tempData=image->getData();
  259. //定义无符号int指针变量，也是为了指向32位色深的图片像素数据，以便使指针直接对应指定的一个像素数据位置。
  260. unsignedint*inPixel32=NULL;
  261. //定义无符号char指针变量，也是为了指向8位色深的图片像素数据，以便使指针直接对应指定的一个像素数据位置。
  262. unsignedchar*inPixel8=NULL;
  263. //定义无符号short指针变量，指向16位色深的贴图像素数据，以便使指针直接对应指定的一个像素数据位置。
  264. unsignedshort*outPixel16=NULL;
  265. //定义bool变量hasAlpha取得图片是否有Alpha通道。
  266. boolhasAlpha=image->hasAlpha();
  267. //定义变量imageSize保存图片大小。
  268. CCSizeimageSize=CCSizeMake((float)(image->getWidth()),(float)(image->getHeight()));
  269. //定义变量pixelFormat用来保存贴图的像素格式。
  270. CCTexture2DPixelFormatpixelFormat;
  271. //定义变量bpp保存图片的色深。
  272. size_tbpp=image->getBitsPerComponent();
  274. //如果有ALPHA通道，使用默认的RGBA8888格式。
  275. if(hasAlpha)
  276. {
  277. pixelFormat=g_defaultAlphaPixelFormat;
  278. }
  279. else
  280. {//如果没有ALPHA通道
  281. //如果色深大于等于8，则转为RGB888格式，否则转为RGB565格式。这里有点问题，感觉应该按色深大于16来进行判断。即24和32位都转为RGB888，而16位及以下转为RGB565。
  282. if(bpp>=8)
  283. {
  284. pixelFormat=kCCTexture2DPixelFormat_RGB888;
  285. }
  286. else
  287. {
  288. pixelFormat=kCCTexture2DPixelFormat_RGB565;
  289. }
  291. }
  293. //取得数据的长度
  294. unsignedintlength=width*height;
  295. //根据图片的不同格式和要创建的纹理格式，将数据填充到纹理中。
  296. if(pixelFormat==kCCTexture2DPixelFormat_RGB565)
  297. {
  298. //根据是否有ALPHA通道来分别进行填充处理
  299. if(hasAlpha)
  300. {
  301. //转换RGBA8888到RGB565
  302. //Convert"RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA"to"RRRRRGGGGGGBBBBB"
  303. //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。
  304. tempData=newunsignedchar[width*height*2];
  305. //将贴图像素数据的地址返回给unsignedshort指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。
  306. outPixel16=(unsignedshort*)tempData;
  307. //因为有alpha，则图片是32位RGBA8888格式。取得图像的像素数据地址返回给unsignedint指针，则inPixel32指向了贴图中第一个像素的数据位置。
  308. inPixel32=(unsignedint*)image->getData();
  309. //遍历图片中所有的像素，逐像素处理。
  310. for(unsignedinti=0;i<length;++i,++inPixel32)
  311. {//将inPixel32指向的unsignedint数据通过取出R,G,B各8位数据值，然后组成RGB565值。放入outPixel16指向的unsignedshort数据中。
  312. *outPixel16++=
  313. ((((*inPixel32>>0)&0xFF)>>3)<<11)|//R
  314. ((((*inPixel32>>8)&0xFF)>>2)<<5)|//G
  315. ((((*inPixel32>>16)&0xFF)>>3)<<0);//B
  316. }
  317. }
  318. else
  319. {//转换RGB888到RGB565
  320. //Convert"RRRRRRRRRGGGGGGGGBBBBBBBB"to"RRRRRGGGGGGBBBBB"
  321. //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。
  322. tempData=newunsignedchar[width*height*2];
  323. //将贴图像素数据的地址返回给unsignedshort指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。
  324. outPixel16=(unsignedshort*)tempData;
  325. //如果图像的格式为RGB888。取得图像的像素数据地址返回给unsignedchar指针，则inPixel8指向了贴图中第一个像素的R值位置。
  326. inPixel8=(unsignedchar*)image->getData();
  327. //遍历图片中所有的像素，逐像素处理。
  328. for(unsignedinti=0;i<length;++i)
  329. {//inPixel8指向的是unsignedchar值，通过++操作来取出R,B数据值，然后组成RGB565值。放入outPixel16指向的unsignedshort数据中。
  331. *outPixel16++=
  332. (((*inPixel8++&0xFF)>>3)<<11)|//R
  333. (((*inPixel8++&0xFF)>>2)<<5)|//G
  334. (((*inPixel8++&0xFF)>>3)<<0);//B
  335. }
  336. }
  337. }
  338. elseif(pixelFormat==kCCTexture2DPixelFormat_RGBA4444)
  339. {//转换RGBA8888到RGBA4444
  340. //Convert"RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA"to"RRRRGGGGBBBBAAAA"
  341. //取得图像的像素数据地址返回给unsignedint指针，则inPixel32指向了贴图中第一个像素的数据位置。
  342. inPixel32=(unsignedint*)image->getData();
  343. //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。
  344. tempData=newunsignedchar[width*height*2];
  345. //将贴图像素数据的地址返回给unsignedshort指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。
  346. outPixel16=(unsignedshort*)tempData;
  347. //遍历图片中所有的像素，逐像素处理。
  348. for(unsignedinti=0;i<length;++i,B,A各8位数据值，然后组成RGBA4444值。放入outPixel16指向的unsignedshort数据中。
  349. *outPixel16++=
  350. ((((*inPixel32>>0)&0xFF)>>4)<<12)|//R
  351. ((((*inPixel32>>8)&0xFF)>>4)<<8)|//G
  352. ((((*inPixel32>>16)&0xFF)>>4)<<4)|//B
  353. ((((*inPixel32>>24)&0xFF)>>4)<<0);//A
  354. }
  355. }
  356. elseif(pixelFormat==kCCTexture2DPixelFormat_RGB5A1)
  357. {//转换RGBA8888到RGBA5551
  358. //Convert"RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA"to"RRRRRGGGGGBBBBBA"
  359. inPixel32=(unsignedint*)image->getData();
  360. //一个像素占2个字节，所以图像中所有像素占用的字节数为width*height*2。由此大小申请内存作为贴图的像素数据。
  361. tempData=newunsignedchar[width*height*2];
  362. //将贴图像素数据的地址返回给unsignedshort指针。这样outPixel16就指向了贴图中的第一个像素的数据位置。
  363. outPixel16=(unsignedshort*)tempData;
  364. //遍历图片中所有的像素，逐像素处理。
  365. for(unsignedinti=0;i<length;++i,A各8位数据值，然后组成RGB5A1值。放入outPixel16指向的unsignedshort数据中。
  366. *outPixel16++=
  367. ((((*inPixel32>>0)&0xFF)>>3)<<11)|//R
  368. ((((*inPixel32>>8)&0xFF)>>3)<<6)|//G
  369. ((((*inPixel32>>16)&0xFF)>>3)<<1)|//B
  370. ((((*inPixel32>>24)&0xFF)>>7)<<0);//A
  371. }
  372. }
  373. elseif(pixelFormat==kCCTexture2DPixelFormat_A8)
  374. {//转换RGBA8888到A8，同理，不再赘述
  375. //Convert"RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA"to"AAAAAAAA"
  376. inPixel32=(unsignedint*)image->getData();
  377. tempData=newunsignedchar[width*height];
  378. unsignedchar*outPixel8=tempData;
  380. for(unsignedinti=0;i<length;++i,++inPixel32)
  381. {
  382. *outPixel8++=(*inPixel32>>24)&0xFF;//A
  383. }
  384. }
  386. if(hasAlpha&&pixelFormat==kCCTexture2DPixelFormat_RGB888)
  387. {//转换RGBA8888到RGB888，同理，不再赘述
  388. //Convert"RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA"to"RRRRRRRRGGGGGGGGBBBBBBBB"
  389. inPixel32=(unsignedint*)image->getData();
  390. tempData=newunsignedchar[width*height*3];
  391. unsignedchar*outPixel8=tempData;
  393. for(unsignedinti=0;i<length;++i,++inPixel32)
  394. {
  395. *outPixel8++=(*inPixel32>>0)&0xFF;//R
  396. *outPixel8++=(*inPixel32>>8)&0xFF;//G
  397. *outPixel8++=(*inPixel32>>16)&0xFF;//B
  398. }
  399. }
  400. //因为最终相应像素格式的数据都存放在tempData中，所以这里通过像素数据来生成OpenGL贴图。
  401. initWithData(tempData,pixelFormat,width,height,imageSize);
  402. //如果是以上相应格式，则tempData都是新申请的内存块，则在这里释放申请的内存。
  403. if(tempData!=image->getData())
  404. {
  405. delete[]tempData;
  406. }
  407. //取得是否有ALPHA渐变通道数据
  408. m_bHasPremultipliedAlpha=image->isPremultipliedAlpha();
  409. returntrue;
  410. }
  412. //从字符串中创建OpenGL贴图。
  413. //参1:字符串
  414. //参2:字体名称
  415. //参3:字体大小
  416. boolCCTexture2D::initWithString(constchar*text,floatfontSize)
  417. {
  418. returninitWithString(text,CCSizeMake(0,0),kCCTextAlignmentCenter,kCCVerticalTextAlignmentTop,fontName,fontSize);
  419. }
  420. //从字符串中创建OpenGL贴图,可指定更多参数。
  421. //参1:字符串
  422. //参2:返回参数，代表在屏幕上占用的区域大小
  423. //参3:文字的横向对齐方式
  424. //参4:文字的纵向对齐方式
  425. //参5:字体名称
  426. //参6:字体大小
  427. boolCCTexture2D::initWithString(constchar*text,floatfontSize)
  428. {
  429. //如果定义使用可变纹理
  430. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  431. //cachethetexturedata
  432. VolatileTexture::addStringTexture(this,text,dimensions,hAlignment,vAlignment,fontSize);
  433. #endif
  434. //定义一个CCImage实例对象
  435. CCImageimage;
  436. //定义一个CCImage进行由字符串创建图片时指定的文字对齐方式的变量eAlign
  437. CCImage::ETextAligneAlign;
  438. //如果文字纵向对齐方式为顶部对齐。
  439. if(kCCVerticalTextAlignmentTop==vAlignment)
  440. {
  441. //根据文字横向对齐方式的不同分别对eAlign进行设置。
  442. eAlign=(kCCTextAlignmentCenter==hAlignment)?CCImage::kAlignTop
  443. :(kCCTextAlignmentLeft==hAlignment)?CCImage::kAlignTopLeft:CCImage::kAlignTopRight;
  444. }
  445. //如果文字纵向对齐方式为居中对齐。
  446. elseif(kCCVerticalTextAlignmentCenter==vAlignment)
  447. {
  448. //根据文字横向对齐方式的不同分别对eAlign进行设置。
  449. eAlign=(kCCTextAlignmentCenter==hAlignment)?CCImage::kAlignCenter
  450. :(kCCTextAlignmentLeft==hAlignment)?CCImage::kAlignLeft:CCImage::kAlignRight;
  451. }
  452. //如果文字纵向对齐方式为底部对齐。
  453. elseif(kCCVerticalTextAlignmentBottom==vAlignment)
  454. {
  455. //根据文字横向对齐方式的不同分别对eAlign进行设置。
  456. eAlign=(kCCTextAlignmentCenter==hAlignment)?CCImage::kAlignBottom
  457. :(kCCTextAlignmentLeft==hAlignment)?CCImage::kAlignBottomLeft:CCImage::kAlignBottomRight;
  458. }
  459. else
  460. {
  461. //其它对齐方式不应存在，故打印错误。
  462. CCAssert(false,"Notsupportedalignmentformat!");
  463. }
  464. //调用CCImage的成员函数由字符串创建出图片数据。
  465. if(!image.initWithString(text,(int)dimensions.width,(int)dimensions.height,eAlign,(int)fontSize))
  466. {
  467. returnfalse;
  468. }
  469. //再由CCImage实例对象来创建出OpenGL贴图，初始化纹理。
  470. returninitWithImage(&image);
  471. }
  474. //在指定的位置绘制贴图。
  475. voidCCTexture2D::drawAtPoint(constCCPoint&point)
  476. {//定义贴图中图像区域的UV坐标。从左上至右下。
  477. GLfloatcoordinates[]={
  478. 0.0f,
  479. m_fMaxS,
  480. 0.0f,0.0f,0.0f};
  481. //取得贴图中图像区域的宽高
  482. GLfloatwidth=(GLfloat)m_uPixelsWide*m_fMaxS,
  483. height=(GLfloat)m_uPixelsHigh*m_fMaxT;
  484. //定义对应的顶点坐标
  485. GLfloatvertices[]={
  486. point.x,point.y,
  487. width+point.x,
  488. point.x,height+point.y,height+point.y};
  489. //Shader中使用位置和纹理坐标通道。
  490. ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position|kCCVertexAttribFlag_TexCoords);
  491. //后面的代码便用Shader进行渲染
  492. m_pShaderProgram->use();
  493. //设置Shader使用的最终结果矩阵
  494. m_pShaderProgram->setUniformForModelViewProjectionMatrix();
  495. //将贴图绑定
  496. ccGLBindTexture2D(m_uName);
  498. //将vertices设置为顶点位置参数
  499. glVertexAttribPointer(kCCVertexAttrib_Position,2,GL_FLOAT,GL_FALSE,vertices);
  500. //将coordinates设置为顶点的纹理坐标参数
  501. glVertexAttribPointer(kCCVertexAttrib_TexCoords,coordinates);
  502. //绘制三角形，参1为绘图方式，参2为顶点起始索引，参3为三角形面数。
  503. glDrawArrays(GL_TRIANGLE_STRIP,4);
  504. }
  505. //绘制纹理上的一个区域。
  506. voidCCTexture2D::drawInRect(constCCRect&rect)
  507. {//定义贴图中图像区域的UV坐标。从左上至右下。
  508. GLfloatcoordinates[]={
  509. 0.0f,
  510. m_fMaxS,
  511. 0.0f,0.0f};
  512. //绘制到的区域
  513. GLfloatvertices[]={rect.origin.x,rect.origin.y,/*0.0f,*/
  514. rect.origin.x+rect.size.width,*/
  515. rect.origin.x,rect.origin.y+rect.size.height,/*0.0f*/};
  516. //Shader中使用位置和纹理坐标通道。
  517. ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position|kCCVertexAttribFlag_TexCoords);
  518. //后面的代码便用Shader进行渲染
  519. m_pShaderProgram->use();
  520. //设置Shader使用的最终结果矩阵
  521. m_pShaderProgram->setUniformForModelViewProjectionMatrix();
  522. //将贴图绑定
  523. ccGLBindTexture2D(m_uName);
  524. //将vertices设置为顶点位置参数
  525. glVertexAttribPointer(kCCVertexAttrib_Position,4);
  526. }
  528. #ifdefCC_SUPPORT_PVRTC
  530. //如果支持PVR文件的压缩格式。提供的读取PVR压缩文件的函数。
  531. boolCCTexture2D::initWithPVRTCData(constvoid*data,CCTexture2DPixelFormatpixelFormat)
  532. {
  533. if(!(CCConfiguration::sharedConfiguration()->supportsPVRTC()))
  534. {
  535. CCLOG("cocos2d:WARNING:PVRTCimagesisnotsupported.");
  536. this->release();
  537. returnfalse;
  538. }
  539. //产生一个OpenGL的贴图索引。
  540. glGenTextures(1,&m_uName);
  541. //绑定纹理
  542. glBindTexture(GL_TEXTURE_2D,m_uName);
  543. //设置纹理抗锯齿
  544. this->setAntiAliasTexParameters();
  545. //贴图格式
  546. GLenumformat;
  547. //数据大小
  548. GLsizeisize=length*length*bpp/8;
  549. //根据是否有Alpha来取得贴图格式
  550. if(hasAlpha){
  551. format=(bpp==4)?GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
  552. }else{
  553. format=(bpp==4)?GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG:GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
  554. }
  555. if(size<32){
  556. size=32;
  557. }
  558. //加载压缩纹理。
  559. glCompressedTexImage2D(GL_TEXTURE_2D,level,format,length,size,data);
  560. //设置其它属性。
  561. m_tContentSize=CCSizeMake((float)(length),(float)(length));
  562. m_uPixelsWide=length;
  563. m_uPixelsHigh=length;
  564. m_fMaxS=1.0f;
  565. m_fMaxT=1.0f;
  566. m_bHasPremultipliedAlpha=PVRHaveAlphaPremultiplied_;
  567. m_ePixelFormat=pixelFormat;
  569. returntrue;
  570. }
  571. #endif//CC_SUPPORT_PVRTC
  572. //加载PVR普通文件的函数。
  573. boolCCTexture2D::initWithPVRFile(constchar*file)
  574. {
  575. boolbRet=false;
  576. //nothingtodowithCCObject::init
  578. CCTexturePVR*pvr=newCCTexturePVR;
  579. bRet=pvr->initWithContentsOfFile(file);
  581. if(bRet)
  582. {
  583. pvr->setRetainName(true);//don'tdealloctextureonrelease
  585. m_uName=pvr->getName();
  586. m_fMaxS=1.0f;
  587. m_fMaxT=1.0f;
  588. m_uPixelsWide=pvr->getWidth();
  589. m_uPixelsHigh=pvr->getHeight();
  590. m_tContentSize=CCSizeMake((float)m_uPixelsWide,(float)m_uPixelsHigh);
  591. m_bHasPremultipliedAlpha=PVRHaveAlphaPremultiplied_;
  592. m_ePixelFormat=pvr->getFormat();
  593. m_bHasMipmaps=pvr->getNumberOfMipmaps()>1;
  595. pvr->release();
  596. }
  597. else
  598. {
  599. CCLOG("cocos2d:Couldn'tloadPVRimage%s",file);
  600. }
  602. returnbRet;
  603. }
  604. //设置PVR文件加载时是否使用ALPHA渐变。
  605. voidCCTexture2D::PVRImagesHavePremultipliedAlpha(boolhaveAlphaPremultiplied)
  606. {
  607. PVRHaveAlphaPremultiplied_=haveAlphaPremultiplied;
  608. }
  611. //生成多级纹理。
  612. voidCCTexture2D::generateMipmap()
  613. {
  614. CCAssert(m_uPixelsWide==ccNextPOT(m_uPixelsWide)&&m_uPixelsHigh==ccNextPOT(m_uPixelsHigh),"MimpaptextureonlyworksinPOTtextures");
  615. ccGLBindTexture2D(m_uName);
  616. glGenerateMipmap(GL_TEXTURE_2D);
  617. m_bHasMipmaps=true;
  618. }
  619. //是否有多级纹理
  620. boolCCTexture2D::hasMipmaps()
  621. {
  622. returnm_bHasMipmaps;
  623. }
  624. //设置纹理参数。
  625. voidCCTexture2D::setTexParameters(ccTexParams*texParams)
  626. {
  627. CCAssert((m_uPixelsWide==ccNextPOT(m_uPixelsWide)||texParams->wrapS==GL_CLAMP_TO_EDGE)&&
  628. (m_uPixelsHigh==ccNextPOT(m_uPixelsHigh)||texParams->wrapT==GL_CLAMP_TO_EDGE),
  629. "GL_CLAMP_TO_EDGEshouldbeusedinNPOTdimensions");
  631. ccGLBindTexture2D(m_uName);
  632. glTexParameteri(GL_TEXTURE_2D,texParams->minFilter);
  633. glTexParameteri(GL_TEXTURE_2D,texParams->magFilter);
  634. glTexParameteri(GL_TEXTURE_2D,texParams->wrapS);
  635. glTexParameteri(GL_TEXTURE_2D,texParams->wrapT);
  636. }
  637. //设置为非抗锯齿纹理模式
  638. voidCCTexture2D::setAliasTexParameters()
  639. {//绑定纹理
  640. ccGLBindTexture2D(m_uName);
  641. //设置多级纹理
  642. if(!m_bHasMipmaps)
  643. {
  644. //设置最小滤波方式为最近点采样,这种方式最快，但有锯齿。
  645. glTexParameteri(GL_TEXTURE_2D,GL_NEAREST);
  646. }
  647. else
  648. {//设置最小滤波方式为多级纹理方式。
  649. glTexParameteri(GL_TEXTURE_2D,GL_NEAREST_MIPMAP_NEAREST);
  650. }
  651. //设置放大滤波方式为最近点采样
  652. glTexParameteri(GL_TEXTURE_2D,GL_NEAREST);
  653. }
  654. //设置为抗锯齿纹理模式
  655. voidCCTexture2D::setAntiAliasTexParameters()
  656. {//绑定纹理
  657. ccGLBindTexture2D(m_uName);
  658. //设置多级纹理
  659. if(!m_bHasMipmaps)
  660. {
  661. //设置最小滤波方式为线性过滤,这种方式纹理会有一定程度模糊。
  662. glTexParameteri(GL_TEXTURE_2D,GL_LINEAR);
  663. }
  664. else
  665. {//设置最小滤波方式为多级纹理方式。
  666. glTexParameteri(GL_TEXTURE_2D,GL_LINEAR_MIPMAP_NEAREST);
  667. }
  668. //设置放大滤波方式为最近点采样
  669. glTexParameteri(GL_TEXTURE_2D,GL_LINEAR);
  670. }
  671. //取得纹理格式的名字字符串
  672. constchar*CCTexture2D::stringForFormat()
  673. {
  674. switch(m_ePixelFormat)
  675. {
  676. casekCCTexture2DPixelFormat_RGBA8888:
  677. return"RGBA8888";
  679. casekCCTexture2DPixelFormat_RGB888:
  680. return"RGB888";
  682. casekCCTexture2DPixelFormat_RGB565:
  683. return"RGB565";
  685. casekCCTexture2DPixelFormat_RGBA4444:
  686. return"RGBA4444";
  688. casekCCTexture2DPixelFormat_RGB5A1:
  689. return"RGB5A1";
  691. casekCCTexture2DPixelFormat_AI88:
  692. return"AI88";
  694. casekCCTexture2DPixelFormat_A8:
  695. return"A8";
  697. casekCCTexture2DPixelFormat_I8:
  698. return"I8";
  700. casekCCTexture2DPixelFormat_PVRTC4:
  701. return"PVRTC4";
  703. casekCCTexture2DPixelFormat_PVRTC2:
  704. return"PVRTC2";
  706. default:
  707. CCAssert(false,"unrecognisedpixelformat");
  708. CCLOG("stringForFormat:%ld,cannotgiveusefulresult",(long)m_ePixelFormat);
  709. break;
  710. }
  712. returnNULL;
  713. }
  716. //设置默认带ALPHA通道的纹理格式
  717. voidCCTexture2D::setDefaultAlphaPixelFormat(CCTexture2DPixelFormatformat)
  718. {
  719. g_defaultAlphaPixelFormat=format;
  720. }
  722. //取得默认带ALPHA通道的纹理格式
  723. CCTexture2DPixelFormatCCTexture2D::defaultAlphaPixelFormat()
  724. {
  725. returng_defaultAlphaPixelFormat;
  726. }
  727. //取得相应纹理格式的色深。
  728. unsignedintCCTexture2D::bitsPerPixelForFormat(CCTexture2DPixelFormatformat)
  729. {
  730. unsignedintret=0;
  732. switch(format){
  733. casekCCTexture2DPixelFormat_RGBA8888:
  734. ret=32;//32位真彩色
  735. break;
  736. casekCCTexture2DPixelFormat_RGB888:
  737. //看起来是用24位，但内部实际是用DWORD来存数据的，所以还是32位。只不过Alpha通道没用。
  738. ret=32;
  739. break;
  740. casekCCTexture2DPixelFormat_RGB565:
  741. ret=16;
  742. break;
  743. casekCCTexture2DPixelFormat_RGBA4444:
  744. ret=16;
  745. break;
  746. casekCCTexture2DPixelFormat_RGB5A1:
  747. ret=16;
  748. break;
  749. casekCCTexture2DPixelFormat_AI88:
  750. ret=16;
  751. break;
  752. casekCCTexture2DPixelFormat_A8:
  753. ret=8;
  754. break;
  755. casekCCTexture2DPixelFormat_I8:
  756. ret=8;
  757. break;
  758. casekCCTexture2DPixelFormat_PVRTC4:
  759. ret=4;
  760. break;
  761. casekCCTexture2DPixelFormat_PVRTC2:
  762. ret=2;
  763. break;
  764. default:
  765. ret=-1;
  766. CCAssert(false,"unrecognisedpixelformat");
  767. CCLOG("bitsPerPixelForFormat:%ld,(long)format);
  768. break;
  769. }
  770. returnret;
  771. }
  772. //取得当前纹理格式的色深。
  773. unsignedintCCTexture2D::bitsPerPixelForFormat()
  774. {
  775. returnthis->bitsPerPixelForFormat(m_ePixelFormat);
  776. }
  779. NS_CC_END

二．CCTexturePVR:

CCTexturePVR.h:

源码 打印 ？
  1. #ifndef__CCPVRTEXTURE_H__
  2. #define__CCPVRTEXTURE_H__
  4. #include"CCStdC.h"
  5. #include"CCGL.h"
  6. #include"cocoa/CCObject.h"
  7. #include"cocoa/CCArray.h"
  8. //Cocos2d命名空间
  9. NS_CC_BEGIN
  11. //用于多级纹理的结构
  12. structCCPVRMipmap{
  13. unsignedchar*address;
  14. unsignedintlen;
  15. };
  17. //最大的多级纹理级数
  18. enum{
  19. CC_PVRMIPMAP_MAX=16,
  20. };
  23. //所支持的PVR图片格式:
  24. -RGBA8888
  25. -BGRA8888
  26. -RGBA4444
  27. -RGBA5551
  28. -RGB565
  29. -A8
  30. -I8
  31. -AI88
  32. -PVRTC4BPP
  33. -PVRTC2BPP
  35. classCCTexturePVR:publicCCObject
  36. {
  37. public:
  38. //构造
  39. CCTexturePVR();
  40. //析构
  41. virtual~CCTexturePVR();
  42. //成员函数：载入一个PVR图片文件
  43. boolinitWithContentsOfFile(constchar*path);
  45. //导出的静态函数：载入一个PVR图片文件。此函数为可供js调用。
  46. CC_DEPRECATED_ATTRIB一个UTEstaticCCTexturePVR*pvrTextureWithContentsOfFile(constchar*path);
  47. //静态函数：载入一个PVR图片文件
  48. staticCCTexturePVR*create(constchar*path);
  50. //相关属性的获取
  51. //取得贴图索引
  52. inlineunsignedintgetName(){returnm_uName;}
  53. //取得
  54. inlineunsignedintgetWidth(){returnm_uWidth;}
  55. inlineunsignedintgetHeight(){returnm_uHeight;}
  56. //取得是否有ALPHA通道
  57. inlineboolhasAlpha(){returnm_bHasAlpha;}
  58. //取得多级纹理的级数
  59. inlineunsignedintgetNumberOfMipmaps(){returnm_uNumberOfMipmaps;}
  60. //取得图片格式
  61. inlineCCTexture2DPixelFormatgetFormat(){returnm_eFormat;}
  62. //取得是否是供Retain显示屏使用的高清图片。
  63. inlineboolisRetainName(){returnm_bRetainName;}
  64. //设置为供Retain显示屏使用的高清图片。
  65. inlinevoidsetRetainName(boolretainName){m_bRetainName=retainName;}
  67. private:
  68. //解压PVR图片数据
  69. boolunpackPVRData(unsignedchar*data,unsignedintlen);
  70. //创建OpenGL纹理
  71. boolcreateGLTexture();
  73. protected:
  74. //多级纹理的各级信息结构。
  75. structCCPVRMipmapm_asMipmaps[CC_PVRMIPMAP_MAX];//pointertomipmapimages
  76. //多级纹理的最大级别数
  77. unsignedintm_uNumberOfMipmaps;//numberofmipmapused
  78. //
  79. unsignedintm_uTableFormatIndex;
  80. unsignedintm_uWidth,m_uHeight;
  81. //贴图索引
  82. GLuintm_uName;
  83. //是否有Alpha通道
  84. boolm_bHasAlpha;
  85. //是否是供Retain显示屏使用的高清图片。
  86. boolm_bRetainName;
  87. //图片格式
  88. CCTexture2DPixelFormatm_eFormat;
  89. };
  91. NS_CC_END
  94. #endif//__CCPVRTEXTURE_H__

CCTexturePVR.cpp:

源码 打印 ？
  1. #include"CCTexture2D.h"
  2. #include"CCTexturePVR.h"
  3. #include"ccMacros.h"
  4. #include"CCConfiguration.h"
  5. #include"support/ccUtils.h"
  6. #include"CCStdC.h"
  7. #include"platform/CCFileUtils.h"
  8. #include"support/zip_support/ZipUtils.h"
  9. #include"shaders/ccGLStateCache.h"
  10. #include<ctype.h>
  11. #include<cctype>
  12. //Cocos2d命名空间
  13. NS_CC_BEGIN
  15. #definePVR_TEXTURE_FLAG_TYPE_MASK0xff
  17. //PVR文件的信息标志位的各bit位意义
  18. enum{
  19. kPVRTextureFlagMipmap=(1<<8),//有多级纹理
  20. kPVRTextureFlagTwiddle=(1<<9),//istwiddled
  21. kPVRTextureFlagBumpmap=(1<<10),//是法线贴图（用于产生凹凸感）
  22. kPVRTextureFlagTiling=(1<<11),//isborderedfortiledpvr
  23. kPVRTextureFlagCubemap=(1<<12),//是立方体环境映射贴图（一般用于做天空盒）
  24. kPVRTextureFlagFalseMipCol=(1<<13),//aretherefalsecolouredMIPlevels
  25. kPVRTextureFlagVolume=(1<<14),//立体纹理，相当于有多层的纹理。
  26. kPVRTextureFlagAlpha=(1<<15),//v2.1istheretransparencyinfointhetexture
  27. kPVRTextureFlagVerticalFlip=(1<<16),//v2.1isthetextureverticallyflipped
  28. };
  29. //PVR文件头标识
  30. staticchargPVRTexIdentifier[5]="PVR!";
  31. //所有PVR文件的格式
  32. enum
  33. {
  34. kPVRTexturePixelTypeRGBA_4444=0x10,
  35. kPVRTexturePixelTypeRGBA_5551,
  36. kPVRTexturePixelTypeRGBA_8888,
  37. kPVRTexturePixelTypeRGB_565,
  38. kPVRTexturePixelTypeRGB_555,//这个Cocos2d-x暂不支持
  39. kPVRTexturePixelTypeRGB_888,
  40. kPVRTexturePixelTypeI_8,
  41. kPVRTexturePixelTypeAI_88,
  42. kPVRTexturePixelTypePVRTC_2,
  43. kPVRTexturePixelTypePVRTC_4,
  44. kPVRTexturePixelTypeBGRA_8888,
  45. kPVRTexturePixelTypeA_8,
  46. };
  47. //信息数组
  48. staticconstunsignedinttableFormats[][7]={
  49. //数组元素的结构为：
  50. //1-PVR文件格式
  51. //2-OpenGL内部格式
  52. //3-OpenGL格式
  53. //4-OpenGL数据类型
  54. //5-色深
  55. //6-是否压缩
  56. //7-Cocos2d像素格式
  57. {kPVRTexturePixelTypeRGBA_4444,16,false,kCCTexture2DPixelFormat_RGBA4444},
  58. {kPVRTexturePixelTypeRGBA_5551,kCCTexture2DPixelFormat_RGB5A1},
  59. {kPVRTexturePixelTypeRGBA_8888,32,kCCTexture2DPixelFormat_RGBA8888},
  60. {kPVRTexturePixelTypeRGB_565,kCCTexture2DPixelFormat_RGB565},
  61. {kPVRTexturePixelTypeRGB_888,24,kCCTexture2DPixelFormat_RGB888},
  62. {kPVRTexturePixelTypeA_8,8,kCCTexture2DPixelFormat_A8},
  63. {kPVRTexturePixelTypeI_8,kCCTexture2DPixelFormat_I8},
  64. {kPVRTexturePixelTypeAI_88,kCCTexture2DPixelFormat_AI88},
  65. #if(CC_TARGET_PLATFORM==CC_PLATFORM_IOS)
  66. //如果程序运行在IOS上，还可支持以下信息
  67. {kPVRTexturePixelTypePVRTC_2,GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,(unsignedint)-1,(unsignedint)-1,true,kCCTexture2DPixelFormat_PVRTC2},
  68. {kPVRTexturePixelTypePVRTC_4,GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,4,kCCTexture2DPixelFormat_PVRTC4},
  70. {kPVRTexturePixelTypeBGRA_8888,GL_BGRA,
  71. #endif
  72. };
  74. //信息表的元素数量
  75. #defineMAX_TABLE_ELEMENTS(sizeof(tableFormats)/sizeof(tableFormats[0]))
  76. //
  77. enum{
  78. kCCInternalPVRTextureFormat,
  79. kCCInternalOpenGLInternalFormat,
  80. kCCInternalOpenGLFormat,
  81. kCCInternalOpenGLType,
  82. kCCInternalBPP,
  83. kCCInternalCompressedImage,
  84. kCCInternalCCTexture2DPixelFormat,
  85. };
  86. //PVR文件头信息结构
  87. typedefstruct_PVRTexHeader
  88. {
  89. unsignedintheaderLength;//头信息长度
  90. unsignedintheight;//高
  91. unsignedintwidth;//宽
  92. unsignedintnumMipmaps;//是否有多级纹理
  93. unsignedintflags;//标记位
  94. unsignedintdataLength;//后面的像素数据长度
  95. unsignedintbpp;//色深
  96. unsignedintbitmaskRed;//对应红色的像素位
  97. unsignedintbitmaskGreen;//对应绿色的像素位
  98. unsignedintbitmaskBlue;//对应蓝色的像素位
  99. unsignedintbitmaskAlpha;//对应ALPHA色的像素位
  100. unsignedintpvrTag;//
  101. unsignedintnumSurfs;//是否有多层
  102. }PVRTexHeader;
  103. //构造函数
  104. CCTexturePVR::CCTexturePVR()
  105. :m_uTableFormatIndex(0)
  106. ,m_uNumberOfMipmaps(0)
  107. ,m_uWidth(0)
  108. ,m_uHeight(0)
  109. ,m_bRetainName(false)
  110. ,m_bHasAlpha(false)
  111. ,m_eFormat(kCCTexture2DPixelFormat_Default)
  112. {
  113. }
  114. //析构函数
  115. CCTexturePVR::~CCTexturePVR()
  116. {
  117. CCLOGINFO("cocos2d:deallocingCCTexturePVR");
  118. //释放OpenGL贴图
  119. if(m_uName!=0&&!m_bRetainName)
  120. {
  121. ccGLDeleteTexture(m_uName);
  122. }
  123. }
  124. //解压PVR像素数据
  125. boolCCTexturePVR::unpackPVRData(unsignedchar*data,unsignedintlen)
  126. {
  127. boolsuccess=false;
  128. PVRTexHeader*header=NULL;
  129. unsignedintflags,pvrTag;
  130. unsignedintdataLength=0,dataOffset=0,dataSize=0;
  131. unsignedintblockSize=0,widthBlocks=0,heightBlocks=0;
  132. unsignedintwidth=0,height=0,bpp=4;
  133. unsignedchar*bytes=NULL;
  134. unsignedintformatFlags;
  136. //将数据地址转为头信息指针，这个就可以直接通过结构指针进行存取。
  137. header=(PVRTexHeader*)data;
  139. //格式有效性检查
  140. pvrTag=CC_SWAP_INT32_LITTLE_TO_HOST(header->pvrTag);
  142. /*
  143. Checkthatgivendatareallyrepresentspvrtexture
  145. [0]='P'
  146. [1]='V'
  147. [2]='R'
  148. [3]='!'
  149. */
  150. if(gPVRTexIdentifier[0]!=((pvrTag>>0)&0xff)||
  151. gPVRTexIdentifier[1]!=((pvrTag>>8)&0xff)||
  152. gPVRTexIdentifier[2]!=((pvrTag>>16)&0xff)||
  153. gPVRTexIdentifier[3]!=((pvrTag>>24)&0xff))
  154. {
  155. CCLOG("UnsupportedPVRformat.UsetheLegacyformatuntilthenewformatissupported");
  156. returnfalse;
  157. }
  158. //取得配置信息
  159. CCConfiguration*configuration=CCConfiguration::sharedConfiguration();
  160. //取得标记
  161. flags=CC_SWAP_INT32_LITTLE_TO_HOST(header->flags);
  162. formatFlags=flags&PVR_TEXTURE_FLAG_TYPE_MASK;
  163. boolflipped=(flags&kPVRTextureFlagVerticalFlip)?true:false;
  164. if(flipped)
  165. {
  166. CCLOG("cocos2d:WARNING:Imageisflipped.RegenerateitusingPVRTexTool");
  167. }
  168. //查看是否支持非2的幂次方大小的纹理
  169. if(!configuration->supportsNPOT()&&
  170. (header->width!=ccNextPOT(header->width)||header->height!=ccNextPOT(header->height)))
  171. {
  172. CCLOG("cocos2d:ERROR:LodinganNPOTtexture(%dx%d)butisnotsupportedonthisdevice",header->width,header->height);
  173. returnfalse;
  174. }
  175. //遍历所有的格式信息数据，找到对应的格式信息。
  176. for(m_uTableFormatIndex=0;m_uTableFormatIndex<(unsignedint)MAX_TABLE_ELEMENTS;m_uTableFormatIndex++)
  177. {
  178. if(tableFormats[m_uTableFormatIndex][kCCInternalPVRTextureFormat]==formatFlags)
  179. {
  180. //Resetnumofmipmaps
  181. m_uNumberOfMipmaps=0;
  183. //取得图片大小
  184. m_uWidth=width=CC_SWAP_INT32_LITTLE_TO_HOST(header->width);
  185. m_uHeight=height=CC_SWAP_INT32_LITTLE_TO_HOST(header->height);
  187. //检查是否有ALPHA通道
  188. if(CC_SWAP_INT32_LITTLE_TO_HOST(header->bitmaskAlpha))
  189. {
  190. m_bHasAlpha=true;
  191. }
  192. else
  193. {
  194. m_bHasAlpha=false;
  195. }
  197. //取得数据长度
  198. dataLength=CC_SWAP_INT32_LITTLE_TO_HOST(header->dataLength);
  200. //将数据指针偏移到头信息之后，即像素数据所在位置
  201. bytes=((unsignedchar*)data)+sizeof(PVRTexHeader);
  202. m_eFormat=(CCTexture2DPixelFormat)(tableFormats[m_uTableFormatIndex][kCCInternalCCTexture2DPixelFormat]);
  203. bpp=tableFormats[m_uTableFormatIndex][kCCInternalBPP];
  205. //遍历每个多级纹理图像块
  206. while(dataOffset<dataLength)
  207. {
  208. switch(formatFlags){
  209. casekPVRTexturePixelTypePVRTC_2:
  210. blockSize=8*4;//Pixelbypixelblocksizefor2bpp
  211. widthBlocks=width/8;
  212. heightBlocks=height/4;
  213. break;
  214. casekPVRTexturePixelTypePVRTC_4:
  215. blockSize=4*4;//Pixelbypixelblocksizefor4bpp
  216. widthBlocks=width/4;
  217. heightBlocks=height/4;
  218. break;
  219. casekPVRTexturePixelTypeBGRA_8888:
  220. if(CCConfiguration::sharedConfiguration()->supportsBGRA8888()==false)
  221. {
  222. CCLOG("cocos2d:TexturePVR.BGRA8888notsupportedonthisdevice");
  223. returnfalse;
  224. }
  225. default:
  226. blockSize=1;
  227. widthBlocks=width;
  228. heightBlocks=height;
  229. break;
  230. }
  232. //Clamptominimumnumberofblocks
  233. if(widthBlocks<2)
  234. {
  235. widthBlocks=2;
  236. }
  237. if(heightBlocks<2)
  238. {
  239. heightBlocks=2;
  240. }
  242. dataSize=widthBlocks*heightBlocks*((blockSize*bpp)/8);
  243. unsignedintpacketLength=(dataLength-dataOffset);
  244. packetLength=packetLength>dataSize?dataSize:packetLength;
  246. //记录每个多级纹理图像块的像素数据地址和长度。
  247. m_asMipmaps[m_uNumberOfMipmaps].address=bytes+dataOffset;
  248. m_asMipmaps[m_uNumberOfMipmaps].len=packetLength;
  249. m_uNumberOfMipmaps++;
  251. //检查是否超出最大级数
  252. CCAssert(m_uNumberOfMipmaps<CC_PVRMIPMAP_MAX,
  253. "TexturePVR:Maximumnumberofmimpapsreached.IncreatetheCC_PVRMIPMAP_MAXvalue");
  254. //偏移到下一个多级纹理图像块。
  255. dataOffset+=packetLength;
  257. //大小减为原来1/2。
  258. width=MAX(width>>1,1);
  259. height=MAX(height>>1,1);
  260. }
  262. //读取完成
  263. success=true;
  264. break;
  265. }
  266. }
  267. //成功判断
  268. if(!success)
  269. {
  270. CCLOG("cocos2d:WARNING:UnsupportedPVRPixelFormat:0x%2x.Re-encodeitwithaOpenGLpixelformatvariant",formatFlags);
  271. }
  273. returnsuccess;
  274. }
  275. //创建OpenGL贴图
  276. boolCCTexturePVR::createGLTexture()
  277. {
  278. //保存宽高
  279. unsignedintwidth=m_uWidth;
  280. unsignedintheight=m_uHeight;
  281. GLenumerr;
  282. //如果文件中有多级纹理
  283. if(m_uNumberOfMipmaps>0)
  284. {
  285. //先释放原来的纹理
  286. if(m_uName!=0)
  287. {
  288. ccGLDeleteTexture(m_uName);
  289. }
  290. //像素数据每字节对齐
  291. glPixelStorei(GL_UNPACK_ALIGNMENT,1);
  292. //产生OpenGL贴图
  293. glGenTextures(1,&m_uName);
  294. glBindTexture(GL_TEXTURE_2D,m_uName);
  296. //如果无多级纹理，设置最小滤波方式为线性过滤，产生抗锯齿效果。
  297. if(m_uNumberOfMipmaps==1)
  298. {
  299. glTexParameteri(GL_TEXTURE_2D,GL_LINEAR);
  300. }
  301. else
  302. {//设置最小滤波方式为最近点采样,这种方式有锯齿。
  303. glTexParameteri(GL_TEXTURE_2D,GL_LINEAR_MIPMAP_NEAREST);
  304. }
  305. //设置最大滤波方式为线性过滤
  306. glTexParameteri(GL_TEXTURE_2D,GL_CLAMP_TO_EDGE);
  307. }
  308. //检错
  309. CHECK_GL_ERROR_DEBUG();//cleanpossibleGLerror
  310. //取得对应格式的相关信息。
  311. GLenuminternalFormat=tableFormats[m_uTableFormatIndex][kCCInternalOpenGLInternalFormat];
  312. GLenumformat=tableFormats[m_uTableFormatIndex][kCCInternalOpenGLFormat];
  313. GLenumtype=tableFormats[m_uTableFormatIndex][kCCInternalOpenGLType];
  314. boolcompressed=(0==tableFormats[m_uTableFormatIndex][kCCInternalCompressedImage])?false:true;
  316. //循环产生多级纹理贴图。
  317. for(unsignedinti=0;i<m_uNumberOfMipmaps;++i)
  318. {
  319. //检查配置信息是否支持压缩格式。
  320. if(compressed&&!CCConfiguration::sharedConfiguration()->supportsPVRTC())
  321. {
  322. CCLOG("cocos2d:WARNING:PVRTCimagesarenotsupported");
  323. returnfalse;
  324. }
  325. //取得当前级别的图像块的像素数据地址和长度。
  326. unsignedchar*data=m_asMipmaps[i].address;
  327. unsignedintdatalen=m_asMipmaps[i].len;
  328. //如果是压缩格式，则产生压缩格式的贴图。
  329. if(compressed)
  330. {
  331. glCompressedTexImage2D(GL_TEXTURE_2D,i,internalFormat,datalen,data);
  332. }
  333. else
  334. {//产生一般格式的贴图。
  335. glTexImage2D(GL_TEXTURE_2D,type,data);
  336. }
  337. //如果是非2的幂次方大小，则提示。
  338. if(i>0&&(width!=height||ccNextPOT(width)!=width))
  339. {
  340. CCLOG("cocos2d:TexturePVR.WARNING.Mipmaplevel%uisnotsquared.Texturewon'trendercorrectly.width=%u!=height=%u",height);
  341. }
  342. //检错
  343. err=glGetError();
  344. if(err!=GL_NO_ERROR)
  345. {
  346. CCLOG("cocos2d:TexturePVR:Erroruploadingcompressedtexturelevel:%u.glError:0x%04X",err);
  347. returnfalse;
  348. }
  349. //变为原来大小的1/2。
  350. width=MAX(width>>1,1);
  351. }
  353. returntrue;
  354. }
  356. //成员函数：加载PVR图片
  357. boolCCTexturePVR::initWithContentsOfFile(constchar*path)
  358. {
  359. unsignedchar*pvrdata=NULL;
  360. intpvrlen=0;
  361. //定义字符串变量，存储转换为小写的路径字符串。
  362. std::stringlowerCase(path);
  363. for(unsignedinti=0;i<lowerCase.length();++i)
  364. {
  365. lowerCase[i]=tolower(lowerCase[i]);
  366. }
  367. //检查是否是ccz格式。
  368. if(lowerCase.find(".ccz")!=std::string::npos)
  369. {
  370. //调用压缩库函数将文件数据读取到为pvrdata申请的内存中。取得其大小存入pvrlen变量中。
  371. pvrlen=ZipUtils::ccInflateCCZFile(path,&pvrdata);
  372. }
  373. //检查是否是gz格式。
  374. elseif(lowerCase.find(".gz")!=std::string::npos)
  375. {
  376. //调用压缩库函数将文件数据读取到为pvrdata申请的内存中。取得其大小存入pvrlen变量中。
  377. pvrlen=ZipUtils::ccInflateGZipFile(path,&pvrdata);
  378. }
  379. else
  380. {
  381. //普通PVR文件，将文件数据读取到一块内存中返回给pvrdata。取得其大小存入pvrlen变量中。
  382. pvrdata=CCFileUtils::sharedFileUtils()->getFileData(path,"rb",(unsignedlong*)(&pvrlen));
  383. }
  384. //如果读取失败则返回
  385. if(pvrlen<0)
  386. {
  387. this->release();
  388. returnfalse;
  389. }
  391. m_uNumberOfMipmaps=0;
  393. m_uName=0;
  394. m_uWidth=m_uHeight=0;
  395. m_bHasAlpha=false;
  397. m_bRetainName=false;
  398. //如果解压数据失败则返回。
  399. //解压后，如果创建贴图失败则返回。
  400. if(!unpackPVRData(pvrdata,pvrlen)||!createGLTexture())
  401. {
  402. CC_SAFE_DELETE_ARRAY(pvrdata);
  403. this->release();
  404. returnfalse;
  405. }
  406. //释放数据占用的内存。
  407. CC_SAFE_DELETE_ARRAY(pvrdata);
  409. returntrue;
  410. }
  411. //导出的静态函数：加载PVR图片
  412. CCTexturePVR*CCTexturePVR::pvrTextureWithContentsOfFile(constchar*path)
  413. {
  414. returnCCTexturePVR::create(path);
  415. }
  416. //静态函数：加载PVR图片
  417. CCTexturePVR*CCTexturePVR::create(constchar*path)
  418. {
  419. //new一个新的CCTexturePVR
  420. CCTexturePVR*pTexture=newCCTexturePVR();
  421. if(pTexture)
  422. {
  423. //调用成员函数加载PVR图片
  424. if(pTexture->initWithContentsOfFile(path))
  425. {
  426. //如果成功,设置交由内存管理器使用引用计数器进行内存管理。
  427. pTexture->autorelease();
  428. }
  429. else
  430. {
  431. //否则释放纹理
  432. deletepTexture;
  433. pTexture=NULL;
  434. }
  435. }
  436. //返回这个CCTexturePVR
  437. returnpTexture;
  438. }
  440. NS_CC_END

三．CCTextureCache:

打开CCTextureCache.h:

源码 打印 ？
  1. #ifndef__CCTEXTURE_CACHE_H__
  2. #define__CCTEXTURE_CACHE_H__
  3. //由CCObject派生
  4. #include"cocoa/CCObject.h"
  5. //需要用到字典
  6. #include"cocoa/CCDictionary.h"
  7. #include"textures/CCTexture2D.h"
  8. #include<string>
  10. //这里用到CCImage类和STL容器之一list
  11. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  12. #include"platform/CCImage.h"
  13. #include<list>
  14. #endif
  16. //Cocos2d命名空间
  17. NS_CC_BEGIN
  18. //用到线程锁
  19. classCCLock;
  20. //用到CCImage处理图片
  21. classCCImage;
  23. //纹理管理器
  24. classCC_DLLCCTextureCache:publicCCObject
  25. {
  26. protected:
  27. //字典对象指针。
  28. CCDictionary*m_pTextures;
  29. //线程临界区。用于锁定字典访问，貌似用不到。这里屏蔽了~
  30. //pthread_mutex_t*m_pDictLock;
  33. private:
  34. //设置多线程加载图片时的回调函数。
  35. voidaddImageAsyncCallBack(floatdt);
  37. public:
  38. //构造函数
  39. CCTextureCache();
  40. //析构函数
  41. virtual~CCTextureCache();
  42. //取得当前类描述
  43. constchar*description(void);
  44. //取得当前字典的快照（拷贝）
  45. CCDictionary*snapshotTextures();
  47. //返回唯一纹理管理器的实例指针
  48. staticCCTextureCache*sharedTextureCache();
  50. //销毁唯一纹理管理器的实例指针
  51. staticvoidpurgeSharedTextureCache();
  53. //加载一个图片生成纹理，文件名做为字典的查询对应关键字。返回生成的纹理指针，支持png,bmp,tiff,jpeg,pvr,gif等格式。
  54. CCTexture2D*addImage(constchar*fileimage);
  56. //此函数可以支持多线程载入图片，调用时会创建一个线程进行异步加载，加载成功后由主线程调用设置的回调函数，当然创建的纹理会做为参数传递。支持png和jpg
  57. voidaddImageAsync(constchar*path,CCObject*target,SEL_CallFuncOselector);
  60. //加载一个图片生成纹理，指定参数key（其实要求是图片的相对路径字符串）做为字典的查询对应关键字。
  61. CCTexture2D*addUIImage(CCImage*image,constchar*key);
  63. //通过查询关键字（其实要求是图片的相对路径字符串）从字典里找到对应的纹理。
  64. CCTexture2D*textureForKey(constchar*key);
  66. //清空字典，释放所有纹理。
  67. voidremoveAllTextures();
  69. //清除未被外部使用的纹理。怎么知道未使用呢？因为在Cocos2d-x中使用“引用计数器”来管理各种资源的使用情况，纹理也不例外。在资源类构造时，纹理的计数器值为0，但由CCTextureCache来创建完成后，会对纹理的资源计数器做加1操作以通知纹理说“你现在被我占用呢”。如果纹理被外部使用，应该再次调用其资源计数器做加1操作，退出使用时做减1操作通知其“我现在不用你了”。所以这里只需要遍历下计数器值为1的纹理即未被外部使用的纹理进行释放即可。
  70. voidremoveUnusedTextures();
  72. //移除一个纹理
  73. voidremoveTexture(CCTexture2D*texture);
  75. //由字典查询关键字找到相应纹理并移除。
  76. voidremoveTextureForKey(constchar*textureKeyName);
  78. //打印出当前管理的纹理信息，包括现在纹理占用的内存和总的纹理内存。
  79. voiddumpCachedTextureInfo();
  81. #ifdefCC_SUPPORT_PVRTC
  82. //如果开启支持PVR的压缩格式，这里提供加载PVR压缩文件生成纹理的函数。
  83. //参1:PVR压缩文件名
  84. //参2:压缩质量参数，只能设为2或4，4比2质量高，但压缩比低。2则相反。
  85. //参3:是否有Alpha通道。这里会根据是否有ALPHA通道以生成相应的默认纹理格式。
  86. //参4:图片必须是2的幂次方大小的正方形，所以这里只需要填写一下宽度，也就是图片大小。
  87. CCTexture2D*addPVRTCImage(constchar*fileimage,intwidth);
  88. #endif//CC_SUPPORT_PVRTC
  90. //加载普通的PVR图片文件生成纹理。
  91. CCTexture2D*addPVRImage(constchar*filename);
  93. //如果CC_ENABLE_CACHE_TEXTURE_DATA宏定义为可用（即值为1），则调用此函数会将所有的纹理都预加载进内存生成相应纹理。
  94. staticvoidreloadAllTextures();
  95. };
  97. //如果定义了CC_ENABLE_CACHE_TEXTURE_DATA，这里定义一个新的类
  98. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  100. //新定义的类名称为VolatileTexture，意思是多变纹理。这里代表了多种数据源生成的纹理的管理器。
  101. classVolatileTexture
  102. {
  103. //这里声明了一个枚举，代表了多变纹理对应的几种数据源类型
  104. typedefenum{
  105. kInvalid=0,//无效未加载任何数据的状态
  106. kImageFile,//图片文件
  107. kImageData,//内存中的图片数据
  108. kString,//字符串
  109. kImage,//图片对象(CCImage)
  110. }ccCachedImageType;
  112. public:
  113. //构造
  114. VolatileTexture(CCTexture2D*t);
  115. //析构
  116. ~VolatileTexture();
  117. //静态函数：通过图片文件生成的纹理及相关信息生成一个多变纹理并将其指针放入容器。
  118. staticvoidaddImageTexture(CCTexture2D*tt,constchar*imageFileName,CCImage::EImageFormatformat);
  119. //静态函数：通过字符串生成的纹理及相关信息生成一个多变纹理并将其指针放入容器。
  120. staticvoidaddStringTexture(CCTexture2D*tt,constchar*text,CCTextAlignmentalignment,
  121. CCVerticalTextAlignmentvAlignment,constchar*fontName,floatfontSize);
  122. //通过图片数据生成的纹理及相关信息生成一个多变纹理并将其指针放入容器。
  123. staticvoidaddDataTexture(CCTexture2D*tt,void*data,constCCSize&contentSize);
  124. //通过图片对象生成的纹理及相关信息生成一个多变纹理并将其指针放入容器。
  125. staticvoidaddCCImage(CCTexture2D*tt,CCImage*image);
  126. //通过纹理指针参数从容器中删除对应的多变纹理
  127. staticvoidremoveTexture(CCTexture2D*t);
  128. //重新载入所有的纹理
  129. staticvoidreloadAllTextures();
  131. public:
  132. //静态多变纹理指针容器，用来存储所有的多变纹理对象指针。
  133. staticstd::list<VolatileTexture*>textures;
  134. //是否正在进行全部重新载入
  135. staticboolisReloading;
  137. private:
  138. //通过纹理指针参数从容器找到对应的多变纹理对象指针
  139. staticVolatileTexture*findVolotileTexture(CCTexture2D*tt);
  141. protected:
  142. //与当前多变纹理对应的纹理指针
  143. CCTexture2D*texture;
  144. //对应的图片对象
  145. CCImage*uiImage;
  146. //数据源类型
  147. ccCachedImageTypem_eCashedImageType;
  148. //纹理数据指针
  149. void*m_pTextureData;
  150. //纹理的实际大小
  151. CCSizem_TextureSize;
  152. //纹理的像素格式
  153. CCTexture2DPixelFormatm_PixelFormat;
  154. //对应的图片名称
  155. std::stringm_strFileName;
  156. //图片的像素格式
  157. CCImage::EImageFormatm_FmtImage;
  158. //图片的大小
  159. CCSizem_size;
  160. //横向文字的对齐方式
  161. CCTextAlignmentm_alignment;
  162. //纵向文字的对齐方式
  163. CCVerticalTextAlignmentm_vAlignment;
  164. //字体名称
  165. std::stringm_strFontName;
  166. //文字
  167. std::stringm_strText;
  168. //字体大小
  169. floatm_fFontSize;
  170. };
  172. #endif
  175. NS_CC_END
  177. #endif//__CCTEXTURE_CACHE_H__

然后是CPP文件：

源码 打印 ？
  1. #include"CCTextureCache.h"
  2. #include"CCTexture2D.h"
  3. #include"ccMacros.h"
  4. #include"CCDirector.h"
  5. #include"platform/platform.h"
  6. #include"platform/CCFileUtils.h"
  7. #include"platform/CCThread.h"
  8. #include"platform/CCImage.h"
  9. #include"support/ccUtils.h"
  10. #include"CCScheduler.h"
  11. #include"cocoa/CCString.h"
  12. #include<errno.h>
  13. #include<stack>
  14. #include<string>
  15. #include<cctype>
  16. #include<queue>
  17. #include<list>
  18. #include<pthread.h>
  19. #include<semaphore.h>
  20. //使用标准库命名空间
  21. usingnamespacestd;
  22. //使用Cocos2d命名空间
  23. NS_CC_BEGIN
  24. //异步加载所用的消息结构
  25. typedefstruct_AsyncStruct
  26. {
  27. std::stringfilename;//文件名
  28. CCObject*target;//调用者
  29. SEL_CallFuncOselector;//载回完的回调函数
  30. }AsyncStruct;
  31. //图片信息
  32. typedefstruct_ImageInfo
  33. {
  34. AsyncStruct*asyncStruct;//异步加载消息结构
  35. CCImage*image;//图片指针
  36. CCImage::EImageFormatimageType//图片类型
  37. }ImageInfo;
  39. //加载图片的线程
  40. staticpthread_ts_loadingThread;
  41. //用于读取异步消息队列的线程临界区
  42. staticpthread_mutex_ts_asyncStructQueueMutex;
  43. //用于存储图片信息结构处理的临界区
  44. staticpthread_mutex_ts_ImageInfoMutex;
  45. //信号量指针。信号量是当前进程中的多个线程通信的一种方式。
  46. staticsem_t*s_pSem=NULL;
  47. //多线程加载图片的数量。
  48. staticunsignedlongs_nAsyncRefCount=0;
  49. //如果是IOS平台，则定义是否使用信号量命名。
  50. #ifCC_TARGET_PLATFORM==CC_PLATFORM_IOS
  51. #defineCC_ASYNC_TEXTURE_CACHE_USE_NAMED_SEMAPHORE1
  52. #else
  53. #defineCC_ASYNC_TEXTURE_CACHE_USE_NAMED_SEMAPHORE0
  54. #endif
  56. //如果使用信号量命名，则定义命名的字符串宏，否则定义静态全局的信号量结构。
  57. #ifCC_ASYNC_TEXTURE_CACHE_USE_NAMED_SEMAPHORE
  58. #defineCC_ASYNC_TEXTURE_CACHE_SEMAPHORE"ccAsync"
  59. #else
  60. staticsem_ts_sem;
  61. #endif
  63. //是否在当前加载线程处理完手上的活儿就退出。
  64. staticboolneed_quit=false;
  65. //异步加载图片的消息结构指针容器，即消息队列。
  66. staticstd::queue<AsyncStruct*>*s_pAsyncStructQueue=NULL;
  67. //异步存储图片信息结构指针的容器。
  68. staticstd::queue<ImageInfo*>*s_pImageQueue=NULL;
  69. //通过文件扩展名取得图片格式
  70. staticCCImage::EImageFormatcomputeImageFormatType(string&filename)
  71. {
  72. CCImage::EImageFormatret=CCImage::kFmtUnKnown;
  73. //JPG
  74. if((std::string::npos!=filename.find(".jpg"))||(std::string::npos!=filename.find(".jpeg")))
  75. {
  76. ret=CCImage::kFmtJpg;
  77. }//PNG
  78. elseif((std::string::npos!=filename.find(".png"))||(std::string::npos!=filename.find(".PNG")))
  79. {
  80. ret=CCImage::kFmtPng;
  81. }//TIFF
  82. elseif((std::string::npos!=filename.find(".tiff"))||(std::string::npos!=filename.find(".TIFF")))
  83. {
  84. ret=CCImage::kFmtTiff;
  85. }
  87. returnret;
  88. }
  89. //加载图片的线程函数
  90. staticvoid*loadImage(void*data)
  91. {
  92. //创建一个线程信息对象
  93. CCThreadthread;
  94. thread.createAutoreleasePool();
  95. //多线程加载消息结构
  96. AsyncStruct*pAsyncStruct=NULL;
  98. //线程将处理所有随时要进行多线程加载的图片，所以会有一个While循环。
  99. while(true)
  100. {
  101. //当前线程等待信号量变为非零值，并减1。
  102. intsemWaitRet=sem_wait(s_pSem);
  103. //如果信号量为负值，打印出错信息并中断。
  104. if(semWaitRet<0)
  105. {
  106. CCLOG("CCTextureCacheasyncthreadsemaphoreerror:%sn",strerror(errno));
  107. break;
  108. }
  109. //取得全局的异步加载信息结构指针容器
  110. std::queue<AsyncStruct*>*pQueue=s_pAsyncStructQueue;
  111. //下面代码作为临界区上锁
  112. pthread_mutex_lock(&s_asyncStructQueueMutex);
  113. //如果没有需要异步加载的图片
  114. if(pQueue->empty())
  115. {
  116. //解锁临界区
  117. pthread_mutex_unlock(&s_asyncStructQueueMutex);
  118. //如果退出线程标记为true则中断退出，否则继续。
  119. if(need_quit)
  120. break;
  121. else
  122. continue;
  123. }
  124. else
  125. {
  126. //如果有需要异步加载的图片，则从队列中取第一个消息指针保存在变量pAsyncStruct中随后将其从队列中移除。
  127. pAsyncStruct=pQueue->front();
  128. pQueue->pop();
  129. //解锁临界区
  130. pthread_mutex_unlock(&s_asyncStructQueueMutex);
  131. }
  132. //取得要进行异步加载的图片名称
  133. constchar*filename=pAsyncStruct->filename.c_str();
  135. //取得图片类型
  136. CCImage::EImageFormatimageType=computeImageFormatType(pAsyncStruct->filename);
  137. //如果不是PNG,JPG或TIFF就不支持了。打印错误后进行相应处理。
  138. if(imageType==CCImage::kFmtUnKnown)
  139. {
  140. CCLOG("unsupporttedformat%s",filename);
  141. deletepAsyncStruct;
  143. continue;
  144. }
  146. //如果是有效格式，生成一个新的CCImage对象
  147. CCImage*pImage=newCCImage();
  148. //由文件名和图片格式将图片加载到CCImage中。
  149. if(!pImage->initWithImageFileThreadSafe(filename,imageType))
  150. {//如果失败，释放CCImage对象并打印错误。
  151. deletepImage;
  152. CCLOG("cannotload%s",filename);
  153. continue;
  154. }
  156. //动态创建一个新的图片信息结构并填充相应信息
  157. ImageInfo*pImageInfo=newImageInfo();
  158. pImageInfo->asyncStruct=pAsyncStruct;
  159. pImageInfo->image=pImage;
  160. pImageInfo->imageType=imageType;
  162. //下面代码作为临界区上锁
  163. pthread_mutex_lock(&s_ImageInfoMutex);
  164. //将新的图片信息放入图片信息结构容器。
  165. s_pImageQueue->push(pImageInfo);
  166. //解锁临界区
  167. pthread_mutex_unlock(&s_ImageInfoMutex);
  168. }
  169. //如果退出循环，释放信号量
  170. if(s_pSem!=NULL)
  171. {
  172. #ifCC_ASYNC_TEXTURE_CACHE_USE_NAMED_SEMAPHORE
  173. sem_unlink(CC_ASYNC_TEXTURE_CACHE_SEMAPHORE);
  174. sem_close(s_pSem);
  175. #else
  176. sem_destroy(s_pSem);
  177. #endif
  178. s_pSem=NULL;
  179. //释放多线程加载所用的消息队列和与之对应的图片信息队列。
  180. deletes_pAsyncStructQueue;
  181. deletes_pImageQueue;
  182. }
  184. return0;
  185. }
  188. //唯一的全局纹理数据缓冲区对象指针
  189. staticCCTextureCache*g_sharedTextureCache=NULL;
  190. //取得唯一的全局纹理数据缓冲区对象指针
  191. CCTextureCache*CCTextureCache::sharedTextureCache()
  192. {
  193. if(!g_sharedTextureCache)
  194. {
  195. g_sharedTextureCache=newCCTextureCache();
  196. }
  197. returng_sharedTextureCache;
  198. }
  199. //构造函数
  200. CCTextureCache::CCTextureCache()
  201. {
  202. CCAssert(g_sharedTextureCache==NULL,"Attemptedtoallocateasecondinstanceofasingleton.");
  203. //生成一个字典
  204. m_pTextures=newCCDictionary();
  205. }
  206. //析构函数
  207. CCTextureCache::~CCTextureCache()
  208. {
  209. CCLOGINFO("cocos2d:deallocingCCTextureCache.");
  210. need_quit=true;
  211. if(s_pSem!=NULL)
  212. {
  213. sem_post(s_pSem);
  214. }
  215. //释放字典
  216. CC_SAFE_RELEASE(m_pTextures);
  217. }
  218. //释放唯一的全局纹理数据缓冲区对象
  219. voidCCTextureCache::purgeSharedTextureCache()
  220. {
  221. CC_SAFE_RELEASE_NULL(g_sharedTextureCache);
  222. }
  223. //取得当前类描述
  224. constchar*CCTextureCache::description()
  225. {
  226. returnCCString::createWithFormat("<CCTextureCache|Numberoftextures=%u>",m_pTextures->count())->getCString();
  227. }
  228. //取得当前字典的快照
  229. CCDictionary*CCTextureCache::snapshotTextures()
  230. {
  231. //动态创建一个新的字典
  232. CCDictionary*pRet=newCCDictionary();
  233. CCDictElement*pElement=NULL;
  234. //遍历原来字典将数据填充到新字典中
  235. CCDICT_FOREACH(m_pTextures,pElement)
  236. {
  237. pRet->setObject(pElement->getObject(),pElement->getStrKey());
  238. }
  239. returnpRet;
  240. }
  241. //使用多线程载入图片。
  242. //参1:图片相对路径名。
  243. //参2:载入完成后要通知的对象。
  244. //参3:载入完成后要通知对象调用的函数。
  245. voidCCTextureCache::addImageAsync(constchar*path,SEL_CallFuncOselector)
  246. {
  247. //文件名不能为空
  248. CCAssert(path!=NULL,"TextureCache:fileimageMUSTnotbeNULL");
  249. //定义一个纹理指针并置空
  250. CCTexture2D*texture=NULL;
  252. //创建字符串pathKey做为字典查询关键字。
  253. std::stringpathKey=path;
  254. //取得图片所在位置的全路径名
  255. pathKey=CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(pathKey.c_str());
  256. //先查询一下是否字典里已经有了此纹理。
  257. texture=(CCTexture2D*)m_pTextures->objectForKey(pathKey.c_str());
  259. std::stringfullpath=pathKey;
  260. //如果已经有了，则直接把纹理做为参数调用要通知的对象的函数。
  261. if(texture!=NULL)
  262. {
  263. if(target&&selector)
  264. {
  265. (target->*selector)(texture);
  266. }
  268. return;
  269. }
  271. //如果是第一次调用多线程载入，创建信号量并进行相应初始化。
  272. if(s_pSem==NULL)
  273. {
  274. //判断是否使用信号量命名，如果是，创建一个信号量返回其地址给指针s_pSem。
  275. #ifCC_ASYNC_TEXTURE_CACHE_USE_NAMED_SEMAPHORE
  276. s_pSem=sem_open(CC_ASYNC_TEXTURE_CACHE_SEMAPHORE,O_CREAT,0644,0);
  277. if(s_pSem==SEM_FAILED)
  278. {
  279. CCLOG("CCTextureCacheasyncthreadsemaphoreiniterror:%sn",strerror(errno));
  280. s_pSem=NULL;
  281. return;
  282. }
  283. #else
  284. //如果不使用信号量命名，直接用sem_init来初始化信号量对象s_sem。
  285. intsemInitRet=sem_init(&s_sem,0);
  286. if(semInitRet<0)
  287. {
  288. //如果失败，打印出错并退出。
  289. CCLOG("CCTextureCacheasyncthreadsemaphoreiniterror:%sn",strerror(errno));
  290. return;
  291. }
  292. //如果成功，将信号量对象地址给指针s_pSem。
  293. s_pSem=&s_sem;
  294. #endif
  295. //建立加载消息队列
  296. s_pAsyncStructQueue=newqueue<AsyncStruct*>();
  297. //建立加载的图片信息结构队列
  298. s_pImageQueue=newqueue<ImageInfo*>();
  299. //线程锁初始化
  300. pthread_mutex_init(&s_asyncStructQueueMutex,NULL);
  301. pthread_mutex_init(&s_ImageInfoMutex,NULL);
  302. //创建加载线程。
  303. pthread_create(&s_loadingThread,NULL,loadImage,NULL);
  304. //将退出指令设为false。
  305. need_quit=false;
  306. }
  307. //多线程加载图片的引用计数器如果为0，
  308. if(0==s_nAsyncRefCount)
  309. {
  310. //将addImageAsyncCallBack函数加入显示设备上的回调函数处理器中。
  311. CCDirector::sharedDirector()->getScheduler()->scheduleSelector(schedule_selector(CCTextureCache::addImageAsyncCallBack),this,false);
  312. }
  313. //计数器加1
  314. ++s_nAsyncRefCount;
  315. //
  316. if(target)
  317. {
  318. target->retain();
  319. }
  321. //产生一个新的加载消息，放入加载消息队列中。
  322. AsyncStruct*data=newAsyncStruct();
  323. data->filename=fullpath.c_str();
  324. data->target=target;
  325. data->selector=selector;
  327. //当然，放入时得锁一下，放入后再解锁。
  328. pthread_mutex_lock(&s_asyncStructQueueMutex);
  329. s_pAsyncStructQueue->push(data);
  330. pthread_mutex_unlock(&s_asyncStructQueueMutex);
  331. //给信号量加1，sem_post是原子操作，即多个线程同时调用并不会产生冲突。
  332. sem_post(s_pSem);
  333. }
  334. //多线程加载图片时的回调函数。
  335. voidCCTextureCache::addImageAsyncCallBack(floatdt)
  336. {
  337. //取得多线程加载的图片信息队列
  338. std::queue<ImageInfo*>*imagesQueue=s_pImageQueue;
  339. //下面代码作为临界区上锁
  340. pthread_mutex_lock(&s_ImageInfoMutex);
  341. //如果图片信息队列为空直接解锁，否则进行处理
  342. if(imagesQueue->empty())
  343. {
  344. pthread_mutex_unlock(&s_ImageInfoMutex);
  345. }
  346. else
  347. {
  348. //取出图片信息队列的头一个信息从队列中弹出。
  349. ImageInfo*pImageInfo=imagesQueue->front();
  350. imagesQueue->pop();
  351. //解锁临界区
  352. pthread_mutex_unlock(&s_ImageInfoMutex);
  353. //取得信息中的加载消息。
  354. AsyncStruct*pAsyncStruct=pImageInfo->asyncStruct;
  355. //取得图片信息中的CCImage指针。
  356. CCImage*pImage=pImageInfo->image;
  357. //取得加载完成后要通知的对象以及要调用的函数。
  358. CCObject*target=pAsyncStruct->target;
  359. SEL_CallFuncOselector=pAsyncStruct->selector;
  360. //取得图片文件名
  361. constchar*filename=pAsyncStruct->filename.c_str();
  363. //新建一个纹理。
  364. CCTexture2D*texture=newCCTexture2D();
  365. //使用CCImage指针pImage来初始化纹理生成OpenGL贴图。
  366. #if0//TODO:(CC_TARGET_PLATFORM==CC_PLATFORM_IOS)
  367. texture->initWithImage(pImage,kCCResolutioniPhone);
  368. #else
  369. texture->initWithImage(pImage);
  370. #endif
  372. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  373. //使用纹理和图片信息生成相应的可变纹理
  374. VolatileTexture::addImageTexture(texture,filename,pImageInfo->imageType);
  375. #endif
  377. //使用文件名做为查询关键字将纹理存入字典
  378. m_pTextures->setObject(texture,filename);
  379. texture->autorelease();
  380. //调用通知目标的相应函数。
  381. if(target&&selector)
  382. {
  383. (target->*selector)(texture);
  384. target->release();
  385. }
  386. //释放CCImage对象。
  387. pImage->release();
  388. //释放new出来的消息结构和图片信息结构。
  389. deletepAsyncStruct;
  390. deletepImageInfo;
  391. //多线程加载引用计数器减1，
  392. --s_nAsyncRefCount;
  393. if(0==s_nAsyncRefCount)
  394. {
  395. //从显示设备上的回调函数处理器中移除加载回调函数。
  396. CCDirector::sharedDirector()->getScheduler()->unscheduleSelector(schedule_selector(CCTextureCache::addImageAsyncCallBack),this);
  397. }
  398. }
  399. }
  400. //加载一个图片生成纹理。
  401. CCTexture2D*CCTextureCache::addImage(constchar*path)
  402. {
  403. //参数有效性判断
  404. CCAssert(path!=NULL,"TextureCache:fileimageMUSTnotbeNULL");
  405. //定义纹理指针变量并置空
  406. CCTexture2D*texture=NULL;
  407. //非多线程，故屏蔽，如果addImageAsync在其它线程调用此函数，则打开这段代码。
  408. //pthread_mutex_lock(m_pDictLock);
  410. //创建字符串pathKey做为字典查询关键字。
  411. std::stringpathKey=path;
  412. //取得图片所在位置的全路径名
  413. pathKey=CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(pathKey.c_str());
  414. //用pathKey查询字典中是否有此纹理。
  415. texture=(CCTexture2D*)m_pTextures->objectForKey(pathKey.c_str());
  416. //新建字符串fullpath存储全路径。
  417. std::stringfullpath=pathKey;
  418. //如果没有找到，
  419. if(!texture)
  420. {
  421. //将文件路径放入新字符串lowerCase。并将字符串中的所有字母转为小写。
  422. std::stringlowerCase(path);
  423. for(unsignedinti=0;i<lowerCase.length();++i)
  424. {
  425. lowerCase[i]=tolower(lowerCase[i]);
  426. }
  427. //
  428. do
  429. {
  430. //如果字符串能够找到".pvr"，则代表是pvr文件。调用相应函数将其载入。
  431. if(std::string::npos!=lowerCase.find(".pvr"))
  432. {
  433. texture=this->addPVRImage(fullpath.c_str());
  434. }
  435. else
  436. {
  437. //否则分别取得文件的格式。
  438. CCImage::EImageFormateImageFormat=CCImage::kFmtUnKnown;
  439. if(std::string::npos!=lowerCase.find(".png"))
  440. {
  441. eImageFormat=CCImage::kFmtPng;
  442. }
  443. elseif(std::string::npos!=lowerCase.find(".jpg")||std::string::npos!=lowerCase.find(".jpeg"))
  444. {
  445. eImageFormat=CCImage::kFmtJpg;
  446. }
  447. elseif(std::string::npos!=lowerCase.find(".tif")||std::string::npos!=lowerCase.find(".tiff"))
  448. {
  449. eImageFormat=CCImage::kFmtTiff;
  450. }
  452. //创建CCImage对象，从文件中读取文件的数据并初始化CCImage对象。
  453. CCImageimage;
  454. //取得文件大小
  455. unsignedlongnSize=0;
  456. //读入数据返回给BYTE类型指针。
  457. unsignedchar*pBuffer=CCFileUtils::sharedFileUtils()->getFileData(fullpath.c_str(),"rb",&nSize);
  458. //使用读入的数据初始化相应的图片对象。
  459. CC_BREAK_IF(!image.initWithImageData((void*)pBuffer,nSize,eImageFormat));
  460. //读完后释放数据占用的内存。
  461. CC_SAFE_DELETE_ARRAY(pBuffer);
  462. //创建一个纹理。
  463. texture=newCCTexture2D();
  464. //使用图片对象创建纹理。
  465. if(texture&&
  466. texture->initWithImage(&image))
  467. {
  468. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  469. //使用图片对象生成可变纹理
  470. VolatileTexture::addImageTexture(texture,fullpath.c_str(),eImageFormat);
  471. #endif
  472. //利用路径名做为查询关键字将纹理存入字典。
  473. m_pTextures->setObject(texture,pathKey.c_str());
  474. //计数器减1。则刚存入字典的纹理的引用计数器值标记为尚未使用。
  475. texture->release();
  476. }
  477. else
  478. {
  479. //失败则打印错误。
  480. CCLOG("cocos2d:Couldn'taddimage:%sinCCTextureCache",path);
  481. }
  482. }
  483. }while(0);
  484. }
  485. //与上面屏蔽加锁一样，这里屏蔽解锁。
  486. //pthread_mutex_unlock(m_pDictLock);
  487. returntexture;
  488. }
  490. //如果支持PVR的压缩格式。
  491. #ifdefCC_SUPPORT_PVRTC
  492. //加载一个PVR的压缩格式的图片。
  493. CCTexture2D*CCTextureCache::addPVRTCImage(constchar*path,intwidth)
  494. {
  495. //参数有效性判断
  496. CCAssert(path!=NULL,"TextureCache:fileimageMUSTnotbenill");
  497. //压缩类型参数有效性判断，只能为2或4
  498. CCAssert(bpp==2||bpp==4,"TextureCache:bppmustbeeither2or4");
  499. //定义一个新的纹理指针
  500. CCTexture2D*texture;
  502. //定义临时字符串存储相对路径名。
  503. std::stringtemp(path);
  504. //查询字典中是否已经有此纹理。有则取得并直接返回纹理。
  505. if((texture=(CCTexture2D*)m_pTextures->objectForKey(temp.c_str())))
  506. {
  507. returntexture;
  508. }
  510. //取得文件的全路径字符串。
  511. std::stringfullpath(CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(path));
  513. //新建变量nLeng用于存储读取到的数据大小。初始化为0。
  514. unsignedlongnLen=0;
  515. //新建字符指针pData用于存储读取到的数据并实际读取文件数据。
  516. unsignedchar*pData=CCFileUtils::sharedFileUtils()->getFileData(fullpath.c_str(),&nLen);
  517. //新建创一个纹理。
  518. texture=newCCTexture2D();
  519. //使用读取到的数据创建纹理。
  520. if(texture->initWithPVRTCData(pData,bpp,hasAlpha,
  521. (bpp==2?kCCTexture2DPixelFormat_PVRTC2:kCCTexture2DPixelFormat_PVRTC4)))
  522. {
  523. //将纹理以文件名做为关键字存入字典。
  524. m_pTextures->setObject(texture,temp.c_str());
  525. //将纹理交由内存管理器处理。
  526. texture->autorelease();
  527. }
  528. else
  529. {
  530. //如果创建失败或读取PVR文件失败，打印错误日志。
  531. CCLOG("cocos2d:Couldn'taddPVRTCImage:%sinCCTextureCache",path);
  532. }
  533. //释放读取文件的数据所占用的内存。
  534. CC_SAFE_DELETE_ARRAY(pData);
  536. returntexture;
  537. }
  538. #endif//CC_SUPPORT_PVRTC
  540. //加载一个普通的PVR图片文件
  541. CCTexture2D*CCTextureCache::addPVRImage(constchar*path)
  542. {
  543. //文件名参数有效性判断。
  544. CCAssert(path!=NULL,"TextureCache:fileimageMUSTnotbenill");
  545. //新建纹理指针变量置空。
  546. CCTexture2D*texture=NULL;
  547. //定义临时字符串存储相对路径名。
  548. std::stringkey(path);
  549. //先使用文件名查询是否字典中已经有此纹理了。如果有直接取得并返回纹理。
  550. if((texture=(CCTexture2D*)m_pTextures->objectForKey(key.c_str())))
  551. {
  552. returntexture;
  553. }
  555. //由文件名字符串取得图片的全路径字符串。
  556. std::stringfullpath=CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(key.c_str());
  557. //动态创建一个纹理。
  558. texture=newCCTexture2D();
  559. //如果创建成功，则读取相应的PVR文件来初始化纹理。
  560. if(texture!=NULL&&texture->initWithPVRFile(fullpath.c_str()))
  561. {
  562. //初始化成功。
  563. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  564. //使用纹理和图片信息生成可变纹理。
  565. VolatileTexture::addImageTexture(texture,CCImage::kFmtRawData);
  566. #endif
  567. //将纹理以文件名做为查询关键字存入字典。
  568. m_pTextures->setObject(texture,key.c_str());
  569. texture->autorelease();
  570. }
  571. else
  572. {
  573. //如果创建失败或读取PVR文件失败，打印错误日志。
  574. CCLOG("cocos2d:Couldn'taddPVRImage:%sinCCTextureCache",key.c_str());
  575. CC_SAFE_DELETE(texture);
  576. }
  578. returntexture;
  579. }
  580. //加载一个图片生成纹理，指定参数key做为字典的查询对应关键字。
  581. CCTexture2D*CCTextureCache::addUIImage(CCImage*image,constchar*key)
  582. {
  583. //参数有效性判断
  584. CCAssert(image!=NULL,"TextureCache:imageMUSTnotbenill");
  586. //定义纹理指针变量texure做为返回值。这里初始化为空。
  587. CCTexture2D*texture=NULL;
  588. //定义字符串变量forKey用来存储完整的图片路径名称。
  589. std::stringforKey;
  590. if(key)
  591. {
  592. //取得文件名所对应的全路径名，呵呵，这个key也还是个相对路径名啊。
  593. forKey=CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(key);
  594. }
  596. do
  597. {
  598. //查询字典是否已经有此纹理了。如果有，取出纹理返回给texture，中断退出。
  599. if(key&&(texture=(CCTexture2D*)m_pTextures->objectForKey(forKey.c_str())))
  600. {
  601. break;
  602. }
  604. //动态创建一个纹理对象.返回给texture。
  605. texture=newCCTexture2D();
  606. //使用image来初始化纹理.注意:这一句应该移到下面的if中。
  607. texture->initWithImage(image);
  608. //初始化完成后以路径名做为查询关键字将纹理存入字典。
  609. if(key&&texture)
  610. {
  611. m_pTextures->setObject(texture,forKey.c_str());
  612. texture->autorelease();
  613. }
  614. else
  615. {
  616. //如果key为空或texture为空打印错误
  617. CCLOG("cocos2d:Couldn'taddUIImageinCCTextureCache");
  618. }
  620. }while(0);
  622. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  623. //使用纹理和CCImage对象生成可变纹理。
  624. VolatileTexture::addCCImage(texture,image);
  625. #endif
  627. returntexture;
  628. }
  630. //清空字典，释放所有纹理。
  631. voidCCTextureCache::removeAllTextures()
  632. {
  633. m_pTextures->removeAllObjects();
  634. }
  635. //清除未被外部使用的纹理
  636. voidCCTextureCache::removeUnusedTextures()
  637. {
  638. /*原来的做法，因为有问题给屏蔽了，仍然解释下：
  639. //定义字典词汇指针变量pElement。
  640. CCDictElement*pElement=NULL;
  641. //遍历字典
  642. CCDICT_FOREACH(m_pTextures,pElement)
  643. {
  644. //打印词汇信息
  645. CCLOG("cocos2d:CCTextureCache:texture:%s",pElement->getStrKey());
  646. //取得词汇对应的纹理
  647. CCTexture2D*value=(CCTexture2D*)pElement->getObject();
  648. //如果引用计数器值为1，从字典中删除。
  649. if(value->retainCount()==1)
  650. {
  651. CCLOG("cocos2d:CCTextureCache:removingunusedtexture:%s",pElement->getStrKey());
  652. m_pTextures->removeObjectForElememt(pElement);
  653. }
  654. }
  655. */
  657. //现在的做法
  658. //判断字典不为空
  659. if(m_pTextures->count())
  660. {
  661. //定义字典词汇指针变量pElement。
  662. CCDictElement*pElement=NULL;
  663. //定义一个list容器用来存储未被外部使用的纹理指针。
  664. list<CCDictElement*>elementToRemove;
  665. //遍历字典
  666. CCDICT_FOREACH(m_pTextures,pElement)
  667. {
  668. //打印词汇信息
  669. CCLOG("cocos2d:CCTextureCache:texture:%s",pElement->getStrKey());
  670. //取得词汇对应的纹理
  671. CCTexture2D*value=(CCTexture2D*)pElement->getObject();
  672. if(value->retainCount()==1)
  673. {
  674. //如果引用计数器值为1，先存入容器中。
  675. elementToRemove.push_back(pElement);
  676. }
  677. }
  679. //遍历list中的元素从字典中删除
  680. for(list<CCDictElement*>::iteratoriter=elementToRemove.begin();iter!=elementToRemove.end();++iter)
  681. {
  682. //打印删除元素日志。
  683. CCLOG("cocos2d:CCTextureCache:removingunusedtexture:%s",(*iter)->getStrKey());
  684. //从字典中删除
  685. m_pTextures->removeObjectForElememt(*iter);
  686. }
  687. }
  688. //好吧，答案是因为CCDICT_FOREACH和removeObjectForElememt会互相影响，CCDICT_FOREACH中会调用HASH_ITER循环遍历。而循环的计数器是位置，通过地址对比来找下一个结点位置。而removeObjectForElememt会调用HASH_DELETE删除元素导致链表的重构。重构后会影响到HASK_ITER的查询。
  690. }
  691. //移除一个纹理
  692. voidCCTextureCache::removeTexture(CCTexture2D*texture)
  693. {
  694. //参数有效性判断
  695. if(!texture)
  696. {
  697. return;
  698. }
  699. //查询所有对应此纹理的词汇
  700. CCArray*keys=m_pTextures->allKeysForObject(texture);
  701. //从字典中把这些词汇及相应纹理删除。
  702. m_pTextures->removeObjectsForKeys(keys);
  703. }
  704. //由字典查询关键字找到相应纹理并移除。
  705. voidCCTextureCache::removeTextureForKey(constchar*textureKeyName)
  706. {
  707. //参数有效性判断
  708. if(textureKeyName==NULL)
  709. {
  710. return;
  711. }
  712. //查询关键字实际是文件的相对路径，这里取得全路径。
  713. stringfullPath=CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(textureKeyName);
  714. //将全路径做为查询关键字从字典中删除相应词汇及纹理
  715. m_pTextures->removeObjectForKey(fullPath.c_str());
  716. }
  717. //由字典查询关键字找到相应纹理
  718. CCTexture2D*CCTextureCache::textureForKey(constchar*key)
  719. {
  720. return(CCTexture2D*)m_pTextures->objectForKey(CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(key));
  721. }
  722. //重新载入所有的纹理
  723. voidCCTextureCache::reloadAllTextures()
  724. {
  725. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  726. //调用可变纹理的静态函数重新载入所有的纹理
  727. VolatileTexture::reloadAllTextures();
  728. #endif
  729. }
  730. //打印字典中的纹理统计信息。
  731. voidCCTextureCache::dumpCachedTextureInfo()
  732. {
  733. unsignedintcount=0;
  734. unsignedinttotalBytes=0;
  736. CCDictElement*pElement=NULL;
  737. //遍历字典中的所有词汇信息
  738. CCDICT_FOREACH(m_pTextures,pElement)
  739. {
  740. //取得词汇对应的纹理
  741. CCTexture2D*tex=(CCTexture2D*)pElement->getObject();
  742. //取得纹理对应贴图的色深
  743. unsignedintbpp=tex->bitsPerPixelForFormat();
  744. //生成贴图占用的内存大小(字节数量)
  745. unsignedintbytes=tex->getPixelsWide()*tex->getPixelsHigh()*bpp/8;
  746. //统计内存总大小
  747. totalBytes+=bytes;
  748. count++;
  749. //打印纹理信息
  750. CCLOG("cocos2d:"%s"rc=%luid=%lu%lux%lu@%ldbpp=>%luKB",
  751. pElement->getStrKey(),//查询关键字
  752. (long)tex->retainCount(),//使用次数
  753. (long)tex->getName(),//图片名称
  754. (long)tex->getPixelsWide(),//对应贴图的宽度
  755. (long)tex->getPixelsHigh(),//对应贴图的高度
  756. (long)bpp,//对应贴图色深
  757. (long)bytes/1024);//占用内存大小(千字节数量)
  758. }
  759. //打印总的数量数量，占用内存数量。
  760. CCLOG("cocos2d:CCTextureCachedumpDebugInfo:%ldtextures,for%luKB(%.2fMB)",(long)count,(long)totalBytes/1024,totalBytes/(1024.0f*1024.0f));
  761. }
  762. //如果开启了使用多变纹理
  763. #ifCC_ENABLE_CACHE_TEXTURE_DATA
  764. //定义全局的list容器，用来存储产生的多变纹理对象指针
  765. std::list<VolatileTexture*>VolatileTexture::textures;
  766. //定义布尔变量标记是否在全部重新载入
  767. boolVolatileTexture::isReloading=false;
  768. //构造函数
  769. VolatileTexture::VolatileTexture(CCTexture2D*t)
  770. :texture(t)
  771. ,m_eCashedImageType(kInvalid)
  772. ,m_pTextureData(NULL)
  773. ,m_PixelFormat(kTexture2DPixelFormat_RGBA8888)
  774. ,m_strFileName("")
  775. ,m_FmtImage(CCImage::kFmtPng)
  776. ,m_alignment(kCCTextAlignmentCenter)
  777. ,m_vAlignment(kCCVerticalTextAlignmentCenter)
  778. ,m_strFontName("")
  779. ,m_strText("")
  780. ,uiImage(NULL)
  781. ,m_fFontSize(0.0f)
  782. {
  783. m_size=CCSizeMake(0,0);
  784. textures.push_back(this);
  785. }
  786. //析构函数
  787. VolatileTexture::~VolatileTexture()
  788. {
  789. textures.remove(this);
  790. CC_SAFE_RELEASE(uiImage);
  791. }
  792. //通过纹理图片属性信息生成可变纹理。
  793. voidVolatileTexture::addImageTexture(CCTexture2D*tt,CCImage::EImageFormatformat)
  794. {
  795. //如果正在重新载入过程中，直接返回。
  796. if(isReloading)
  797. {
  798. return;
  799. }
  800. //通过纹理指针找到相应的可变纹理，如果没有则new一个返回其指针。
  801. VolatileTexture*vt=findVolotileTexture(tt);
  802. //设置相关属性，注意:这里最好对vt做下有效性检查，如果为NULL的话会崩溃的。
  803. vt->m_eCashedImageType=kImageFile;
  804. vt->m_strFileName=imageFileName;
  805. vt->m_FmtImage=format;
  806. vt->m_PixelFormat=tt->getPixelFormat();
  807. }
  808. //通过CCImage对象生成可变纹理。
  809. voidVolatileTexture::addCCImage(CCTexture2D*tt,CCImage*image)
  810. {
  811. //通过纹理指针找到相应的可变纹理，如果没有则new一个返回其指针。
  812. VolatileTexture*vt=findVolotileTexture(tt);
  813. image->retain();
  814. //设置相关属性
  815. vt->uiImage=image;
  816. vt->m_eCashedImageType=kImage;
  817. }
  818. //通过纹理指针找到相应的可变纹理，如果没有则new出一个返回。
  819. VolatileTexture*VolatileTexture::findVolotileTexture(CCTexture2D*tt)
  820. {
  821. VolatileTexture*vt=0;
  822. //遍历list容器，对比查询。
  823. std::list<VolatileTexture*>::iteratori=textures.begin();
  824. while(i!=textures.end())
  825. {
  826. VolatileTexture*v=*i++;
  827. if(v->texture==tt)
  828. {
  829. vt=v;
  830. break;
  831. }
  832. }
  833. //如果没有找到，则由纹理参数new出一个可变纹理，new会调用其带参数的拷贝构造函数设置其对应纹理。
  834. if(!vt)
  835. {
  836. vt=newVolatileTexture(tt);
  837. }
  839. returnvt;
  840. }
  841. //通过指定图像数据，像素格式和图片大小来生成可变纹理。
  842. voidVolatileTexture::addDataTexture(CCTexture2D*tt,constCCSize&contentSize)
  843. {
  844. //如果正在重新载入过程中，直接返回。
  845. if(isReloading)
  846. {
  847. return;
  848. }
  849. //通过纹理指针找到相应的可变纹理，如果没有则new一个返回其指针。
  850. VolatileTexture*vt=findVolotileTexture(tt);
  851. //设置相关属性
  852. vt->m_eCashedImageType=kImageData;
  853. vt->m_pTextureData=data;
  854. vt->m_PixelFormat=pixelFormat;
  855. vt->m_TextureSize=contentSize;
  856. }
  857. //由字符串和相应信息生成可变纹理
  858. voidVolatileTexture::addStringTexture(CCTexture2D*tt,floatfontSize)
  859. {
  860. //如果正在重新载入过程中，直接返回。
  861. if(isReloading)
  862. {
  863. return;
  864. }
  865. //通过纹理指针找到相应的可变纹理，如果没有则new一个返回其指针。
  866. VolatileTexture*vt=findVolotileTexture(tt);
  867. //设置相关属性
  868. vt->m_eCashedImageType=kString;
  869. vt->m_size=dimensions;
  870. vt->m_strFontName=fontName;
  871. vt->m_alignment=alignment;
  872. vt->m_vAlignment=vAlignment;
  873. vt->m_fFontSize=fontSize;
  874. vt->m_strText=text;
  875. }
  876. //通过纹理指针找到相应的可变纹理并删除。
  877. voidVolatileTexture::removeTexture(CCTexture2D*t)
  878. {
  880. std::list<VolatileTexture*>::iteratori=textures.begin();
  881. while(i!=textures.end())
  882. {
  883. VolatileTexture*vt=*i++;
  884. if(vt->texture==t)
  885. {
  886. deletevt;
  887. break;
  888. }
  889. }
  890. }
  891. //重新载入所有的纹理。
  892. voidVolatileTexture::reloadAllTextures()
  893. {
  894. //设置开始进行重新载入所有纹理。
  895. isReloading=true;
  897. CCLOG("reloadalltexture");
  898. //通过迭代器遍历list容器
  899. std::list<VolatileTexture*>::iteratoriter=textures.begin();
  900. while(iter!=textures.end())
  901. {
  902. VolatileTexture*vt=*iter++;
  903. //根据不同的格式进行纹理的重建
  904. switch(vt->m_eCashedImageType)
  905. {
  906. casekImageFile:
  907. {
  908. //这里定义一个CCImage对象image
  909. CCImageimage;
  910. //先将路径名都变成小写字符串。
  911. std::stringlowerCase(vt->m_strFileName.c_str());
  912. for(unsignedinti=0;i<lowerCase.length();++i)
  913. {
  914. lowerCase[i]=tolower(lowerCase[i]);
  915. }
  916. //扩展名对比，如果是PVR文件
  917. if(std::string::npos!=lowerCase.find(".pvr"))
  918. {
  919. //取得原来的默认带ALPHA通道的像素格式。
  920. CCTexture2DPixelFormatoldPixelFormat=CCTexture2D::defaultAlphaPixelFormat();
  921. //重设默认带ALPHA通道的像素格式。
  922. CCTexture2D::setDefaultAlphaPixelFormat(vt->m_PixelFormat);
  924. //纹理重新由PVR文件进行初始化。会用到新的默认带ALPHA通道的像素格式。
  925. vt->texture->initWithPVRFile(vt->m_strFileName.c_str());
  926. //重设原来的默认带ALPHA通道的像素格式。
  927. CCTexture2D::setDefaultAlphaPixelFormat(oldPixelFormat);
  928. }
  929. else
  930. {
  931. //如果是非PVR文件。
  932. unsignedlongnSize=0;
  933. //通过文件工具集中的接口读入图片文件并返回数据地址。
  934. unsignedchar*pBuffer=CCFileUtils::sharedFileUtils()->getFileData(vt->m_strFileName.c_str(),&nSize);
  935. //使用数据地址对前面定义的CCImage对象image进行初始化。
  936. if(image.initWithImageData((void*)pBuffer,vt->m_FmtImage))
  937. {
  938. //取得原来的默认带ALPHA通道的像素格式。
  939. CCTexture2DPixelFormatoldPixelFormat=CCTexture2D::defaultAlphaPixelFormat();
  940. //重设默认带ALPHA通道的像素格式。CCTexture2D::setDefaultAlphaPixelFormat(vt->m_PixelFormat);
  941. //纹理重新由图片对象初始化。会用到新的默认带ALPHA通道的像素格式。
  943. vt->texture->initWithImage(&image);
  944. //重设原来的默认带ALPHA通道的像素格式。
  945. CCTexture2D::setDefaultAlphaPixelFormat(oldPixelFormat);
  946. }
  948. CC_SAFE_DELETE_ARRAY(pBuffer);
  949. }
  950. }
  951. break;
  952. casekImageData:
  953. {
  954. //纹理重新由图片数据初始化。
  955. vt->texture->initWithData(vt->m_pTextureData,
  956. vt->m_PixelFormat,
  957. vt->m_TextureSize.width,
  958. vt->m_TextureSize.height,
  959. vt->m_TextureSize);
  960. }
  961. break;
  962. casekString:
  963. {
  964. //纹理重新由字符串初始化。
  965. vt->texture->initWithString(vt->m_strText.c_str(),
  966. vt->m_size,
  967. vt->m_alignment,
  968. vt->m_vAlignment,
  969. vt->m_strFontName.c_str(),
  970. vt->m_fFontSize);
  971. }
  972. break;
  973. casekImage:
  974. {
  975. //纹理重新由图片对象初始化。
  976. vt->texture->initWithImage(vt->uiImage);
  977. }
  978. break;
  979. default:
  980. break;
  981. }
  982. }
  983. //设置重新载入完成
  984. isReloading=false;
  985. }
  987. #endif//CC_ENABLE_CACHE_TEXTURE_DATA
  989. NS_CC_END

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
    相关内容
      推荐文章
        站长推荐
        热点阅读

          【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

          建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

          Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同