Cocos2d-x从入门到精通第七课《内存管理》

最新推荐文章于 2019-08-10 11:33:00 发布
最新推荐文章于 2019-08-10 11:33:00 发布
阅读量977 收藏
点赞数
分类专栏： cocos2d-x从入门到精通 文章标签： cocos2dx cocos2d-x 游戏开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wocacaaa/article/details/48137705
版权
课程视频地址:  http://edu.csdn.net/course/detail/1342/20992?auto_start=1

一． 什么是引用计数



        引用计数是现代内存管理中经常使用到的一个概念，它的基本思想是通过计数方式实现多个不同对象同时引用一个共享对象，具体地讲，当创建一个对象的实例并在堆上分配内存时，对象的引用计数为1，在其他对象中需要持有这个共享对象时，需要把共享对象的引用计数加1，当其他对象不再持有该共享对象时，共享对象的引用计数减1，当共享对象的引用计数变成0时，对象的内存会被立即释放。

         在Cocos2d-x中，则定义了retain，release和autorelease函数，分别用于增加计数、减少计数以及将一个对象交给自动释放池对象AutoreleasePool进行管理，由AutoreleasePool对象负责调用release函数。


二． Ref类



        Ref类实现了引用计数的功能，它是引擎代码中绝大多数其他类的父类，定义在CCRef.h中，实现在CCRef.cpp中。其实在CCRef.h文件中不止定义了Ref类，还定义了Clonable类、一系列的宏定义和类型定义，不过我们暂且将精力放在Ref类的解读上。Ref类使用私有成员变量_referenceCount保存计数值，并通过retain，release和autorelease函数实现增减计数值。下面我们来看一下Ref类的代码，从源码进行分析，代码如下： 

#ifndef __BASE_CCREF_H__
#define __BASE_CCREF_H__


#include "platform/CCPlatformMacros.h"
#include "base/ccConfig.h"
//内存泄露检测的开关
#define CC_REF_LEAK_DETECTION 0


NS_CC_BEGIN


class Ref;


/** Interface that defines how to clone an Ref */
//Clonable类定义了复制Ref类对象的规约，3.0以上版本建议使用clone函数，copy函数已属于废弃函数。
class CC_DLL Clonable
{
public:
    /** returns a copy of the Ref */
    //返回一个copy的Ref对象,纯虚函数，需要重写
    virtual Clonable* clone() const = 0;
    /**
     * @js NA
     * @lua NA
     */
    virtual ~Clonable() {};


    /** returns a copy of the Ref.
     * @deprecated Use clone() instead
     */
    //被废弃
    CC_DEPRECATED_ATTRIBUTE Ref* copy() const
    {
        // use "clone" instead
        CC_ASSERT(false);
        return nullptr;
    }
};


class CC_DLL Ref
{
public:
    
    //保留，引用计数+1
    void retain();


    //释放 , 引用计数-1
    void release();


    Ref* autorelease();


    //获得引用计数
    unsigned int getReferenceCount() const;


protected:
    
    Ref();


public:
    
    //析构
    virtual ~Ref();


protected:
    //引用的计数 , retain 会 +1  release会 -1
    unsigned int _referenceCount;
    //设定CAutoreleasePool为友元类，这是一个通过CCObject指针容器CCMutableArray来对CCObject实例对象的内存进行管理的类，CCMutableArray在加入CCObject时对其引用计数器加1，在移除CCObject时对其引用计数器减1。
    friend class AutoreleasePool;


#if CC_ENABLE_SCRIPT_BINDING
public:
    // 唯一ID
    unsigned int        _ID;
    /// Lua reference id
    // 在LUA脚本引擎中的访问标识ID.暂可不理会，待学习到LUA时再分析
    int                 _luaID;
    //swift脚本的对象指针，为支持swift脚本所定义的
    void* _scriptObject;
#endif


#if CC_USE_MEM_LEAK_DETECTION
public:
    //打印内存泄露的信息
    static void printLeaks();
#endif
};


class Node;
//动作类的回调函数
typedef void (Ref::*SEL_CallFunc)();
typedef void (Ref::*SEL_CallFuncN)(Node*);
typedef void (Ref::*SEL_CallFuncND)(Node*, void*);
typedef void (Ref::*SEL_CallFuncO)(Ref*);
//menuitem的回调函数
typedef void (Ref::*SEL_MenuHandler)(Ref*);
//schedule的回调函数
typedef void (Ref::*SEL_SCHEDULE)(float);


