cocos2dx循环滚动视图

由于项目需求大厅里的牌子要循环滚动（tips:这样看起来东西比较多，其实是个挺搞笑的需求），cocos本身的控件不满足需求，所以就简单写了个。目前惯性减速不太好用，有更好解决方案的大拿给个提示啊！

GitHub链接
代码如下：

//
//  ScrollCircle.hpp
//  ScrollSelector-mobile
//
//  Created by 徐家伟 on 2018/1/19.
//

#ifndef CycleScroll_hpp
#define CycleScroll_hpp

#include "cocos2d.h"
#include "cocos-ext.h"
#include <vector>

#define MIN_SCROLL_SPEED 1
#define MAX_SCROLL_SPEED 30

class CycleScroll: public cocos2d::LayerColor
{
CycleScroll();
public:
static CycleScroll* create(cocos2d::Size &size, std::vector<cocos2d::Node*> nodes, float distance, float minScale = 1.0f);
void ScrollTo(int index, float delay);
void setDisplaySize(const cocos2d::Size &size);
const cocos2d::Size& getDisplaySize() const;

private:
float minScale;
float spaceDistance;
int currentIndex;
cocos2d::Size disSize;
cocos2d::ClippingNode* clipNode;
std::vector<cocos2d::Node*> nodes;

// 减速使用
bool dragging;
bool autoScrolling;
float scrollDistance;
float startTime;
cocos2d::Vec2 startPos;

bool onTouchBegin(cocos2d::Touch *touch, cocos2d::Event *unused_event);
void onTouchMove(cocos2d::Touch *touch, cocos2d::Event *unused_event);
void onTouchEnd(cocos2d::Touch *touch, cocos2d::Event *unused_event);
void updateNodePosX(float interval);

virtual bool init();
void initView();
void initListener();
void update(float dt);
void deaccelerateScrolling(float dt);

CREATE_FUNC(CycleScroll);
};

#endif /* ScrollCircle_hpp */

#include "CyclyScroll.hpp"

using namespace std;
USING_NS_CC;

CycleScroll::CycleScroll():autoScrolling(false),
dragging(false),
scrollDistance(0),
minScale(1),
spaceDistance(150),
currentIndex(0),
startTime(0)
{}

CycleScroll* CycleScroll::create(Size &size, vector<Node*> nodes, float distance, float minScale /*= 1.0f*/)
{
auto ret = CycleScroll::create();
ret->nodes = nodes;
ret->spaceDistance = distance;
ret->minScale = minScale;
ret->disSize = size;
ret->initView();
ret->scheduleUpdate();
return ret;
}

void CycleScroll::initView()
{
this->setContentSize(this->disSize);
auto clipSize = this->disSize;
auto stencil = LayerColor::create(Color4B::RED, clipSize.width, clipSize.height);
clipNode = ClippingNode::create(stencil);
this->addChild(this->clipNode);

unsigned long cnt = this->nodes.size();
for(int i = 0; i< cnt; i++){
if(this->nodes[i] != NULL){
this->nodes[i]->setPosition(Vec2(this->nodes[i]->getContentSize().width/2 + i * spaceDistance, disSize.height/2));// TODO
clipNode->addChild(this->nodes[i]);
}
}

this->initListener();
//    this->ScrollTo(0, 0);
}

void CycleScroll::setDisplaySize(const cocos2d::Size &size){
LayerColor::setContentSize(size);
clipNode->getStencil()->setContentSize(size);
}

const Size& CycleScroll::getDisplaySize() const{
return this->disSize;
}

void CycleScroll::ScrollTo(int index, float delay){
if(index < 0 || index >= this->nodes.size())
return;

Size contentSize = this->getContentSize();

float distance = contentSize.width/2 - this->nodes[index]->getPositionX();
for(auto i : this->nodes)
i->runAction(MoveBy::create(delay, Vec2(distance, 0)));
}

bool CycleScroll::init()
{
return LayerColor::initWithColor(Color4B(0,0,0,0));
}

