CCMotionStreak（ccnode子类 可实现拖尾效果 需要设置--- 消隐动画时长，拖尾条带相邻顶点间的最小距离,拖尾条带的宽度,顶点颜色，纹理）

例子：

以下示例出自tests项目中的MotionStreakTest文件夹下的MotionStreakTest.cpp文件，其中的MotionStreakTest2类如代码清单3-43所示。

代码清单3-43　定义CCMotionStreak对象
void MotionStreakTest2::onEnter()
{
    MotionStreakTest::onEnter();

    setTouchEnabled(true);

    CCSize s = CCDirector::sharedDirector()->getWinSize();
       
    streak = CCMotionStreak::create(3, 3, 64, ccWHITE, s_streak );
    addChild(streak);
   
    streak->setPosition( CCPointMake(s.width/2, s.height/2) );
}

 

void MotionStreakTest2::ccTouchesMoved(CCSet* touches, CCEvent* event)
{
    CCSetIterator it = touches->begin();
    CCTouch* touch = (CCTouch*)(*it);

    CCPoint touchLocation = touch->locationInView();   
    touchLocation = CCDirector::sharedDirector()->convertToGL( touchLocation );
   
    streak->setPosition( touchLocation );
}

以上代码使用create函数创建CCMotionStreak对象，每次调用setPosition函数重新设置对象位置时，“影子”将被创建并且慢慢渐隐，

#ifndef __CCMOTION_STREAK_H__

#define __CCMOTION_STREAK_H__

#include "CCProtocols.h"

#include "textures/CCTexture2D.h"

#include "ccTypes.h"

#include "base_nodes/CCNode.h"

#ifdef EMSCRIPTEN

#include "base_nodes/CCGLBufferedNode.h"

#endif // EMSCRIPTEN

NS_CC_BEGIN

/**

 * @addtogroup misc_nodes

 * @{

 */

/** MotionStreak.

 Creates a trailing path.

 */

class CC_DLL CCMotionStreak : public CCNodeRGBA, public CCTextureProtocol

#ifdef EMSCRIPTEN

, public CCGLBufferedNode

#endif // EMSCRIPTEN

{

public:

    CCMotionStreak();

    virtual ~CCMotionStreak();

   // 创建一个拖尾效果，参一为消隐动画时长，参二为拖尾条带相邻顶点间的最小距离,参三为拖尾条带的宽度,参四为顶点颜色值，参五为所使用的纹理图片。

    static CCMotionStreak* create(float fade, float minSeg, float stroke, ccColor3B color, const char* path);

//同上 参五为所使用的纹理对象指针。 

    static CCMotionStreak* create(float fade, float minSeg, float stroke, ccColor3B color, CCTexture2D* texture);

    bool initWithFade(float fade, float minSeg, float stroke, ccColor3B color, const char* path);   

{

    CCAssert(path != NULL, "Invalid filename");

    CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(path);

    return initWithFade(fade, minSeg, stroke, color, texture);

}

bool initWithFade(float fade, float minSeg, float stroke, ccColor3B color, CCTexture2D* texture);

{

    CCNode::setPosition(CCPointZero);

    setAnchorPoint(CCPointZero);

    ignoreAnchorPointForPosition(true);

    m_bStartingPositionInitialized = false;

    m_tPositionR = CCPointZero;

    m_bFastMode = true;

    m_fMinSeg = (minSeg == -1.0f) ? stroke/5.0f : minSeg;

    m_fMinSeg *= m_fMinSeg;

    m_fStroke = stroke;

    m_fFadeDelta = 1.0f/fade;

    m_uMaxPoints = (int)(fade*60.0f)+2;

    m_uNuPoints = 0;

    m_pPointState = (float *)malloc(sizeof(float) * m_uMaxPoints);

    m_pPointVertexes = (CCPoint*)malloc(sizeof(CCPoint) * m_uMaxPoints);

    m_pVertices = (ccVertex2F*)malloc(sizeof(ccVertex2F) * m_uMaxPoints * 2);

    m_pTexCoords = (ccTex2F*)malloc(sizeof(ccTex2F) * m_uMaxPoints * 2);

    m_pColorPointer =  (GLubyte*)malloc(sizeof(GLubyte) * m_uMaxPoints * 2 * 4);

    // Set blend mode

    m_tBlendFunc.src = GL_SRC_ALPHA;

    m_tBlendFunc.dst = GL_ONE_MINUS_SRC_ALPHA;

    // shader program

    setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTextureColor));

    setTexture(texture);

    setColor(color);

    scheduleUpdate();

    return true;

}

    /** color used for the tint */

    void tintWithColor(ccColor3B colors);