#define CC_CALLFUNC_SELECTOR(_SELECTOR) static_cast<cocos2d::SEL_CallFunc>(&_SELECTOR)
#define CC_CALLFUNCN_SELECTOR(_SELECTOR) static_cast<cocos2d::SEL_CallFuncN>(&_SELECTOR)
#define CC_CALLFUNCND_SELECTOR(_SELECTOR) static_cast<cocos2d::SEL_CallFuncND>(&_SELECTOR)
#define CC_CALLFUNCO_SELECTOR(_SELECTOR) static_cast<cocos2d::SEL_CallFuncO>(&_SELECTOR)
#define CC_MENU_SELECTOR(_SELECTOR) static_cast<cocos2d::SEL_MenuHandler>(&_SELECTOR)
#define CC_SCHEDULE_SELECTOR(_SELECTOR) static_cast<cocos2d::SEL_SCHEDULE>(&_SELECTOR)


// Deprecated
#define callfunc_selector(_SELECTOR) CC_CALLFUNC_SELECTOR(_SELECTOR)
#define callfuncN_selector(_SELECTOR) CC_CALLFUNCN_SELECTOR(_SELECTOR)
#define callfuncND_selector(_SELECTOR) CC_CALLFUNCND_SELECTOR(_SELECTOR)
#define callfuncO_selector(_SELECTOR) CC_CALLFUNCO_SELECTOR(_SELECTOR)
#define menu_selector(_SELECTOR) CC_MENU_SELECTOR(_SELECTOR)
#define schedule_selector(_SELECTOR) CC_SCHEDULE_SELECTOR(_SELECTOR)




// end of base_nodes group
/// @}


NS_CC_END


#endif // __BASE_CCREF_H__

           Ref将构造函数声明为保护类型，防止直接生成Ref对象，在构造函数的成员初始化列表中将引用计数值_referenceCount初始化为1。retain函数将_referenceCount加1，release函数则减1，autorelease函数则将对象托管给AutoreleasePool对象进行管理，具体实现代码如下： 


#include "base/CCRef.h"
#include "base/CCAutoreleasePool.h"
#include "base/ccMacros.h"
#include "base/CCScriptSupport.h"


#if CC_REF_LEAK_DETECTION
#include <algorithm>    // std::find
#endif


NS_CC_BEGIN


#if CC_REF_LEAK_DETECTION
static void trackRef(Ref* ref);
static void untrackRef(Ref* ref);
#endif


Ref::Ref()
: _referenceCount(1) // when the Ref is created, the reference count of it is 1
{
#if CC_ENABLE_SCRIPT_BINDING
    //定义一个静态UINT类型变量做为实例对象计数器，此值只会增长，不会减少，保证唯一。
    static unsigned int uObjectCount = 0;
    //脚本对象的Id
    _luaID = 0;
    //注意：所有由此CCObject类派生的子类也会拥有这个唯一的ID。它可以使我们通过唯一ID来获取相应的实例对象。
    _ID = ++uObjectCount;
    _scriptObject = nullptr;
#endif
    
#if CC_REF_LEAK_DETECTION
    //加入到保存Ref的list中
    trackRef(this);
#endif
}


Ref::~Ref()
{
#if CC_ENABLE_SCRIPT_BINDING
    // if the object is referenced by Lua engine, remove it
    //如果这个对象被lua脚本引擎引用了，就删除掉
    if (_luaID)
    {
        ScriptEngineManager::getInstance()->getScriptEngine()->removeScriptObjectByObject(this);
    }
    else
    {
        //获得脚本引擎
        ScriptEngineProtocol* pEngine = ScriptEngineManager::getInstance()->getScriptEngine();
        //如果这个脚本引擎是javascript
        if (pEngine != nullptr && pEngine->getScriptType() == kScriptTypeJavascript)
        {
            //删除对象
            pEngine->removeScriptObjectByObject(this);
        }
    }
#endif




#if CC_REF_LEAK_DETECTION
    //从保存Ref的list中删除
    if (_referenceCount != 0)
        untrackRef(this);
#endif
}


void Ref::retain()
{
    CCASSERT(_referenceCount > 0, "reference count should greater than 0");
    //引用计数+1
    ++_referenceCount;
}