void CycleScroll::initListener()
{
auto listener = EventListenerTouchOneByOne::create();
listener->onTouchBegan = CC_CALLBACK_2(CycleScroll::onTouchBegin, this);
listener->onTouchMoved = CC_CALLBACK_2(CycleScroll::onTouchMove, this);
listener->onTouchEnded = CC_CALLBACK_2(CycleScroll::onTouchEnd, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
}

bool CycleScroll::onTouchBegin(cocos2d::Touch *touch, cocos2d::Event *unused_event){
dragging = true;
scrollDistance = 0;
startTime = clock();
startPos = touch->getLocation();
return true;
}

void CycleScroll::onTouchMove(cocos2d::Touch *touch, cocos2d::Event *unused_event){
float disX = touch->getDelta().x;
this->updateNodePosX(disX);
}

void CycleScroll::onTouchEnd(cocos2d::Touch *touch, cocos2d::Event *unused_event){
//    float startDistance = touch->getLocation().distance(touch->getStartLocation());
//
//    if(startDistance < 10) // click
//    {
//
//    }

// 处理减速
dragging = false;
auto prePos = touch->getPreviousLocation();
auto curPos = touch->getLocation();
scrollDistance = curPos.distance(prePos);
int direction = curPos.x > startPos.x?1:-1;

scrollDistance = scrollDistance <= MAX_SCROLL_SPEED?scrollDistance : MAX_SCROLL_SPEED;
scrollDistance = scrollDistance * direction;
CCLOG("end:%f, pre:%f", curPos.x, prePos.x);

float longDisance = curPos.distance(startPos);
float elapsedTime = (clock() - startTime) / 1000; //毫秒
CCLOG("long:%f, t:%f", longDisance, elapsedTime);
if (elapsedTime < 50 && scrollDistance < 10 && longDisance >= 10){
scrollDistance = longDisance<=MAX_SCROLL_SPEED?longDisance:MAX_SCROLL_SPEED;
scrollDistance *= direction;
}
if (fabs(scrollDistance) > MIN_SCROLL_SPEED){
autoScrolling = true;
}
}

void CycleScroll::updateNodePosX(float interval){
int length = (int)nodes.size();
for (int i=0; i<length; i++){
auto node = this->nodes[i];
node->setPositionX(node->getPositionX() + interval);
}
}

void CycleScroll::deaccelerateScrolling(float dt){
if (dragging)
{
autoScrolling = false;
return;
}
CCLOG("sc:%f", scrollDistance);
scrollDistance *= 0.95;
if (fabs(scrollDistance) < MIN_SCROLL_SPEED){
autoScrolling = false;
startTime = 0;
}
this->updateNodePosX(scrollDistance);
}

void CycleScroll::update(float dt)
{
int length = (int)nodes.size();
float newPosX = 0;
auto s = 0.5;
auto mid = this->disSize.width/2;

for (int i=0; i<length; i++){
auto node = this->nodes[i];
auto curPosX = node->getPositionX();

if (curPosX < -node->getContentSize().width/2){
int beforeIndex = i-1;
beforeIndex = beforeIndex>=0?beforeIndex:length-1;
newPosX = nodes[beforeIndex]->getPositionX() + this->spaceDistance;
if (curPosX != newPosX){
node->setPositionX(newPosX);
curPosX = newPosX;
}
}else if (curPosX > this->disSize.width + node->getContentSize().width/2){
int afterIndex = i+1;
afterIndex = afterIndex<=length-1?afterIndex:0;
newPosX = nodes[afterIndex]->getPositionX() - this->spaceDistance;
if (curPosX != newPosX){
node->setPositionX(newPosX);
curPosX = newPosX;
}
}

if (curPosX <= mid){
s = curPosX / mid;
} else{
s = (this->disSize.width-curPosX) / mid;
}
s *= 1.2;
s = s<=1?s:1;
s = s>=this->minScale?s:this->minScale;
node->setScale(s);
}

if (autoScrolling){
this->deaccelerateScrolling(dt);
}
}