Cocos2d-x2.0 粒子系统深入分析三部曲(二)

来源：互联网发布：卓智网络锐捷编辑：程序博客网时间：2024/06/05 06:38

Cocos2d-x2.0 粒子系统深入分析三部曲(二)

分类： Cocos2d-x学习2013-02-02 10:08 10604人阅读评论(6) 收藏举报

目录(?)[+]

[Cocos2d-x相关教程来源于红孩儿的游戏编程之路CSDN博客地址：http://blog.csdn.net/honghaier]

红孩儿Cocos2d-X学习园地QQ2群：44208467加群写：Cocos2d-x
红孩儿Cocos2d-X学习园地QQ群：249941957加群写：Cocos2d-x

Cocos2d-x2.0 粒子系统深入分析三部曲(二)

另：本章所用Cocos2d-x版本为:

cocos2d-2.0-x-2.0.2@ Aug 30 2012

http://cn.cocos2d-x.org/download

上一节我们了解了粒子系统的原理，也学习了Cocos2d-x中的两个有关粒子系统的类：

（1） CCParticleSystem :粒子系统的基类，提供对粒子的创建和更新管理。

（2） CCParticleBatchNode:粒子系统的批次结点，用于将使用相同纹理的粒子系统进行同批次渲染优化处理。

在学习CCParticleSystem时，我们留下了一些疑问，什么时候调用setBatchNode？以及做为基类，CCParticleSystem提供了两个供子类重载的纯虚函数postStep()和updateQuadWithParticle，它们的具体用法是什么？我们仍然有一些迷茫。

我们今天来了解一下CCParticleSystemQuad，这个类是CCParticleSystem的子类。它将解开我们的这些疑惑。

打开CCParticleSystemQuad.h:

[cpp] view plaincopy
class CC_DLL CCParticleSystemQuad : public CCParticleSystem  
{  
protected:  
       //如果当前粒子系统未使用批次结点，则需要为粒子系统创建单独的顶点缓冲及索引缓冲以及OPENGL进行渲染的一些相关物件。  
    ccV3F_C4B_T2F_Quad    *m_pQuads;    // OPENGL渲染图形所用的四边形顶点缓冲。  
    GLushort            *m_pIndices;    // OPENGL渲染图形所用的索引缓冲。  
//这里有宏判断当前OPENGL版本是否支持使用VAO处理顶点缓冲（VAO是什么？这个问题问的好，VAO是OPENGL3.X以上引入的新特性，VBO是Vertex Buffer Object, VAO是Vertex Array Object。 VAO是OpenGL 3.0以后才引入的新东西，但是在2.0版本中做为扩展接口。VBO其实就是显卡中的显存，为了提高渲染速度，可以将要绘制的顶点数据缓存在显存中，这样就不需要将要绘制的顶点数据重复从CPU发送到GPU, 浪费带宽资源。而VAO则是一个容器，可以包括多个VBO, 它类似于以前的call list, 由于它进一步将VBO容于其中，所以绘制效率将在VBO的基础上更进一步。）  
#if CC_TEXTURE_ATLAS_USE_VAO  
    GLuint                m_uVAOname;           //VAO的句柄。  
#endif  
       GLuint                m_pBuffersVBO[2];  //VBO的两个句柄，第一个句柄对应顶点缓冲，第二个句柄对应索引缓冲。  
public:  
       //构造函数。  
    CCParticleSystemQuad();  
       //析构函数。  
    virtual ~CCParticleSystemQuad();  
  
    //创建函数，参为为PLIST，内部调用create实现。  
    CC_DEPRECATED_ATTRIBUTE static CCParticleSystemQuad * particleWithFile(const char *plistFile);  
  
    //上面函数的create实现。  
    static CCParticleSystemQuad * create(const char *plistFile);  
  
    //初始化索引缓冲。  
    void setupIndices();  
  
    //初始化方理坐标。  
    void initTexCoordsWithRect(const CCRect& rect);  
  
    //设置显示一个精灵帧。  
    void setDisplayFrame(CCSpriteFrame *spriteFrame);  
  
    //设置使用纹理对象上指定的矩形图像区域做为粒子系统的贴图。  
    void setTextureWithRect(CCTexture2D *texture, const CCRect& rect);  
    // 重载基类粒子系统的相应函数。  
       //初始化粒子数量。  
    virtual bool initWithTotalParticles(unsigned int numberOfParticles);  
       //设置所用的纹理对象指针  
    virtual void setTexture(CCTexture2D* texture);  
       //上一篇留下的疑问，虽然明显是更新粒子顶点缓冲中的位置数据。但上一篇为什么没有实现？  
    virtual void updateQuadWithParticle(tCCParticle* particle, const CCPoint& newPosition);  
       //上一篇留下的疑问，不知道是做什么，咱们到CPP中看吧。  
    virtual void postStep();  
       //渲染处理。  
    virtual void draw();  
       //设置批次结点。  
    virtual void setBatchNode(CCParticleBatchNode* batchNode);  
       //设置总的粒子数量。  
    virtual void setTotalParticles(unsigned int tp);  
    //监听响应当前结点的EVNET_COME_TO_FOREGROUND事件的回调函数。  
    void listenBackToForeground(CCObject *obj);  
  
    //创建一个当前实例结点，内部调用create实现。  
    CC_DEPRECATED_ATTRIBUTE static CCParticleSystemQuad * node();  
       //上面的create实现。  
    static CCParticleSystemQuad * create();  
private:  
        //如果使用VAO  
#if CC_TEXTURE_ATLAS_USE_VAO  
       //初始化VAO和VBO  
    void setupVBOandVAO();  
#else  
    //初始化VBO  
    void setupVBO();  
#endif  
       //申请内存。  
    bool allocMemory();  
};  

对应的实现：

[cpp] view plaincopy
//重载粒子系统基类的初始化函数，创建相应数量的粒子。  
bool CCParticleSystemQuad::initWithTotalParticles(unsigned int numberOfParticles)  
{  
    //调用基类的相应函数。  
    if( CCParticleSystem::initWithTotalParticles(numberOfParticles) )   
    {  
        // 创建顶点和索引缓冲，如果失败释放并返回。  
        if( ! this->allocMemory() ) {  
            this->release();  
            return false;  
        }  
        //填充索引缓冲。  
        setupIndices();  
        //如果当前OPENGL版本支持VAO，就创建VAO，如果不支持，只创建VBO。  
#if CC_TEXTURE_ATLAS_USE_VAO  
        setupVBOandVAO();  
#else  
        setupVBO();  
#endif  
//设置使用顶点格式为“位置+纹理+顶点色”的顶点格式组合。  
setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTextureColor));  
  
//告诉通知中心，注册函数listenBackToForeground用来响应当前结点的EVNET_COME_TO_FOREGROUND事件。这个事件的意义是程序将由后面返回到前台。这个事件响应时可做资源的重新载入。  
  
CCNotificationCenter::sharedNotificationCenter()->addObserver(this,  
                                                                      callfuncO_selector(CCParticleSystemQuad::listenBackToForeground),  
                                                                      EVNET_COME_TO_FOREGROUND,  
                                                                      NULL);  
          
        return true;  
    }  
    return false;  
}  
//构造函数。  
CCParticleSystemQuad::CCParticleSystemQuad()  
:m_pQuads(NULL)  
,m_pIndices(NULL)  
#if CC_TEXTURE_ATLAS_USE_VAO  
,m_uVAOname(0)  
#endif  
{  
    memset(m_pBuffersVBO, 0, sizeof(m_pBuffersVBO));  
}  
//析构函数。  
CCParticleSystemQuad::~CCParticleSystemQuad()  
{  
    //对所创建的顶点缓冲，索引缓冲，以及VBO,VA0进行释放。  
    if (NULL == m_pBatchNode)  
    {  
        CC_SAFE_FREE(m_pQuads);  
        CC_SAFE_FREE(m_pIndices);  
        glDeleteBuffers(2, &m_pBuffersVBO[0]);  
#if CC_TEXTURE_ATLAS_USE_VAO  
        glDeleteVertexArrays(1, &m_uVAOname);  
#endif  
    }  
      
//注销对通知管理器注册的相应事件的响应处理函数。  
CCNotificationCenter::sharedNotificationCenter()->removeObserver(this, EVNET_COME_TO_FOREGROUND);  
}  
  