void Ref::release()
{
    CCASSERT(_referenceCount > 0, "reference count should greater than 0");
    //引用计数-1
    --_referenceCount;


    if (_referenceCount == 0)
    {
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
        auto poolManager = PoolManager::getInstance();
        if (!poolManager->getCurrentPool()->isClearing() && poolManager->isObjectInPools(this))
        {
            
            CCASSERT(false, "The reference shouldn't be 0 because it is still in autorelease pool.");
        }
#endif


#if CC_REF_LEAK_DETECTION
        //从保存Ref*的list中删除
        untrackRef(this);
#endif
        delete this;
    }
}


Ref* Ref::autorelease()
{
    //调用内存管理器实例对象的addObject函数加入当前Ref实例对象的指针
    PoolManager::getInstance()->getCurrentPool()->addObject(this);
    return this;
}


unsigned int Ref::getReferenceCount() const
{
    //返回该对象的引用计数
    return _referenceCount;
}


#if CC_REF_LEAK_DETECTION
//创建保存Ref对象的list
static std::list<Ref*> __refAllocationList;


void Ref::printLeaks()
{
    // Dump Ref object memory leaks
    //如果是空的不做处理
    if (__refAllocationList.empty())
    {
        log("[memory] All Ref objects successfully cleaned up (no leaks detected).\n");
    }
    else    //不为空
    {
        //打印__refAllocationList的长度
        log("[memory] WARNING: %d Ref objects still active in memory.\n", (int)__refAllocationList.size());
        //循环打印Ref对象的信息
        for (const auto& ref : __refAllocationList)
        {
            CC_ASSERT(ref);
            const char* type = typeid(*ref).name();
            log("[memory] LEAK: Ref object '%s' still active with reference count %d.\n", (type ? type : ""), ref->getReferenceCount());
        }
    }
}


static void trackRef(Ref* ref)
{
    CCASSERT(ref, "Invalid parameter, ref should not be null!");


    // Create memory allocation record.
    //把ref对象添加到list中
    __refAllocationList.push_back(ref);
}


static void untrackRef(Ref* ref)
{
    //获得ref的迭代器
    auto iter = std::find(__refAllocationList.begin(), __refAllocationList.end(), ref);
    //如果没找到
    if (iter == __refAllocationList.end())
    {
        log("[memory] CORRUPTION: Attempting to free (%s) with invalid ref tracking record.\n", typeid(*ref).name());
        return;
    }
    //从list中释放ref
    __refAllocationList.erase(iter);
}


#endif // #if CC_USE_MEM_LEAK_DETECTION




NS_CC_END




           我们看到Ref其实真的很单纯，它主要就是有两个功能，一个是提供引用计数增减的方法。一个是通过引用计数交给内存管理器进行内存管理。下面我们来重点看一下autorelease函数的意义，顾名思义，“自动释放”。也就是说调用此函数则当前CCObject实例对象不需要用户在外部去手动调用release进行内存的释放工作。我们已经知道它通过引用计数来处理在什么时候内存释放。Cocos2d-x是怎么做到的呢？

         在autorelease函数中有这么一句

//调用内存管理器实例对象的addObject函数加入当前Ref实例对象的指针

PoolManager::getInstance()->getCurrentPool()->addObject(this);

        PoolManager代表了内存管理器。此句调用PoolManager的实例对象获得AutoreleasePool对象，然后调用AutoreleasePool的addObject函数将当前Ref对象的指针交给内存管理器。下面我们就来看看这辆类的实现。


三. PoolManager和AutoreleasePool



          内存管理器主要用来管理Cocos2d-x内存自动释放的，在Cocos2d-x的内存管理中起到了重要的作用，下面我们通过AutorelesePool和PoolManager两个类的代码来分析一下Ccocos2d-x内存管理的原理。首先我们来看一下CCAutoreleasePool.h: 


#ifndef __AUTORELEASEPOOL_H__
#define __AUTORELEASEPOOL_H__


#include <vector>
#include <string>
#include "base/CCRef.h"


NS_CC_BEGIN


class CC_DLL AutoreleasePool
{
public:
    //构造
    AutoreleasePool();
    //通过name进行构造
    AutoreleasePool(const std::string &name);
    
    /**
     * @js NA
     * @lua NA
     */
    //析构
    ~AutoreleasePool();
    //添加Ref
    void addObject(Ref *object);


    //清除
    void clear();
    
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
    //判断是否执行了clear()操作
    bool isClearing() const { return _isClearing; };
#endif
    