{

    setColor(colors);

    // Fast assignation

    for(unsigned int i = 0; i<m_uNuPoints*2; i++) 

    {

        *((ccColor3B*) (m_pColorPointer+i*4)) = colors;

    }

}

   //删除所有的条带段  

    void reset();

    virtual void setPosition(const CCPoint& position);

{

    m_bStartingPositionInitialized = true;

    m_tPositionR = position;

}

    virtual void draw();

{

    if(m_uNuPoints <= 1)

        return;

    CC_NODE_DRAW_SETUP();

    ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex );

    ccGLBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );

    ccGLBindTexture2D( m_pTexture->getName() );

#ifdef EMSCRIPTEN

    // Size calculations from ::initWithFade

    setGLBufferData(m_pVertices, (sizeof(ccVertex2F) * m_uMaxPoints * 2), 0);

    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, 0);

    setGLBufferData(m_pTexCoords, (sizeof(ccTex2F) * m_uMaxPoints * 2), 1);

    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, 0);

    setGLBufferData(m_pColorPointer, (sizeof(GLubyte) * m_uMaxPoints * 2 * 4), 2);

    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);

#else

    glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, m_pVertices);

    glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, m_pTexCoords);

    glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, m_pColorPointer);

#endif // EMSCRIPTEN

    glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)m_uNuPoints*2);

    CC_INCREMENT_GL_DRAWS(1);

}

    virtual void update(float delta);