// 静态创建函数。由PLIST文件创建相应的当前实例对象，内部调用create实现。  
CCParticleSystemQuad * CCParticleSystemQuad::particleWithFile(const char *plistFile)  
{  
    return CCParticleSystemQuad::create(plistFile);  
}  
//上面的create实现。  
CCParticleSystemQuad * CCParticleSystemQuad::create(const char *plistFile)  
{  
    //创建一个CCParticleSystemQuad实例对象，进行初始化后交由内存管理器进行引用计数器的管理。  
    CCParticleSystemQuad *pRet = new CCParticleSystemQuad();  
    if (pRet && pRet->initWithFile(plistFile))  
    {  
        pRet->autorelease();  
        return pRet;  
    }  
    //如果失败，删除并置空，返回NULL。  
    CC_SAFE_DELETE(pRet);  
    return pRet;  
}  
  
// 初始化纹理坐标。  
void CCParticleSystemQuad::initTexCoordsWithRect(const CCRect& pointRect)  
{  
    // 创建出相应的矩形。  
    CCRect rect = CCRectMake(  
        pointRect.origin.x * CC_CONTENT_SCALE_FACTOR(),  
        pointRect.origin.y * CC_CONTENT_SCALE_FACTOR(),  
        pointRect.size.width * CC_CONTENT_SCALE_FACTOR(),  
        pointRect.size.height * CC_CONTENT_SCALE_FACTOR());  
    //默认使用的是批次结点，以批次结点的纹理对设置所用的图像区域矩形宽高。  
    GLfloat wide = (GLfloat) pointRect.size.width;  
    GLfloat high = (GLfloat) pointRect.size.height;  
    //如果使用单纹理对象，取得纹理的宽高。  
    if (m_pTexture)  
    {  
        wide = (GLfloat)m_pTexture->getPixelsWide();  
        high = (GLfloat)m_pTexture->getPixelsHigh();  
    }  
    //此宏是为了解决精灵边缘黑线而做的纹理坐标的微调。  
#if CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL  
    GLfloat left = (rect.origin.x*2+1) / (wide*2);  
    GLfloat bottom = (rect.origin.y*2+1) / (high*2);  
    GLfloat right = left + (rect.size.width*2-2) / (wide*2);  
    GLfloat top = bottom + (rect.size.height*2-2) / (high*2);  
#else  
    GLfloat left = rect.origin.x / wide;  
    GLfloat bottom = rect.origin.y / high;  
    GLfloat right = left + rect.size.width / wide;  
    GLfloat top = bottom + rect.size.height / high;  
#endif   
  
    //将top与bottom交换一下，因为在Cococs2d-x中坐标系Y轴是向上为正，这里处理一下后面可以做为顶点位置数据。  
    CC_SWAP( top, bottom, float);  
    //根据是否使用批次结点来取得相应的矩形顶点缓冲数组。  
    ccV3F_C4B_T2F_Quad *quads = NULL;  
    unsigned int start = 0, end = 0;  
    if (m_pBatchNode)  
    {   //如果使用批次结点，这里取得批次结点中所有粒子所对应的矩形顶点数组。  
        quads = m_pBatchNode->getTextureAtlas()->getQuads();  
        //取得起始和结束的粒子所对应的矩形索引。  
        start = m_uAtlasIndex;  
        end = m_uAtlasIndex + m_uTotalParticles;  
    }  
    else  
    {   //如果使用单纹理对象，则起始矩形索引就是0，结束矩形索引就是最大粒子数量。  
        quads = m_pQuads;  
        start = 0;  
        end = m_uTotalParticles;  
    }  
    //遍历所有的矩形顶点。  
    for(unsigned int i=start; i<end; i++)   
    {  
        // 设置四个顶点的纹理坐标。  
        quads[i].bl.texCoords.u = left;  
        quads[i].bl.texCoords.v = bottom;  
        quads[i].br.texCoords.u = right;  
        quads[i].br.texCoords.v = bottom;  
        quads[i].tl.texCoords.u = left;  
        quads[i].tl.texCoords.v = top;  
        quads[i].tr.texCoords.u = right;  
        quads[i].tr.texCoords.v = top;  
    }  
}  
//设置使用纹理对象上指定的矩形图像区域做为粒子系统的贴图。  
void CCParticleSystemQuad::setTextureWithRect(CCTexture2D *texture, const CCRect& rect)  
{  
    // 如果当前尚无纹理对或者使用的纹理与参数指定的纹理不同。则设置使用参数指定的纹理。  
    if( !m_pTexture || texture->getName() != m_pTexture->getName() )  
    {  
        CCParticleSystem::setTexture(texture);  
    }  
    //设置指定的矩形图像区域做为贴图计算粒子系统的纹理坐标.  
    this->initTexCoordsWithRect(rect);  
}  
//设置使用的纹理对象。  
void CCParticleSystemQuad::setTexture(CCTexture2D* texture)  
{  
    //取得纹理的大小。  
    const CCSize& s = texture->getContentSize();  
    //设置使用纹理对象上指定的矩形图像区域做为粒子系统的贴图。      
    this->setTextureWithRect(texture, CCRectMake(0, 0, s.width, s.height));  
}  
//设置使用精灵帧中的纹理。  
void CCParticleSystemQuad::setDisplayFrame(CCSpriteFrame *spriteFrame)  
{  
    //有效性判断。  
    CCAssert(spriteFrame->getOffsetInPixels().equals(CCPointZero),   
             "QuadParticle only supports SpriteFrames with no offsets");  
  
    // 如果当前尚无纹理对或者使用的纹理与参数指定的纹理不同。则设置使用参数指定的纹理。  
    if ( !m_pTexture || spriteFrame->getTexture()->getName() != m_pTexture->getName())  
    {  
        //设置使用精灵帧中的纹理.  
        this->setTexture(spriteFrame->getTexture());  
    }  
}  
//填充索引缓冲。  
void CCParticleSystemQuad::setupIndices()  
{  
    //遍历粒子数目计算索引缓冲值。  
    for(unsigned int i = 0; i < m_uTotalParticles; ++i)  
    {  
        const unsigned int i6 = i*6;  
        const unsigned int i4 = i*4;  
        m_pIndices[i6+0] = (GLushort) i4+0;  
        m_pIndices[i6+1] = (GLushort) i4+1;  
        m_pIndices[i6+2] = (GLushort) i4+2;  
  
        m_pIndices[i6+5] = (GLushort) i4+1;  
        m_pIndices[i6+4] = (GLushort) i4+2;  
        m_pIndices[i6+3] = (GLushort) i4+3;  
    }  
}  
//更新指定粒子的顶点缓冲中的位置数据。  
void CCParticleSystemQuad::updateQuadWithParticle(tCCParticle* particle, const CCPoint& newPosition)  
{  
    //定义临时指针变量用于取得相应的粒子所对应的矩形顶点缓冲。  
    ccV3F_C4B_T2F_Quad *quad;  
    //如果使用了批次结点。  
    if (m_pBatchNode)  
    {  
        //取得批次结点中对应的矩形顶点缓冲数组指针。  
        ccV3F_C4B_T2F_Quad *batchQuads = m_pBatchNode->getTextureAtlas()->getQuads();  
        //通过索引取得相应的矩形顶点缓冲。  
        quad = &(batchQuads[m_uAtlasIndex+particle->atlasIndex]);  
    }  
    else  
    {  
        //如果没有使用批次结点，直接取得相应的粒子的矩形顶点缓冲。  
        quad = &(m_pQuads[m_uParticleIdx]);  
    }  
    //根据是否由ALPHA值来设定RGB取得相应的颜色值。  
    ccColor4B color = (m_bOpacityModifyRGB)  
        ? ccc4( particle->color.r*particle->color.a*255, particle->color.g*particle->color.a*255, particle->color.b*particle->color.a*255, particle->color.a*255)  
        : ccc4( particle->color.r*255, particle->color.g*255, particle->color.b*255, particle->color.a*255);  
    //填真顶点缓冲中的颜色信息。  
    quad->bl.colors = color;  
    quad->br.colors = color;  
    quad->tl.colors = color;  
    quad->tr.colors = color;  
  
    // 设置顶点的位置信息  
    GLfloat size_2 = particle->size/2;  
    //判断是否进行旋转。  
    if (particle->rotation)   
    {  
        //定义临时变量来存放以size_2为半径的矩形外圆上的四个顶点。  
        GLfloat x1 = -size_2;  
        GLfloat y1 = -size_2;  
  
        GLfloat x2 = size_2;  
        GLfloat y2 = size_2;  
        //定义临时变量来存放圆心。  
        GLfloat x = newPosition.x;  
        GLfloat y = newPosition.y;  
        //求得旋转角度。  
        GLfloat r = (GLfloat)-CC_DEGREES_TO_RADIANS(particle->rotation);  
        //通过sin,cos来计算旋转后的矩形外圆上的四个角的顶点位置。  
        GLfloat cr = cosf(r);  
        GLfloat sr = sinf(r);  
        GLfloat ax = x1 * cr - y1 * sr + x;  
        GLfloat ay = x1 * sr + y1 * cr + y;  
        GLfloat bx = x2 * cr - y1 * sr + x;  
        GLfloat by = x2 * sr + y1 * cr + y;  
        GLfloat cx = x2 * cr - y2 * sr + x;  
        GLfloat cy = x2 * sr + y2 * cr + y;  
        GLfloat dx = x1 * cr - y2 * sr + x;  
        GLfloat dy = x1 * sr + y2 * cr + y;  
  
        // 填充计算旋转后的顶点位置信息。  
        quad->bl.vertices.x = ax;  
        quad->bl.vertices.y = ay;  
        quad->br.vertices.x = bx;  
        quad->br.vertices.y = by;  
        quad->tl.vertices.x = dx;  
        quad->tl.vertices.y = dy;  
        quad->tr.vertices.x = cx;  
        quad->tr.vertices.y = cy;  
    }   
    else   
    {  
        //如果不旋转，直接填充位置信息。  
        quad->bl.vertices.x = newPosition.x - size_2;  
        quad->bl.vertices.y = newPosition.y - size_2;  
        quad->br.vertices.x = newPosition.x + size_2;  
        quad->br.vertices.y = newPosition.y - size_2;  
        quad->tl.vertices.x = newPosition.x - size_2;  
        quad->tl.vertices.y = newPosition.y + size_2;  
        quad->tr.vertices.x = newPosition.x + size_2;  
        quad->tr.vertices.y = newPosition.y + size_2;                  
    }  
}  
//我们一直想知道在CCParticleSystem中每次update时，如果粒子批次结点为空时为什么要调用postStep？它倒底是干什么的，看完下面的代码，就很清楚了。  
void CCParticleSystemQuad::postStep()  
{  
    //绑定顶点缓冲区对象。  
    glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0] );  
    //用m_pQuads中数据更新绑定的缓冲区数据。  
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(m_pQuads[0])*m_uParticleCount, m_pQuads);  
    //取消绑定缓冲区对象。  
    glBindBuffer(GL_ARRAY_BUFFER, 0);  
    CHECK_GL_ERROR_DEBUG();  
    //清楚了，原来这个函数是针对不使用批次结点时的VBO顶点缓冲的更新。  
}  
  