    //检查是否有object对象
    bool contains(Ref* object) const;
    //打印删除的对象的地址
    void dump();
    
private:
    //ref对象保存
    std::vector<Ref*> _managedObjectArray;
    //autoreleasepool的名字
    std::string _name;
    
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
   
    //是否执行清除操作的
    bool _isClearing;
#endif
};


class CC_DLL PoolManager
{
public:
  
    CC_DEPRECATED_ATTRIBUTE static PoolManager* sharedPoolManager() { return getInstance(); }
    //获得poolManager的实例
    static PoolManager* getInstance();
    
    
    CC_DEPRECATED_ATTRIBUTE static void purgePoolManager() { destroyInstance(); }
    //销毁
    static void destroyInstance();
    
    
    //获得当前的autoreleasepooll
    AutoreleasePool *getCurrentPool() const;
    //判断obj是否在autoreleasepool
    bool isObjectInPools(Ref* obj) const;


    /**
     * @js NA
     * @lua NA
     */
    //把AutoreleasePool设置成友元类
    friend class AutoreleasePool;
    
private:
    //构造
    PoolManager();
    //析构
    ~PoolManager();
    //加入
    void push(AutoreleasePool *pool);
    //弹出
    void pop();
    //poolmanager的实例
    static PoolManager* s_singleInstance;
    //保存AutoreleasePool对象的vector
    std::vector<AutoreleasePool*> _releasePoolStack;
};


// end of base_nodes group
/// @}


NS_CC_END


#endif //__AUTORELEASEPOOL_H__



            从CCAutoreleasePool.h中可以看到声明了两个类，分别是AutoreleasePool，PoolManager，AutoreleasePool主要用来管理Ref对象，而PoolManager主要用来管理AutoreleasePool，具体这两个类是怎么实现的呢，我们来看看CCAutoreleasePool.cpp的代码： 

#include "base/CCAutoreleasePool.h"
#include "base/ccMacros.h"


NS_CC_BEGIN


AutoreleasePool::AutoreleasePool()
: _name("") //设置名字为""
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
, _isClearing(false) //设置_isClearing为false
#endif
{
    //申请vector的size增加150
    _managedObjectArray.reserve(150);
    //把该autoreleasePool添加到管类类
    PoolManager::getInstance()->push(this);
}


AutoreleasePool::AutoreleasePool(const std::string &name)
: _name(name)   //设置名称
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
, _isClearing(false)    //设置_isClearing
#endif
{
    //申请vector的size增加150
    _managedObjectArray.reserve(150);
    //把该autoreleasePool添加到管类类
    PoolManager::getInstance()->push(this);
}


AutoreleasePool::~AutoreleasePool()
{
    CCLOGINFO("deallocing AutoreleasePool: %p", this);
    //清除
    clear();
    //弹出
    PoolManager::getInstance()->pop();
}


void AutoreleasePool::addObject(Ref* object)
{
    //把object添加到_managedObjectArray
    _managedObjectArray.push_back(object);
}


void AutoreleasePool::clear()
{
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
    _isClearing = true; //设置为执行了清空操作
#endif
    //遍历_managedObjectArray所有的Ref
    for (const auto &obj : _managedObjectArray)
    {
        //调用obj的release，对obj的引用计数-1
        obj->release();
    }
    //清空_managedObjectArray
    _managedObjectArray.clear();
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
    _isClearing = false;  //设置为未执行了清空操作
#endif
}


bool AutoreleasePool::contains(Ref* object) const
{
    //遍历_managedObjectArray
    for (const auto& obj : _managedObjectArray)
    {
        //如果相等
        if (obj == object)
            //返回true，表示_managedObjectArray中有该对象
            return true;
    }
    return false;
}


void AutoreleasePool::dump()
{
    //打印_managedObjectArray的size，用于调试
    CCLOG("autorelease pool: %s, number of managed object %d\n", _name.c_str(), static_cast<int>(_managedObjectArray.size()));
    CCLOG("%20s%20s%20s", "Object pointer", "Object id", "reference count");
    for (const auto &obj : _managedObjectArray)
    {
        CC_UNUSED_PARAM(obj);
        //打印对象的引用计数
        CCLOG("%20p%20u\n", obj, obj->getReferenceCount());
    }
}