{

    if (!m_bStartingPositionInitialized)

    {

        return;

    }

    

    delta *= m_fFadeDelta;

    unsigned int newIdx, newIdx2, i, i2;

    unsigned int mov = 0;

    // Update current points

    for(i = 0; i<m_uNuPoints; i++)

    {

        m_pPointState[i]-=delta;

        if(m_pPointState[i] <= 0)

            mov++;

        else

        {

            newIdx = i-mov;

            if(mov>0)

            {

                // Move data

                m_pPointState[newIdx] = m_pPointState[i];

                // Move point

                m_pPointVertexes[newIdx] = m_pPointVertexes[i];

                // Move vertices

                i2 = i*2;

                newIdx2 = newIdx*2;

                m_pVertices[newIdx2] = m_pVertices[i2];

                m_pVertices[newIdx2+1] = m_pVertices[i2+1];

                // Move color

                i2 *= 4;

                newIdx2 *= 4;

                m_pColorPointer[newIdx2+0] = m_pColorPointer[i2+0];

                m_pColorPointer[newIdx2+1] = m_pColorPointer[i2+1];

                m_pColorPointer[newIdx2+2] = m_pColorPointer[i2+2];

                m_pColorPointer[newIdx2+4] = m_pColorPointer[i2+4];

                m_pColorPointer[newIdx2+5] = m_pColorPointer[i2+5];

                m_pColorPointer[newIdx2+6] = m_pColorPointer[i2+6];

            }else

                newIdx2 = newIdx*8;

            const GLubyte op = (GLubyte)(m_pPointState[newIdx] * 255.0f);

            m_pColorPointer[newIdx2+3] = op;

            m_pColorPointer[newIdx2+7] = op;

        }

    }

    m_uNuPoints-=mov;

    // Append new point

    bool appendNewPoint = true;

    if(m_uNuPoints >= m_uMaxPoints)

    {

        appendNewPoint = false;

    }

    else if(m_uNuPoints>0)

    {

        bool a1 = ccpDistanceSQ(m_pPointVertexes[m_uNuPoints-1], m_tPositionR) < m_fMinSeg;

        bool a2 = (m_uNuPoints == 1) ? false : (ccpDistanceSQ(m_pPointVertexes[m_uNuPoints-2], m_tPositionR) < (m_fMinSeg * 2.0f));

        if(a1 || a2)

        {

            appendNewPoint = false;

        }

    }

    if(appendNewPoint)

    {

        m_pPointVertexes[m_uNuPoints] = m_tPositionR;

        m_pPointState[m_uNuPoints] = 1.0f;

        // Color assignment

        const unsigned int offset = m_uNuPoints*8;

        *((ccColor3B*)(m_pColorPointer + offset)) = _displayedColor;

        *((ccColor3B*)(m_pColorPointer + offset+4)) = _displayedColor;

        // Opacity

        m_pColorPointer[offset+3] = 255;

        m_pColorPointer[offset+7] = 255;

        // Generate polygon

        if(m_uNuPoints > 0 && m_bFastMode )

        {

            if(m_uNuPoints > 1)

            {

                ccVertexLineToPolygon(m_pPointVertexes, m_fStroke, m_pVertices, m_uNuPoints, 1);

            }

            else

            {

                ccVertexLineToPolygon(m_pPointVertexes, m_fStroke, m_pVertices, 0, 2);

            }

        }

        m_uNuPoints ++;

    }

    if( ! m_bFastMode )

    {

        ccVertexLineToPolygon(m_pPointVertexes, m_fStroke, m_pVertices, 0, m_uNuPoints);

    }

    // Updated Tex Coords only if they are different than previous step

    if( m_uNuPoints  && m_uPreviousNuPoints != m_uNuPoints ) {

        float texDelta = 1.0f / m_uNuPoints;

        for( i=0; i < m_uNuPoints; i++ ) {

            m_pTexCoords[i*2] = tex2(0, texDelta*i);

            m_pTexCoords[i*2+1] = tex2(1, texDelta*i);

        }

        m_uPreviousNuPoints = m_uNuPoints;

    }

}

    /* Implement interfaces */

    virtual CCTexture2D* getTexture(void);

    virtual void setTexture(CCTexture2D *texture); //set get 纹理

    virtual void setBlendFunc(ccBlendFunc blendFunc);

    virtual ccBlendFunc getBlendFunc(void);         //set get BlendFunc

    virtual GLubyte getOpacity(void);

    virtual void setOpacity(GLubyte opacity);           //set get Opacity  

    virtual void setOpacityModifyRGB(bool bValue);

    virtual bool isOpacityModifyRGB(void);

    /** When fast mode is enabled, new points are added faster but with lower precision(精密度) */

//快速模式开启时  新的点被更快的添加 但精密度降低

    inline bool isFastMode() { return m_bFastMode; }

    inline void setFastMode(bool bFastMode) { m_bFastMode = bFastMode; }

//起点是否初始化  

    inline bool isStartingPositionInitialized() { return m_bStartingPositionInitialized; }

    inline void setStartingPositionInitialized(bool bStartingPositionInitialized) 

    { 

        m_bStartingPositionInitialized = bStartingPositionInitialized; 

    }

protected:

    bool m_bFastMode;

    bool m_bStartingPositionInitialized;

private:

    /** texture used for the motion streak */

    CCTexture2D* m_pTexture;

    ccBlendFunc m_tBlendFunc; //ALPHA混合方案  

    CCPoint m_tPositionR; //当前拖尾起点位置  

    float m_fStroke; //拖尾线条的宽度,越大当前越粗  

    float m_fFadeDelta;   //每秒条带渐隐的alpha值减少量  

    float m_fMinSeg;     //拖尾中用于划分条带的顶点的最小距离。  

    unsigned int m_uMaxPoints;   //顶点最大数量 

    unsigned int m_uNuPoints;    //当前的顶点数量  

    unsigned int m_uPreviousNuPoints;    //上次的顶点数量  

    /** Pointers */

    CCPoint* m_pPointVertexes;    //顶点位置数组  

    float* m_pPointState;    //顶点的状态值数组，这个状态值取值为0~1.0间，代表了消隐程度，其实就是alpha值。  

       // OPENGL所用的顶点各类数据绘冲 

    ccVertex2F* m_pVertices;   //位置  

    GLubyte* m_pColorPointer;     //颜色  

    ccTex2F* m_pTexCoords;     //纹理UV  

};