// 绘制粒子系统。  
void CCParticleSystemQuad::draw()  
{  
    //如果当前在粒子的批次结点有值，则draw()不应该被调用！为什么呢？因为有批次结点的话，渲染交给批次结点的draw()函数而不是当前粒子系统的draw()函数来处理。  
    CCAssert(!m_pBatchNode,"draw should not be called when added to a particleBatchNode");  
    //使用相应的Shader  
    CC_NODE_DRAW_SETUP();  
    //绑定所用的纹理对象。  
    ccGLBindTexture2D( m_pTexture->getName() );  
    //设定所用的ALPHA混合方案。  
    ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );  
    //判断当前粒子索引是否为粒子总数，也就是判断是否已经update完成未出错。  
    CCAssert( m_uParticleIdx == m_uParticleCount, "Abnormal error in particle quad");  
    //如果使用VAO。  
#if CC_TEXTURE_ATLAS_USE_VAO  
    //使用VAO绑定的顶点数组  
    glBindVertexArray( m_uVAOname );  
    //绑定索引数组  
#if CC_REBIND_INDICES_BUFFER  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);  
#endif  
    //渲染调用  
    glDrawElements(GL_TRIANGLES, (GLsizei) m_uParticleIdx*6, GL_UNSIGNED_SHORT, 0);  
    //渲染完取消绑定索引数组  