//--------------------------------------------------------------------
//
// PoolManager
//
//--------------------------------------------------------------------
//设置PoolManager的单例对象为nullptr
PoolManager* PoolManager::s_singleInstance = nullptr;


PoolManager* PoolManager::getInstance()
{
    //判断是否存在s_singleInstance
    if (s_singleInstance == nullptr)
    {
        //如果s_singleInstance为nullptr，new一个PoolManager
        s_singleInstance = new (std::nothrow) PoolManager();
        // Add the first auto release pool
        //new一个AutoreleasePoll并取名字为cocos2d autorelease pool
        new AutoreleasePool("cocos2d autorelease pool");
    }
    return s_singleInstance;
}


void PoolManager::destroyInstance()
{
    //删除s_singleInstance
    delete s_singleInstance;
    s_singleInstance = nullptr;
}


PoolManager::PoolManager()
{
    //增加_releasePoolStack容器的size
    _releasePoolStack.reserve(10);
}


PoolManager::~PoolManager()
{
    CCLOGINFO("deallocing PoolManager: %p", this);
    
    while (!_releasePoolStack.empty())
    {
        //获得最后一个AutoreleasePool
        AutoreleasePool* pool = _releasePoolStack.back();
        //删除
        delete pool;
    }
}




AutoreleasePool* PoolManager::getCurrentPool() const
{
    //获得当前的AutoreleasePool
    return _releasePoolStack.back();
}


bool PoolManager::isObjectInPools(Ref* obj) const
{
    //遍历所有的AutoreleasePool
    for (const auto& pool : _releasePoolStack)
    {
        //如果pool中存在obj，返回true
        if (pool->contains(obj))
            return true;
    }
    return false;
}


void PoolManager::push(AutoreleasePool *pool)
{
    //把AutoreleasePool添加到_releasePoolStack
    _releasePoolStack.push_back(pool);
}


void PoolManager::pop()
{
    CC_ASSERT(!_releasePoolStack.empty());
    //删除当前的AutoreleasePool
    _releasePoolStack.pop_back();
}


NS_CC_END



       看完上面的代码，大家是不是有点晕啊，下面我来总结一下，首先Autorelease提供了_managedObjectArray的vector容器来保存Ref对象，通过对_managedObjectArray的添加，删除来实现Ref的添加和删除。
通过PoolManager来管理AutoreleasePool,通过PoolManager的pop,push来完成对AutoreleasePool增减，通过clear来实现AutoReleasePool的成员Ref的删除。
看完解释你可能还有一个疑问，说了这么多，那么Cocos2d-x是如果通过调用PoolMananger的相关方法来管理内存的呢，带着这个疑问我们来看看下一个知识点。


四.Cocos2d-x内存管理的运行原理



          还记得我们之前讲的渲染流程吗，从Application类的run()方法开始，一直完成了整个渲染流程的介绍，那么内存管理的入口在哪儿了，聪明的你可能已经猜到了，没错也是在Application类的run()方法，下面我们通过Cocos2d-x的源码来看一下如何调用到PoolManager的，首先打开Application的run()方法，在run()方法中我们可以看到如下代码：
director->mainLoop();
该代码调用了mainLoop()方法，该方法就是Cocos2d-x的住循环的方法，每帧都会被调用一次。进入该方法，我们可以看到如下代码：
PoolManager::getInstance()->getCurrentPool()->clear();
在mainLoop中调用了PoolManager获得当前的AutoreleasePool的clear()方法中调用存放在AutoreleasePool中的所有对象release()方法，在release()中首先对Ref对象的引用计数-1，如果引用计数为0那么就delete掉该对象。
看完上面说的一大堆东东，大家是不是已经有点晕了，下面我们通过一个实例来看看:
    //创建一个Node,create方法会对node的引用计数+1，并在create方法中调用了node的autorelease方法，把它加入到了自动释放池
    Node* node = Node::create();
    //把Node添加到Layer上，addChild操作会对node的引用计数+1
this->addChild(node);
            通过代码注释我们可以得出，现在node的引用计数为2，接着随着在mainLoop的
