07 Cocos2d-x内存管理

Cocos2d-x 前端之家
前端之家收集整理的这篇文章主要介绍了07 Cocos2d-x内存管理，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。
引用计数的由来
cocos2d-x 的世界是基于 CCObject 类构建的，其中的每个元素：层、场景、精灵等都是一个个 CCObject 的对象。所以 内存管理的本质就是管理一个个 CCObject。作为一个 cocos2d 的 C++ 移植版本，在它之前有很多其它语言的 实现，从架构层次来说，这与语言的实现无关（比如 CCNode 的节点树形关系，其它语言也可以实现，如果是内存方便，C# 等更是无需考虑），但就从内存管理方面来说，参考了 OC （Objective-C） 的内存管理实现。
一个简单的自动管理原则：CCObject 内部维护着一个引用计数，引用计数为 0 就自动释放 ～（如果么有直接做如 delete 之类的操作）。那么此时可以预见，管理内存的实质就是管理这些 "引用计数" 了！使用 retain 和 release 方法对引用计数进行操作！
为什么要有自动释放池 及其作用
我们知道 cocos2d-x 使用了自动释放池，自动管理对象，知其然！其所以然呢？为什么需要自动释放池，它在整个框架之中又起着什么样的作用！在了解这一点之前，我们需要 知道 CCObject 从创建之初，到最终销毁，经历了哪些过程。在此，一叶总结以下几点：
1.刚创建的对象，而 为了保证在使用之前不会释放（至少让它存活一帧），所以自引用（也就是初始为1）
2.为了确定是否 实际使用，所以需要在一个合适的时机，解除自身引用。
3.而这个何时的时机正是在帧过度之时。
4.帧过度之后的对象，用则用矣，不用则弃！
5.由于已经解除了自身引用，所以它的引用被使用者管理（一般而言，内部组成树形结构的链式反应，如 CCNode）。
6.链式反应，也就是，如果释放一个对象，也会释放它所引用的对象。
上面是一个对象的大致流程，我们将对象分为两个时期，一个是刚创建时期，自引用为 1（如果为 0 就会释放对象，这是基本原则，所以要大于 0） 的时期，另一个是使用时期。上面说到，为了保证创
建时期的对象不被销毁，所以自引用(并没有实际的使用)初始化为 1，这就意味着我们需要一个合适的时机，来解除这样的自引用。
何时？在帧过度之时！(这样可保证当前帧能正确使用对象而没有被销毁。)怎么样释放？由于是自引用，我们并不能通过其它方式访问到它，所以就有了自动释放池，我们 变相的将“自引用”转化“自动释放池引用”，来标记一个 “创建时期的对象”。然后在帧过度之时，通过自动释放池管理，统一释放 “释放池引用”，也就意味着，去除了“自身引用”。帧过度之后的对象，才是真正的被使用者所管理。 下面我们用代码来解释上述过程。
通常我们使用 create(); 方法来创建一个自动管理的对象，而其内部实际操作如下： 
  1.  
  2.  
      1.   
      2.   
      1. //初始化一个对象
      3.   
      4.   
      1. staticCCObject*create()
      5.   
      6.   
      1. {
      7.   
      8.   
      1. //newCCObject对象
      9.   
      10.   
      1. CCObject*pRet=newCCObject();
      11.   
      12.   
      1. if(pRet&&pRet->init())
      13.   
      14.   
      1. {
      15.   
      16.   
      1. //添加到自动释放池
      17.   
      18.   
      1. pRet->autorelease();
      19.   
      20.   
      1. returnpRet;
      21.   
      22.   
      1. }
      23.   
      24.   
      1. else
      25.   
      26.   
      1. {
      27.   
      28.   
      1. deletepRet;
      29.   
      30.   
      1. pRet=0;
      31.   
      32.   
      1. return0;
      33.   
      34.   
      1. }
      35.   
      36.   
      1. }
      37.   
      38.   
      39.   
      40.   
      1. //我们看到初始化的对象自引用m_uReference=1
      41.   
      42.   
      1. CCObject::CCObject(void)
      43.   
      44.   
      1. :m_uAutoReleaseCount(0)
      45.   
      46.   
      1. ,m_uReference(1)//whentheobjectiscreated,thereferencecountofitis1
      47.   
      48.   
      1. ,m_nLuaID(0)
      49.   
      50.   
      1. {
      51.   
      52.   
      1. staticunsignedintuObjectCount=0;
      53.   
      54.   
      55.   
      56.   
      1. m_uID=++uObjectCount;
      57.   
      58.   
      1. }
      59.   
      60.   
      61.   
      62.   
      1. //标记为自动释放对象
      63.   
      64.   
      1. CCObject*CCObject::autorelease(void)
      65.   
      66.   
      1. {
      67.   
      68.   
      1. //添加到自动释放池
      69.   
      70.   
      1. CCPoolManager::sharedPoolManager()->addObject(this);
      71.   
      72.   
      1. returnthis;
      73.   
      74.   
      1. }
      75.   
      76.   
      77.   
      78.   
      1. //继续跟踪
      79.   
      80.   
      1. voidCCPoolManager::addObject(CCObject*pObject)
      81.   
      82.   
      1. {
      83.   
      84.   
      1. getCurReleasePool()->addObject(pObject);
      85.   
      86.   
      1. }
      87.   
      88.   
      89.   
      90.   
      1. //添加到自动释放池的实际操作
      91.   
      92.   
      1. voidCCAutoreleasePool::addObject(CCObject*pObject)
      93.   
      94.   
      1. {
      95.   
      96.   
      1. //内部是由一个CCArray维护自动释放对象，并且此操作会使引用+1
      97.   
      98.   
      1. m_pManagedObjectArray->addObject(pObject);
      99.   
      100.   
      101.   
      102.   
      1. //由于初始化引用为1，上面又有操作，所以引用至少为2（可能还被其它所引用）
      103.   
      104.   
      1. CCAssert(pObject->m_uReference>1,"referencecountshouldbegreaterthan1");
      105.   
      106.   
      1. ++(pObject->m_uAutoReleaseCount);
      107.   
      108.   
      1. //变相的将自身引用转化为释放池引用，所以减1
      109.   
      110.   
      1. pObject->release();//norefcount,inthiscaseautoreleasepooladded.
      111.   
      112.   
      1. }
      113.  
      114.
    上面便是通过 create() 方法创建对象的过程。文中说到，一个合适的时机，解除自身引用（也就是释放池引用），那这又是在何时进行的呢？程序的运行有一个主循环，控制着每一帧的操作，在每一帧画面画完之时会自动调用 CCPoolManager::sharedPoolManager()->pop(); 方法 ( 具体可参见文章Cocos2d-x 程序是如何开始运行与结束的 ，这里我们只要知道每一帧结束都会调用 pop() 方法)，来自动清理 创建时期 的引用。现在我们就来看看 pop() 的方法实现： 
    1.   
    2.   
    3. voidCCPoolManager::pop()
    4.   
    5.   
    6. {
    7.   
    8.   
    9. if(!m_pCurReleasePool)
    10.   
    11.   
    12. {
    13.   
    14.   
    15. return;
    16.   
    17.   
    18. }
    19.   
    20.   
    22.   
    23.   
    24. //当前释放池个数，pop使用栈结构
    25.   
    26.   
    27. intnCount=m_pReleasePoolStack->count();
    28.   
    29.   
    30. //释放池当中存放的都是创建时期对象，此时解除释放池引用
    31.   
    32.   
    33. m_pCurReleasePool->clear();
    34.   
    35.   
    37.   
    38.   
    39. //当前释放池，出栈，在这里可以看到判断nCount是否大于1，文后将会对此做具体说明
    40.   
    41.   
    42. if(nCount>1)
    43.   
    44.   
    45. {
    46.   
    47.   
    48. m_pReleasePoolStack->removeObjectAtIndex(nCount-1);
    49.   
    50.   
    52.   
    53.   
    54. //if(nCount>1)
    55.   
    56.   
    57. //{
    58.   
    59.   
    60. //m_pCurReleasePool=m_pReleasePoolStack->objectAtIndex(nCount-2);
    61.   
    62.   
    63. //return;
    64.   
    65.   
    66. //}
    67.   
    68.   
    69. m_pCurReleasePool=(CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount-2);
    70.   
    71.   
    72. }
    73.   
    74.   
    76.   
    77.   
    78. /*m_pCurReleasePool=NULL;*/
    79.   
    80.   
    81. }
    82.   
    83.   
    85.   
    86.   
    87. //释放池引用清理工作
    88.   
    89.   
    90. voidCCAutoreleasePool::clear()
    91.   
    92.   
    93. {
    94.   
    95.   
    96. //如果释放池存在创建时期的对象
    97.   
    98.   
    99. if(m_pManagedObjectArray->count()>0)
    100.   
    101.   
    102. {
    103.   
    104.   
    105. //CCAutoreleasePool*pReleasePool;
    106.   
    107.   
    108. #ifdef_DEBUG
    109.   
    110.   
    111. intnIndex=m_pManagedObjectArray->count()-1;
    112.   
    113.   
    114. #endif
    115.   
    116.   
    118.   
    119.   
    120. CCObject*pObj=NULL;
    121.   
    122.   
    123. CCARRAY_FOREACH_REVERSE(m_pManagedObjectArray,pObj)
    124.   
    125.   
    126. {
    127.   
    128.   
    129. if(!pObj)
    130.   
    131.   
    132. break;
    133.   
    134.   
    136.   
    137.   
    138. --(pObj->m_uAutoReleaseCount);
    139.   
    140.   
    141. //(*it)->release();
    142.   
    143.   
    144. //delete(*it);
    145.   
    146.   
    147. #ifdef_DEBUG
    148.   
    149.   
    150. nIndex--;
    151.   
    152.   
    153. #endif
    154.   
    155.   
    156. }
    157.   
    158.   
    159. //移除释放池对创建时期对象的引用，从而使对象交由使用者全权管理
    160.   
    161.   
    162. m_pManagedObjectArray->removeAllObjects();
    163.   
    164.   
    165. }
    166.   
    167.   
    168. }
    169.  
    170.
    到这里，自动释放池的作用也就完成了！ 可以说创建的对象在一帧 (但有特殊情况，下一段说明) 之后就完全脱离了 自动释放池的控制，自动释放池，对对象的管理也就在 创建时期起着作用！之后便交由使用者管理，释放。
    对"释放池"的管理说明
    我们知道了释放池管理着 创建时期 的对象，那么对于释放池本身是如何管理的？我们知道对于释放池，只需要有一个就已经能够满足我们的需求了，而在 cocos2d-x 的设计中，使用了集合管理 一堆 释放池。而在实际，它们又发挥了多大的用处？ 
    1. //释放池管理接口
    2.   
    3.   
    4. classCC_DLLCCPoolManager
    5.   
    6.   
    7. {
    8.   
    9.   
    10. //释放池对象集合
    11.   
    12.   
    13. CCArray*m_pReleasePoolStack;
    14.   
    15.   
    16. //当前操作释放池
    17.   
    18.   
    19. CCAutoreleasePool*m_pCurReleasePool;
    20.   
    21.   
    23.   
    24.   
    25. //获取当前释放池
    26.   
    27.   
    28. CCAutoreleasePool*getCurReleasePool();
    29.   
    30.   
    31. public:
    32.   
    33.   
    34. CCPoolManager();
    35.   
    36.   
    37. ~CCPoolManager();
    38.   
    39.   
    40. voidfinalize();
    41.   
    42.   
    43. voidpush();
    44.   
    45.   
    46. voidpop();
    47.   
    48.   
    50.   
    51.   
    52. voidremoveObject(CCObject*pObject);
    53.   
    54.   
    55. //添加一个创建时期对象
    56.   
    57.   
    58. voidaddObject(CCObject*pObject);
    59.   
    60.   
    62.   
    63.   
    64. staticCCPoolManager*sharedPoolManager();
    65.   
    66.   
    67. staticvoidpurgePoolManager();
    68.   
    69.   
    71.   
    72.   
    73. friendclassCCAutoreleasePool;
    74.   
    75.   
    76. };
    77.   
    78.   
    80.   
    81.   
    82. //我们从addObject开始看起，由上文可以addObject是由CCObject的autorelease自动调用的
    83.   
    84.   
    85. voidCCPoolManager::addObject(CCObject*pObject)
    86.   
    87.   
    88. {
    89.   
    90.   
    91. getCurReleasePool()->addObject(pObject);
    92.   
    93.   
    94. }
    95.   
    96.   
    98.   
    99.   
    100. CCAutoreleasePool*CCPoolManager::getCurReleasePool()
    101.   
    102.   
    103. {
    104.   
    105.   
    106. //如果当前释放池为空
    107.   
    108.   
    109. if(!m_pCurReleasePool)
    110.   
    111.   
    112. {
    113.   
    114.   
    115. //添加一个
    116.   
    117.   
    118. push();
    119.   
    120.   
    121. }
    122.   
    123.   
    125.   
    126.   
    127. CCAssert(m_pCurReleasePool,"currentautoreleasepoolshouldnotbenull");
    128.   
    129.   
    131.   
    132.   
    133. returnm_pCurReleasePool;
    134.   
    135.   
    136. }
    137.   
    138.   
    140.   
    141.   
    142. voidCCPoolManager::push()
    143.   
    144.   
    145. {
    146.   
    147.   
    148. CCAutoreleasePool*pPool=newCCAutoreleasePool();//ref=1
    149.   
    150.   
    151. m_pCurReleasePool=pPool;
    152.   
    153.   
    154. //像集合添加一个新的释放池
    155.   
    156.   
    157. m_pReleasePoolStack->addObject(pPool);//ref=2
    158.   
    159.   
    161.   
    162.   
    163. pPool->release();//ref=1
    164.   
    165.   
    166. }
    167.  
    168.
    从 addObject 开始分析，我们知道在 addObject 之前，会首先判断是否有当前的释放池，如果没有则创建，如果有，则直接使用，可想而知，在任何使用，任何情况，通过 addObject 只需要创建一个释放池便已经足够使用了。事实上也是如此。再来看 pop 方法。 
    1. return;
    2.   
    3.   
    4. }
    5.   
    6.   
    8.   
    9.   
    10. intnCount=m_pReleasePoolStack->count();
    11.   
    12.   
    13. //清楚对创建对象的引用
    14.   
    15.   
    16. m_pCurReleasePool->clear();
    17.   
    18.   
    20.   
    21.   
    22. //如果大于1，这也保证着，在任何时候，总有一个释放池是可以使用的
    23.   
    24.   
    25. if(nCount>1)
    26.   
    27.   
    28. {
    29.   
    30.   
    31. //移除当前的释放池
    32.   
    33.   
    34. m_pReleasePoolStack->removeObjectAtIndex(nCount-1);
    35.   
    36.   
    38.   
    39.   
    40. //}
    41.   
    42.   
    43. //将当前释放池设定为前一个释放池，也就是“出栈”的操作
    44.   
    45.   
    46. m_pCurReleasePool=(CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount-2);
    47.   
    48.   
    49. }
    50.   
    51.   
    53.   
    54.   
    55. /*m_pCurReleasePool=NULL;*/
    56.   
    57.   
    58. }
    59.  
    60.
    看到这里 我就不解了！什么情况下才能用到多个释放池？按照设计的逻辑根本用不到。带着这个疑问，我在 CCPoolManager::push() 方法之内添加了一句话打印（修改源代码） CCLog("这里要长长长的 **********"); ，然后重新编译源文件，运行程序，发现实际的使用中，push 只被调用了两次！我们知道，通过 addObject 可能会自动调用 push() 一次，但也仅有一次，所以一定是哪里手动调用了 push() 方法，才会出现这种情况，所以我继续翻看源代码，定位到了 bool CCDirector::init(void) 方法，在这里进行了游戏的全局初始化相关工作： 
    1.   
    2.   
    3. boolCCDirector::init(void)
    4.   
    5.   
    6. {
    7.   
    8.   
    9. CCLOG("cocos2d:%s",cocos2dVersion());
    10.   
    11.   
    13.   
    14.   
    15. ...
    16.   
    17.   
    18. ...
    19.   
    20.   
    21. m_dOldAnimationInterval=m_dAnimationInterval=1.0/kDefaultFPS;
    22.   
    23.   
    24. m_pobScenesStack=newCCArray();
    25.   
    26.   
    27. m_pobScenesStack->init();
    28.   
    29.   
    31.   
    32.   
    33. ...
    34.   
    35.   
    36. ...
    37.   
    38.   
    39. m_fContentScaleFactor=1.0f;
    40.   
    41.   
    43.   
    44.   
    45. ...
    46.   
    47.   
    48. ...
    49.   
    50.   
    51. //touchDispatcher
    52.   
    53.   
    54. m_pTouchDispatcher=newCCTouchDispatcher();
    55.   
    56.   
    57. m_pTouchDispatcher->init();
    58.   
    59.   
    61.   
    62.   
    63. //KeypadDispatcher
    64.   
    65.   
    66. m_pKeypadDispatcher=newCCKeypadDispatcher();
    67.   
    68.   
    70.   
    71.   
    72. //Accelerometer
    73.   
    74.   
    75. m_pAccelerometer=newCCAccelerometer();
    76.   
    77.   
    79.   
    80.   
    82.   
    83.   
    84. //这里手动调用了push方法，而在这之前的初始化过程中，间接的使用了CCObject的autorelease，已经触发过一次push方法
    85.   
    86.   
    87. CCPoolManager::sharedPoolManager()->push();
    88.   
    89.   
    91.   
    92.   
    93. true;
    94.   
    95.   
    96. }
    97.  
    98.
    所以我们便能够看到 push 方法被调用了两次，但其实如果我们把这里的手动调用放在方法的开始处，或者干脆就不使用 CCPoolManager::sharedPoolManager()->push(); ，对程序也没任何影响，这样从头到尾，只创建了一个自动释放池，而这里多创建的一个并没有多大的用处。 或者用处不甚明显，因为多创建一个释放池是有其效果的，效果具体体现在哪里，那就是 可以使调用 push() 方法之前的对象，多存活一帧。，因为 pop 方法只对当前释放池做了 clear 释放。为了方便起见，我们使用 Cocos2d-x 内存管理浅说 里面的方法观察每一帧的情况，看下面测试代码：
    //关键代码如下
  3. CCLog("updateindex:%d",updateCount);
  5. //在不同的帧做相关操作，以便观察
  6. if(updateCount==1){
  7. //创建一个自动管理对象
  8. layer=LSLayer::create();
  9. //创建一个新的自动释放池
  10. CCPoolManager::sharedPoolManager()->push();
  11. //再创建一个自动管理对象
  12. sprite=LSSprite::create();
  13. }elseif(updateCount==2){
  15. }if(updateCount==3){
  17. }
  19. CCLog("updateindex:%dend",0); background-color:inherit">///打印代码如下
  20. cocos2d-xdebuginfo[updateindex:1]
  21. //第一帧创建了两个自动管理对象
  22. cocos2d-xdebuginfo[LSLayer().()]
  23. cocos2d-xdebuginfo[LSSprite().()]
  24. cocos2d-xdebuginfo[updateindex:1end]
  25. //第一个过度帧只释放了sprite对象
  26. cocos2d-xdebuginfo[LSSprite().~()]
  27. cocos2d-xdebuginfo[updateindex:2]
  28. cocos2d-xdebuginfo[updateindex:2end]
  29. //第二个过度帧释放了layer对象
  30. cocos2d-xdebuginfo[LSLayer().~()]
  31. cocos2d-xdebuginfo[updateindex:3]
  32. cocos2d-xdebuginfo[updateindex:3end]
    33. 可以对比 sprite 和 layer 对象，两个对象被放在了不同的自动释放池之中。这就是 手动调用 push() 方法所能达到的效果，至于怎么利用这个特性，帮助我们完成特殊的功能？我想还是不用了，这会增加我们程序设计的 复杂度，在我看来，甚至想把，cocos2d-x 2.0.4 中那唯一一次调用的 push() 给删了，以保持简单（程序的第一次初始化“可能”会用到这个特性，不过目测是没有多大关系的了 : P），在这里只系统通过这个例子理解 自动释放池是怎样被管理的即可！
    从自动释放池管理 创建时期 对象，再到对释放池的管理，我们已经大概了解了一个对象的生命周期经历了哪些！ 下面简单说说 使用时期 的对象管理。
    树形结构的链式反应
    文中我们知道了，自动释放池的存在意义，在于对象 创建时期 的处理，而仅仅理解了自动释放池，对于我们使用 cocos2d-x 不够，远远不够！自动释放池只是解决对象初始化的问题，仅此而已，而要在整个使用过程中，相对的自动化管理，那么必须理解两个概念，树形结构 和 链式反应 （链式反应，不错的说法，就像原子弹爆炸一样，一传十，十传百 ：P）
    我们当前运行这一个场景，场景初始化，添加了很多层，层里面有其它的层或者精灵，而这些都是 CCNode 节点，以场景为根，形成一个树形结构，场景初始化之后（一帧之后），这些节点将完全 依附 (内部通过 retain) 在这个树形结构之上，全权交由树来管理，当我们 砍去一个树枝，或者将树 连根拔起，那么在它之上的“子节点”也会跟着去除(内部通过 release)，这便是链式反应。
    Cocos2d-x 内存管理的一种实现，此文这种实现的本质既是 强化这种 链式反应，也是解决内存可能出错的一个解决方案。如下（前文片段，具体详见前文）： 
    1. //方式一：那么我们的使用过程
    2.   
    3.   
    4. LUser*lu=LUser::create();
    5.   
    6.   
    7. lu->m_sSprite=CCSprite::create("a.png");
    8.   
    9.   
    10. //如果这里不retain则以后就用不到了
    11.   
    12.   
    13. lu->m_sSprite->retain();
    14.   
    15.   
    17.   
    18.   
    19. //方式二：使用方法
    20.   
    21.   
    22. LUser*lu=LUser::create();
    23.   
    24.   
    25. lu->m_sUserName="一叶";
    26.   
    27.   
    28. //这里的sprite会随着lu的消亡而消亡，不用管释放问题了
    29.   
    30.   
    31. lu->setSprite(CCSprite::create("a.png"));
    32.  
    33.
    我们看到方式二相比方式一的设计，它通过 setSprite 内部对 sprite 本身 retain，从而实现链式反应，而不是直接使用 lu->m_sSprite->retain();，这样的好处是，我只要想着释放 LUser，而不用考虑LUser 内部 sprite 的引用情况就行了。如此才能把 cocos2d-x 内存的自动管理特性完全发挥 ~
    而要实现这样管理的一个明显特征就是，隐藏 retain 和 release 操作 ~
    稍作总结
    关于 cocos2d-x 的内存管理从使用到原理，系列文章就到这里了！（三篇也算系列 = =!） 由表象到内部的思考探索过程，其实在 浅说 当中对 cocos2d-x 的使用，便已经能够知晓内部细节设计之一二，透过现象看本质！三篇文章包含了，使用浅说（简单的测试），一种防止内存泄漏的设计（加强链式反应），最后纵览 cocos2d-x 的内存管理框架，对 CCObject 的生命周期做了简单的说明，当然其中还是隐藏一些细节的，比如管理都是用 CCArray 来管理，但我们并没有对 CCArray 做介绍，它是如何添加元素，如何引用等。在任何时候我们只针对一个问题进行思考，那我们该把 CCArray 这样的辅助工具类放在何处，如果你了解当然最好，不过不了解，那便 存疑 ，然后对相应的问题，分而治之 ~

    猜你在找的Cocos2d-x相关文章

    创建自定义的Cocos2d-x场景
    操作步骤 1、创建cocos2d-x工程 2、新建 Scene1.cpp Scene1.h Scene1.h代码 #ifndef __SCE...
    给vs2010安装上cocos2d-x的模版
    开发环境：OS(WINDOWS 8.1 X64 企业版) cocos2d-x 2.2.1 vs2010 想给vs安装上cocos的模版，...
    Python创建Cocos2d-x 2.2方法
    把创建项目做成一个批处理，当创建项目时可以省时省力很多。 操作步骤 1、在 E:cocos2d-x-...
    cocos2dx 物理碰撞
    https://www.cnblogs.com/JiaoQing/p/3906780.html 四个响应函数 1 EventListenerPhysics...
    cocos2d-js 自定义事件监听派发
    转载于 http://www.cnblogs.com/kenkofox/p/3926797.html 熟悉js的dom事件或者flash事件的...
    cocos常用 实用 公共函数 lua代码
    公共资源加载，缓存retain；防止被自动销毁 2. 数字滚动递增；用于得奖后，总金币跳动增加...
    cocos creator box2d
    title Map 使用box2d var sfloors = this.tiledMap.getObjectGroup(‘Special_Floor‘).g...
    （转）让quick-cocos2d-x支持加密的plist文件
    前篇：quick-cocos2d-x图片资源加密 在前篇里面，我们实现了图片资源的加密，但还没有实现...
    （转）quick-cocos2d-x图片资源加密(续)
    摘要: 对在quick-cocos2d-x上实现的资源加密方法的补充 前篇： quick-cocos2d-x图片资源加...
    Cocos Creator 动态改变sprite图片
    首先将存放图片最外层文件夹命名为resources 　　 changeBj: function(){ 　　　　var url...
    iOSAndroidSwiftHybridCocos2d-xFlutterXcodeSilverlightcocoaCordova
    调试桥筛选栏假异步不会丢失AndPermissio权限申请抽屉式systemUI信号栏多行排列跨多行显示viewmode数据共享录制语音视频通话多行显示Studio3.5拉伸控件望远镜发动态走势图点赞控件显示牌冷启动v3签名v2签名v1签名本地html外接键盘流式标签