#if CC_REBIND_INDICES_BUFFER  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);  
#endif  
    //取消绑定顶点数组  
    glBindVertexArray( 0 );  
  
#else  
    //  
    // Using VBO without VAO  
    //  
    //  
    #define kQuadSize sizeof(m_pQuads[0].bl)  
    //设置使用相应的顶点格式为:位置+颜色+纹理坐标  
    ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex );  
    // 绑定顶点缓冲  
    glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]);  
    // 设置顶点缓冲中位置数据的描述  
    glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, vertices));  
    //设置顶点缓冲中颜色数据的描述  
    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, colors));  
    //设置顶点缓冲中纹理坐标数据的描述  
    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, texCoords));  
    //绑定索引缓冲  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);  
    //渲染调用  
    glDrawElements(GL_TRIANGLES, (GLsizei) m_uParticleIdx*6, GL_UNSIGNED_SHORT, 0);  
    //取消绑定  
    glBindBuffer(GL_ARRAY_BUFFER, 0);  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);  
  
#endif  
    //渲染调用计数器加一  
    CC_INCREMENT_GL_DRAWS(1);  
    CHECK_GL_ERROR_DEBUG();  
}  
//设置粒子数量  
void CCParticleSystemQuad::setTotalParticles(unsigned int tp)  
{  
    // 如果要申请内存的粒子数量大于之前已经申请内存的粒子数量。  
    if( tp > m_uAllocatedParticles )  
    {  
        // 计算要申请的内存大小。  
        //粒子信息结构数组大小。   
        size_t particlesSize = tp * sizeof(tCCParticle);  
        //顶点缓冲的大小  
        size_t quadsSize = sizeof(m_pQuads[0]) * tp * 1;  
        //索引缓冲的大小  
        size_t indicesSize = sizeof(m_pIndices[0]) * tp * 6 * 1;  
        //在m_pParticles指定的内存位置申请相应大小的内存用于存储粒子信息结构数组。  
        tCCParticle* particlesNew = (tCCParticle*)realloc(m_pParticles, particlesSize);  
        //在m_pQuads指定的内存位置申请相应大小的内存用于填充顶点缓冲。  
        ccV3F_C4B_T2F_Quad* quadsNew = (ccV3F_C4B_T2F_Quad*)realloc(m_pQuads, quadsSize);  
        //在m_pIndices指定的内存位置申请相应大小的内存用于填充索引缓冲。  
        GLushort* indicesNew = (GLushort*)realloc(m_pIndices, indicesSize);  
        //如果申请都成功。  
        if (particlesNew && quadsNew && indicesNew)  
        {  
            // 将内存地址传值给成员指针。  
            m_pParticles = particlesNew;  
            m_pQuads = quadsNew;  
            m_pIndices = indicesNew;  
  
            // 内存清零  
            memset(m_pParticles, 0, particlesSize);  
            memset(m_pQuads, 0, quadsSize);  
            memset(m_pIndices, 0, indicesSize);  
            //记录申请内存的粒子数量。  
            m_uAllocatedParticles = tp;  
        }  
        else  
        {  
            // 如果失败，记录成功申请的内存地址打印出错LOG。  
            if (particlesNew) m_pParticles = particlesNew;  
            if (quadsNew) m_pQuads = quadsNew;  
            if (indicesNew) m_pIndices = indicesNew;  
  
            CCLOG("Particle system: out of memory");  
            return;  
        }  
        //更新粒子数量。  
        m_uTotalParticles = tp;  
  
        // 根据是否使用批次结点来设定每个粒子对应的矩形顶点块的索引。  
        if (m_pBatchNode)  
        {  
            for (unsigned int i = 0; i < m_uTotalParticles; i++)  
            {  
                m_pParticles[i].atlasIndex=i;  
            }  
        }  
        //填充索引缓冲。  
        setupIndices();  
        //初始化VAO  
#if CC_TEXTURE_ATLAS_USE_VAO  
        setupVBOandVAO();  
#else  
        //初始化VBO  
        setupVBO();  
#endif  
    }  
    else  
    {  
        //如果要申请内存的粒子数量小于原来申请的粒子数量，直接修改一下最大粒子数量就OK。  
        m_uTotalParticles = tp;  
    }  
}  
//如果当前OPENGL版本支持VAO。  
#if CC_TEXTURE_ATLAS_USE_VAO  
//初始化VBO与VAO  
void CCParticleSystemQuad::setupVBOandVAO()  
{   //初始化1个顶点数组对象，产生VAO对象的句柄  
    glGenVertexArrays(1, &m_uVAOname);  
    //绑定VAO。  
    glBindVertexArray(m_uVAOname);  
  
#define kQuadSize sizeof(m_pQuads[0].bl)  
    //创建2个VBO缓冲区对象，产生两个句柄填充到句柄数组中。  
    glGenBuffers(2, &m_pBuffersVBO[0]);  
    //绑定第一个VBO缓冲区对象。   
    glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]);  
    //将顶点数据拷贝到绑定的缓冲区。  
    glBufferData(GL_ARRAY_BUFFER, sizeof(m_pQuads[0]) * m_uTotalParticles, m_pQuads, GL_DYNAMIC_DRAW);  
  
    //设置使用位置数据  
    glEnableVertexAttribArray(kCCVertexAttrib_Position);  
    //设置位置数据在顶点缓冲中的描述  
    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, vertices));  
  
    //设置使用颜色数据  
    glEnableVertexAttribArray(kCCVertexAttrib_Color);  
    //设置颜色数据在顶点缓冲中的描述  
    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, colors));  
  
    //设置使用纹理坐标数据  
    glEnableVertexAttribArray(kCCVertexAttrib_TexCoords);  
    //设置纹理坐标数据在顶点缓冲中的描述  
    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof( ccV3F_C4B_T2F, texCoords));  
  
    //绑定VBO的第二个缓冲区  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);  
    //将索引缓冲区数据拷贝到绑定的缓冲区  
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(m_pIndices[0]) * m_uTotalParticles * 6, m_pIndices, GL_STATIC_DRAW);  
    //取消绑定  
    glBindVertexArray(0);  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);  
    glBindBuffer(GL_ARRAY_BUFFER, 0);  
  
    CHECK_GL_ERROR_DEBUG();  
}  
#else  
//否则只使用VBO  
void CCParticleSystemQuad::setupVBO()  
{  
    //创建2个VBO缓冲区对象，产生两个句柄填充到句柄数组中。  
    glGenBuffers(2, &m_pBuffersVBO[0]);  
    //绑定第一个VBO缓冲区对象并填充数据。  
    glBindBuffer(GL_ARRAY_BUFFER, m_pBuffersVBO[0]);  
    glBufferData(GL_ARRAY_BUFFER, sizeof(m_pQuads[0]) * m_uTotalParticles, m_pQuads, GL_DYNAMIC_DRAW);  
    glBindBuffer(GL_ARRAY_BUFFER, 0);  
    //绑定第二个VBO缓冲区对象并填充数据。  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_pBuffersVBO[1]);  
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(m_pIndices[0]) * m_uTotalParticles * 6, m_pIndices, GL_STATIC_DRAW);  
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);  
      
    CHECK_GL_ERROR_DEBUG();  
}  
  