PoolManager::getInstance()->getCurrentPool()->clear();
的调用，我们对所有的Ref的引用计数进行了-1操作，当然我们的node对象也执行了改操作，那么我们的node对象的引用计数就变成了 1，接着对node进行了addchild的操作，在addchild中其实对要添加的对象进行了retain操作，所以addChil操作之后node的引用计数变成了2.然后随着在mainloop中调用 AutoreleasePool的clear()方法之后，node的引用计数就减一了，同时把保存该node的_managedObjectArray进行了clear()操作，也是说把node从AutoreleasePool的managedObjectArray中进行了清除操作，所以在mainloop中在下一次执行AutoreleasePool的clear()的时候不会再次对node进行release操作，所以node的引用计数会一直为1，只用当调用node的remove()方法的时候，才会对node的进行release操作，release操作首先对其引用计数-1，那么node的引用计数就变成了0，然后就会delete掉改node对象，也就完成了node的自动释放释放。


        可能大家会感觉有点绕，但是通过配合源码来仔细研读这段话，相信让你对Cocos2d-x的内存管理有个新的认识的。


五.Cocos2d-x内存管理总结



           本节课主要讲解了Cocos2d-x内存管理，我们通过源码的解析了解了Cocos2d-x内存管理的原理，并通过node的创建的例子来学习了内存管理。Cocos2d-x内存管理是一个比较难的概念，在平时工作中只有理解了Cocos2d-x的内存管理的原理，才能更好的使用它，因为我们的每个Cocos2d-x的内置类都是通过它来进行管理的。


六.作业：



            仔细研读Ref,AutoreleasePool,PoolManager三个类的源码。
再见孙悟空csb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cocos2d-x从入门到精通经典视频
07-23
教程名称：       cocos2d-x从入门到精通经典视频 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
Cocos2d-Lua-社区：基于Cocos2d-x 4.0，打造易用稳定的Cocos2d-x lua引擎
02-03
Cocos2d-Lua社区 Cocos2d-Lua-Community是Cocos2d-x 4.0的改进，并且易于使用Lua游戏引擎。 它是与Quick-Cocos2dx-Community v3.7.x兼容的Lua“框架”。 得到帮助 QQ群： 社区版千人群（1群）号：361920466 社区版2群：138934064 特征 无需安装，无需环境设置。 OpenAL音频输出引擎，专为Lua设计。 集成更多第三方Lua库：protobuf，lsqlite3等。 重构TMX运行时，支持Tiled Map Editor 1.2+。 Spine运行时更新到3.8。 支持FairyGUI。
cocos2d-x-3rd-party-libs-src:cocos2d-x的依存关系
05-28
cocos2d-x第三方库 该存储库包含与cocos2d-x捆绑在一起的第三方库（二进制）的源代码。 对于cocos2d-x开发人员和/或想要： 生成特定库的更新版本（例如：将libpng 1.6.2升级到1.6.14） 将cocos2d-x移植到其他平台（例如：将其移植到Android ARM64或Tizen等） 生成所有第3方库的DEBUG版本 笔记： 我们使用MacOSX为iOS，Android，Mac和Tizen构建所有静态库。 我们使用Ubuntu构建Linux的所有静态库。 尚不支持Windows 其他配置未经测试。 没有对从Linux或Windows机器编译Android二进制文件进行测试，因此我们不知道它是否有效。 下载 $ git clone https://github.com/cocos2d/cocos2d-x-3rd-party-libs-src.
Cocos2d-x实战：JS卷——Cocos2d-JS开发
07-23
资源名称：Cocos2d-x实战：JS卷——Cocos2d-JS开发内容简介：本书是介绍Cocos2d-x游戏编程和开发技术书籍，介绍了使用Cocos2d-JS中核心类、瓦片地图、物理引擎、音乐音效、数据持久化、网络通信、性能优化、多平台发布、程序代码管理、两大应用商店发布产品。全书分为6：基础篇、进阶篇、数据与网络篇、设计与优化篇、多平台发布篇和实战篇。基础篇包括第2章～第8章，Cocos2d- 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
Cocos2d-x源码啃食第一谈
protoss_penguin的博客
10-10 752
第一篇博客，先鼓个掌纪念一下，啪啪啪啪。。。 正文开始。 从 CCRef.h 开始
cocos2d-x的回调函数
小嘟永远的大嘟
03-12 905
我们知道在cocos2d-x中指定回调函数时都使用 *selector 的形式，比如我们要知道定时器schedule的回调函数，则使用schedule_selector，要指定按钮相关的回调则使用callfunc_selector等。 那么我们看下常用的selector有哪些，如下： typedef void (Ref::*SEL_CallFunc)(); typedef void (R
COCOS学习笔记--内存管理(一)-引用计数和Ref类的讲解
RapdoZoroの博客
01-04 6252
最近在看曹世博老师关于cocos引擎的学习教程，打算重新再系统梳理一下cocos相关的知识结构，学习之余把自己的一些收获和理解总结记录下来，方便日后自己回顾并同时希望本笔记可以对各位cocos学习者有所帮助，相关技术上博主理解如有偏颇，还请指正： 视频地址：http://edu.csdn.net/course/detail/1342/20985?auto_start=1 1.引用计
【Cocos2d-x源码分析】 Cocos2d-x内存管理解析
上善若水，人淡如菊
12-15 1995
在使用Cocos2dx时，当我们需要某个对象实例，只要简单地调用相应静态create方法就可以得到该对象实例，使用完之后我们也无需手动地释放该对象内存而没有产生内存泄露问题。你知道其中的原理是什么么？今天我带着这个疑问，通过阅读Cocos2d-x的源码来探讨一下其内存管理的方法。
COCOS2DX引擎深入二————内存管理
宇智波_呵呵的专栏
11-14 655
辅导费
Cocos2d-x的内存管理总结
09-04
主要介绍了Cocos2d-x的内存管理总结,详解探讨了手工对象内存管理、自动对象内存管理、自动释放的时机等问题,需要的朋友可以参考下
Cocos2d-x从入门到精通第六课《自定义绘制》
wocacaaa的专栏
08-31 1546
一．自定义绘制 一个图形引擎，总是由构建点，线，面的绘制功能写起来的。点，线，面。构成了最初的图形基础。所以说，掌握点，线，面是掌握引擎的基础。 Cocos2d-x 2.0的时候开始有的使用DrawPrimitives命名空间下的相关函数进行绘制。Cocos2d-x3.0版本开始有的DrawNode类提供的相关方法来绘制。今天的课程主要讲解使用最新的方法进行绘制。   二．图形绘制 获得
cocos2d-x跨android&ios平台开发入门教程
在路上
10-23 6494
（译）cocos2d-x跨android&ios平台开发入门教程 免责申明（必读！）：本博客提供的所有教程的翻译原稿均来自于互联网，仅供学习交流之用，切勿进行商业传播。同时，转载时不要移除本申明。如产生任何纠纷，均与本博客所有人、发表该翻译稿之人无任何关系。谢谢合作！ 原文链接地址：http://www.raywenderlich.com/11283/cocos2d-x-for-ios-and
Cocos2d-x视频教程
weixin_30514745的博客
08-10 477
目录 1. 我的技术专栏 2. 相关推荐 3. 下载链接 4. cocos2d-xx Lua+JS+C++教学视频 5. 杨丰盛Cocos2D-X游戏课程 6. 【Cocos2d-x】塔防游戏开发实战 7. Cocos2d-x网络编程教学视...
Cocos从入门到精通--《创建第一个项目：HelloWorld》
wocacaaa的专栏
08-20 4652
cocos3.7版本创建第一个工程，对工程目录的变化进行分析，并阐述了这样做的利弊。
Cocos从入门到精通--《Cocos引擎在Windows平台上的搭建》
wocacaaa的专栏
08-19 2727
cocos引擎在Windows上的环境配置
Cocos2d-x从入门到精通第12课《layer的创建与使用》
wocacaaa的专栏
09-06 2384
Cocos2d-x Layer的创建与使用
Cocos2d-x从入门到精通第18节课《 Cocos Studio编辑序列帧及序列帧的使用 》
wocacaaa的专栏
09-21 2239
创建项目 新建一个项目（具体怎么创建，请参阅我们之前的课程），点击完成之后会自动打开CocosStudio。 使用CocosStudio创建帧动画 导入资源： 右键单击CocosStudio的工程文件，选择“导入资源”，然后找到资源存放的文件夹，选择图片，进行导入。 添加一个Sprite 选择“精灵”的选项卡，把它拖入到场景中。 设置记
Cocos2d-x从入门到精通第11课《锚点概念的理解》
wocacaaa的专栏
09-06 1836
Cocos2d-x锚点讲解
cocos2d-x csdn
最新发布
01-20
Cocos2d-x是一个开源的跨平台游戏开发框架，是基于Cocoa2d-iphone移植过来的。它提供了一套完整的游戏开发工具和引擎，可以让开发者在不同平台上开发与发布游戏。Cocos2d-x的CSND是指CSDN（中国软件开发网）上关于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值