#endif  
//响应当前结点的EVNET_COME_TO_FOREGROUND事件。这个事件的意义是程序将由后面返回到前台。这个事件响应时可做资源的重新载入。  
void CCParticleSystemQuad::listenBackToForeground(CCObject *obj)  
{  
    //重新初始化VBO和VAO。  
#if CC_TEXTURE_ATLAS_USE_VAO  
        setupVBOandVAO();  
#else  
        setupVBO();  
#endif  
}  
//创建顶点缓冲和索引缓冲区。  
bool CCParticleSystemQuad::allocMemory()  
{  
    //如果已经申请则中断。  
    CCAssert( ( !m_pQuads && !m_pIndices), "Memory already alloced");  
    CCAssert( !m_pBatchNode, "Memory should not be alloced when not using batchNode");  
    //释放顶点与索引缓冲  
    CC_SAFE_FREE(m_pQuads);  
    CC_SAFE_FREE(m_pIndices);  
    //为顶点与索引缓冲申请内存。  
    m_pQuads = (ccV3F_C4B_T2F_Quad*)malloc(m_uTotalParticles * sizeof(ccV3F_C4B_T2F_Quad));  
    m_pIndices = (GLushort*)malloc(m_uTotalParticles * 6 * sizeof(GLushort));  
    //如果出现失败，则提示LOG并释放置空返回。  
    if( !m_pQuads || !m_pIndices)   
    {  
        CCLOG("cocos2d: Particle system: not enough memory");  
        CC_SAFE_FREE(m_pQuads);  
        CC_SAFE_FREE(m_pIndices);  
  
        return false;  
    }  
    //如果成功，置零操作返回true.  
    memset(m_pQuads, 0, m_uTotalParticles * sizeof(ccV3F_C4B_T2F_Quad));  
    memset(m_pIndices, 0, m_uTotalParticles * 6 * sizeof(GLushort));  
  
    return true;  
}  
//设置CCParticleSystemQuad使用的粒子批次结点。   
void CCParticleSystemQuad::setBatchNode(CCParticleBatchNode * batchNode)  
{  
    //如果当前使用的粒子批次结点与参数不同，则进行更换处理。  
    if( m_pBatchNode != batchNode )   
    {  
        //先记录一下当前使用的。  
        CCParticleBatchNode* oldBatch = m_pBatchNode;  
        //将后调用基类相应函数，设置当前使用的粒子批次结点。  
        CCParticleSystem::setBatchNode(batchNode);  
  
        // 如果参数值为空，代表不使用批次结点。则进行顶点缓冲的相关初始化。  
        if( ! batchNode )   
        {  
            //创建顶点缓冲，填充索引，并根据是否可用VAO设置顶点缓冲,设置纹理。  
            allocMemory();  
            setupIndices();  
            setTexture(oldBatch->getTexture());  
#if CC_TEXTURE_ATLAS_USE_VAO  
            setupVBOandVAO();  
#else  
            setupVBO();  
#endif  
        }  
        // 如果批次结点有效，且更换前没有使用粒子批次结点。  
        else if( !oldBatch )  
        {  
            // 取得相应粒子批次结点的矩形数组，取出相应索引位置的矩形数据，将相应的顶点缓冲数据拷到矩形数组中。  
            ccV3F_C4B_T2F_Quad *batchQuads = m_pBatchNode->getTextureAtlas()->getQuads();  
            ccV3F_C4B_T2F_Quad *quad = &(batchQuads[m_uAtlasIndex] );  
            memcpy( quad, m_pQuads, m_uTotalParticles * sizeof(m_pQuads[0]) );  
            //释放当前用的顶点缓冲  
            CC_SAFE_FREE(m_pQuads);  
            CC_SAFE_FREE(m_pIndices);  
            //释放所用的VBO顶点对象与AVO名称  
            glDeleteBuffers(2, &m_pBuffersVBO[0]);  
#if CC_TEXTURE_ATLAS_USE_VAO  
            glDeleteVertexArrays(1, &m_uVAOname);  
#endif  
        }  
    }  
}  
//创建一个CCParticleSystemQuad,内部调用create实现。  
CCParticleSystemQuad * CCParticleSystemQuad::node()  
{  
    return CCParticleSystemQuad::create();  
}  
//上面函数的create实现。  
CCParticleSystemQuad * CCParticleSystemQuad::create() {  
    //创建一个CCParticleSystemQuad的实例对象。  
    CCParticleSystemQuad *pParticleSystemQuad = new CCParticleSystemQuad();  
    //如果创建成功，进行初始化。成功后交由内存管理器进行引用计数器的管理。  
    if (pParticleSystemQuad && pParticleSystemQuad->init())  
    {  
        pParticleSystemQuad->autorelease();  
        return pParticleSystemQuad;  
    }  
    //如果失败，释放置空并返回NULL。  
    CC_SAFE_DELETE(pParticleSystemQuad);  
    return NULL;  
}  

总结: 类CCParticleSystemQuad的源码进一步完善了粒子系统的功能，使我们可以在不需要批次结点时也能够实现粒子系统的OPENGL顶点和索引缓冲的创建和渲染，这么看来CCParticleSystem是一个不完整的粒子系统的类，它只提供了使用粒子批次结点的粒子系统的渲染方案。

到这里，我们基本算领悟了Cocos2d-x中粒子系统的完整功能基类。后面我们将由此进入到多彩的粒子系统的演示中去！下课~

0 0

Cocos2d-x2.0 粒子系统深入分析三部曲(二)

Cocos2d-x2.0 粒子系统深入分析三部曲(二)

[Cocos2d-x相关教程来源于红孩儿的游戏编程之路CSDN博客地址：http://blog.csdn.net/honghaier]

红孩儿Cocos2d-X学习园地QQ2群：44208467加群写：Cocos2d-x 红孩儿Cocos2d-X学习园地QQ群：249941957加群写：Cocos2d-x

Cocos2d-x2.0 粒子系统深入分析三部曲(二)

红孩儿Cocos2d-X学习园地QQ2群：44208467加群写：Cocos2d-x
红孩儿Cocos2d-X学习园地QQ群：249941957加群写：Cocos2d-x