void CAScrollView::closeToPoint(float delay) { CCSize size = this->getContentSize(); CCPoint point = m_pContainer->getFrameOrigin(); CCPoint resilience = ccpSub(m_tCloseToPoint, point); if (resilience.getLength() <= 0.5f) { m_pContainer->setFrameOrigin(m_tCloseToPoint); CAScheduler::unschedule(schedule_selector(CAScrollView::closeToPoint), this); m_tCloseToPoint = CCPoint(-1, -1); this->hideIndicator(); } else { resilience.x /= size.width; resilience.y /= size.height; resilience = ccpMult(resilience, maxBouncesSpeed(delay)); resilience = ccpAdd(resilience, point); m_pContainer->setFrameOrigin(resilience); } }
bool CAIndicator::initWithFrame(const CCRect& rect, CAIndicatorType type) { if (!CAView::init()) { return false; } this->setFrame(rect); m_eType = type; CAImage* image = CAImage::create("indicator.png"); CCRect r; r.origin = ccpSub(ccpMult(image->getContentSize(), 0.5f), CCPoint(0.5f, 0.5f)); r.size = CCSize(1.0f, 1.0f); m_pIndicator = CAScale9ImageView::createWithImage(r, image); this->addSubview(m_pIndicator); this->setOpacity(0); return true; }
void JoystickController::update(ccTime dt) { if (mListener) { CCPoint scaledV = ccpMult(mJoystick->getVelocity(), 320); mListener->UpdatePosition(dt, scaledV.x, scaledV.y); if (mButton->getIsActive()) { if (!mButtonDown) { mButtonDown = true; mListener->FirePrimary(); } } else mButtonDown = false; } }
void CCLayerParent::ccTouchEnded(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent) { CCPoint touchPoint = this->convertTouchToNodeSpace(pTouch); CCArray* movers = _humanPlayer->getAllEntitiesOnTeam(_humanPlayer->team()->team,"SelectionComponent"); for(UINT i=0;i<movers->count();i++){ Entity* entity =(Entity* ) movers->objectAtIndex(i); SelectionComponent* select = entity->select(); if(select->selected) { MoveComponent* move = entity->move(); RenderComponent* render = entity->render(); move->moveTarget = touchPoint; GunComponent* gun = entity->gun(); if (gun) { CCPoint vector = ccpNormalize(ccpSub(render->node->getPosition(), touchPoint)); move->moveTarget = ccpAdd(touchPoint, ccpMult(vector, gun->deck->fight.Range / 2)); } //CCLog("Destination %d %f,%f",entity->_eid,touchPoint.x,touchPoint.y); } } }
void Canon ::shoot(MyObject* m_enemy, float dt) { CCPoint totarget = ccpSub(m_enemy->m_pos, this->m_pos); float a = ccpDot(m_enemy->m_velocity,m_enemy->m_velocity) - (m_maxVelocity *m_maxVelocity); float b = 2 * ccpDot(m_enemy->m_velocity, totarget); float c = ccpDot(totarget,totarget); float p = -b / (2 * a); float q = (float)sqrt((b * b) - 4 * a * c) / (2 * a); float t1 = p - q; float t2 = p + q; float t; if (t1 > t2 && t2 > 0) { t = t2; } else { t = t1; } CCPoint aimSpot = ccpAdd(m_enemy->m_pos ,ccpMult(m_enemy->m_velocity,t)); //position of target in future after t seconds CCPoint BoomPath = ccpSub (aimSpot , m_pos ); float timeToImpact = ccpLength(BoomPath) / m_maxVelocity/60; //speed must be in units per second m_BoomManager->addBoom(new Boom(layer, m_pos,timeToImpact,m_maxVelocity)); for (int i =0; i < m_BoomManager->getListBoom().size(); i++) { m_BoomManager->getBoom(i)->setTarget(aimSpot); m_BoomManager->getBoom(i)->m_Active = true; } }
void CameraObserver::OnNotifyChange(INotifier *notify, const INotifyEvent *event) { if (NULL == event) { return; } switch (event->GetNotifyEventType()) { case ENCameraEvent::enPosChanged: { const CameraPosChanged *posChangedEvent = reinterpret_cast<const CameraPosChanged*>(event); //setPosition(cocos2d::ccpNeg(posChangedEvent->GetCameraPosition())); cocos2d::CCPoint newPos = cocos2d::ccpNeg(posChangedEvent->GetCameraPosition()); cocos2d::CCPoint dis = cocos2d::ccpSub(newPos, m_lastPos); if ( m_pChildren && m_pChildren->count() > 0 ) { CCObject* child; CCARRAY_FOREACH(m_pChildren, child) { CCNode* pNode = (CCNode*)child; if (pNode) { MoveScale::iterator it = m_moveScale.find(pNode); if (m_moveScale.end() == it) { pNode->setPosition(newPos); } else { pNode->setPosition(ccpAdd(pNode->getPosition(), ccpMult(dis, it->second))); } } } } m_lastPos = cocos2d::ccpNeg(posChangedEvent->GetCameraPosition()); }
void CAIndicator::ccTouchMoved(CATouch *pTouch, CAEvent *pEvent) { DPoint point = m_pIndicator->getCenterOrigin(); DPoint p_off = ccpSub(this->convertToNodeSpace(pTouch->getLocation()), this->convertToNodeSpace(pTouch->getPreviousLocation())); DSize size = m_pIndicator->getFrame().size; if (m_eType == CAIndicatorTypeHorizontal) { point.x += p_off.x; point.x = MAX(point.x, size.width/2); point.x = MIN(point.x, m_obContentSize.width - size.width/2); } else { point.y += p_off.y; point.y = MAX(point.y, size.height/2); point.y = MIN(point.y, m_obContentSize.height - size.height/2); } m_pIndicator->setCenterOrigin(point); DSize indictor_size = ccpSub(m_obContentSize, size); DPoint indictor_point = ccpSub(point, ccpMult(size, 0.5f)); DSize view_size = ccpSub(m_pMyScrollView->getViewSize(), m_pMyScrollView->getBounds().size); DPoint view_offset = m_pMyScrollView->getContentOffset(); if (m_eType == CAIndicatorTypeHorizontal) { view_offset.x = indictor_point.x / indictor_size.width * view_size.width; } else { view_offset.y = indictor_point.y / indictor_size.height * view_size.height; } m_pMyScrollView->setContentOffset(view_offset, false); }
void HFViewport::intervalMove(float dt) { if (limitSpeedX > 0 && fabsf(m_tScrollDistance.x) > limitSpeedX) { m_tScrollDistance.x = m_tScrollDistance.x > 0 ? limitSpeedX:-limitSpeedX; } if (limitSpeedY > 0 && fabsf(m_tScrollDistance.y) > limitSpeedY) { m_tScrollDistance.y = m_tScrollDistance.y > 0 ? limitSpeedY:-limitSpeedY;; } applyPos(m_tScrollDistance); m_tScrollDistance = ccpMult(m_tScrollDistance, SCROLL_DEACCEL_RATE); if (fabsf(m_tScrollDistance.x) <= SCROLL_DEACCEL_DIST && fabsf(m_tScrollDistance.y) <= SCROLL_DEACCEL_DIST) { this->unschedule(schedule_selector(HFViewport::intervalMove)); this->mTouchMode = TouchMode_None; if (mTouchDelegate) { mTouchDelegate->autoMoveEnd(); } if(isChangeFPS) { Director::getInstance()->setAnimationInterval(g_LOW_FPS); } } }
bool CCFollow::initWithTarget(CCNode *pFollowedNode, const CCRect& rect) { CCAssert(pFollowedNode != NULL, ""); pFollowedNode->retain(); m_pobFollowedNode = pFollowedNode; m_bBoundarySet = true; m_bBoundaryFullyCovered = false; CCSize winSize = CCDirector::sharedDirector()->getWinSize(); m_obFullScreenSize = CCPointMake(winSize.width, winSize.height); m_obHalfScreenSize = ccpMult(m_obFullScreenSize, 0.5f); m_fLeftBoundary = -((rect.origin.x+rect.size.width) - m_obFullScreenSize.x); m_fRightBoundary = -rect.origin.x ; m_fTopBoundary = -rect.origin.y; m_fBottomBoundary = -((rect.origin.y+rect.size.height) - m_obFullScreenSize.y); if (m_fRightBoundary < m_fLeftBoundary) { // screen width is larger than world's boundary width //set both in the middle of the world m_fRightBoundary = m_fLeftBoundary = (m_fLeftBoundary + m_fRightBoundary) / 2; } if (m_fTopBoundary < m_fBottomBoundary) { // screen width is larger than world's boundary width //set both in the middle of the world m_fTopBoundary = m_fBottomBoundary = (m_fTopBoundary + m_fBottomBoundary) / 2; } if ((m_fTopBoundary == m_fBottomBoundary) && (m_fLeftBoundary == m_fRightBoundary)) { m_bBoundaryFullyCovered = true; } return true; }
void UIDragPanel::moveByUpdate(float t) { float easeRate = 0.0f; switch (m_eMoveType) { case DRAGPANEL_MOVE_TYPE_AUTOMOVE: easeRate = m_fAutoMoveEaseRate; break; case DRAGPANEL_MOVE_TYPE_BOUNCE: easeRate = m_fBounceEaseRate; break; default: break; } t = powf(t, 1 / easeRate); CCPoint currentPos = m_pActionWidget->getPosition(); CCPoint diff = ccpSub(currentPos, m_previousPosition); m_startPosition = ccpAdd( m_startPosition, diff); CCPoint newPos = ccpAdd( m_startPosition, ccpMult(m_positionDelta, t) ); m_pActionWidget->setPosition(newPos); m_previousPosition = newPos; switch (m_eMoveType) { case DRAGPANEL_MOVE_TYPE_AUTOMOVE: autoMove(); break; default: break; } }
bool HFViewport::boundPos(cocos2d::CCPoint& pos) { auto winsize = CCDirector::sharedDirector()->getWinSize(); float scale = m_TargetNode->getScale(); mCurZoomScale = scale; //Correct for anchor cocos2d::CCPoint anchor = ccp(m_TargetNode->getContentSize().width * m_TargetNode->getAnchorPoint().x, m_TargetNode->getContentSize().height * m_TargetNode->getAnchorPoint().y); anchor = ccpMult(anchor, (1.0f - scale)); CCPoint visibleTopRight(winsize.width, winsize.height); CCPoint visibleBottomLeft = CCPointZero; visibleTopRight = ccpAdd(visibleTopRight, visibleBottomLeft); auto size = CCDirector::sharedDirector()->getWinSize(); float fixW = size.width; float fixH = size.height; if (isForDiamond) { auto fixSize = mWorldBound.size + CCSize(fixW / 2,fixH / 2); auto fixOrigin = mWorldBound.origin + ccp(fixW / 2, fixH / 2); topRight = ccpAdd(ccpSub(ccpMult(fixSize, scale), visibleTopRight), anchor); bottomLeft = ccpSub(ccpAdd(ccpMult(fixOrigin, scale), visibleBottomLeft), anchor); } else { topRight = ccpAdd(ccpSub(ccpMult(this->mWorldBound.size, scale), visibleTopRight), anchor); bottomLeft = ccpSub(ccpAdd(ccpMult(this->mWorldBound.origin, scale), visibleBottomLeft), anchor); } if (bottomLeft.x < pos.x ) { pos.x = bottomLeft.x; } else if (pos.x < -topRight.x) { pos.x = -topRight.x; } if (bottomLeft.y < pos.y ) { pos.y = bottomLeft.y; } else if(pos.y < -topRight.y) { pos.y = -topRight.y; } if (isForDiamond) { auto isNeedToAdjust = [](const CCPoint &p1, const CCPoint &p2){ int dx = (p2.x - p1.x); int dy = (p2.y - p1.y); dx = abs(dx); dy = abs(dy); if(dx > 2 * dy){ return true; } return false; }; auto adjust = [](CCPoint &p1, CCPoint &p2, bool isTop){ int dx = (p2.x - p1.x); dx = abs(dx); if(isTop){ p1.y = p2.y + dx / 2; }else{ p1.y = p2.y - dx / 2; } }; auto ptDown = ccp(-bottomLeft.x + mWorldBound.size.width / 2 * scale, -bottomLeft.y) * -1; auto ptUp = ccp(-bottomLeft.x + mWorldBound.size.width / 2 * scale, -bottomLeft.y + mWorldBound.size.height * scale) * -1; auto centerPt = (ptDown + ptUp) / 2; if(pos.y > centerPt.y){//left_up and left_down if(isNeedToAdjust(pos, ptDown)){ adjust(pos, ptDown, false); } }else{ if(isNeedToAdjust(pos, ptUp)){ adjust(pos, ptUp, true); } } // auto pInside = [](const CCPoint& p1,const CCPoint& p2,const CCPoint& p3){ // // (x1-x3)*(y2-y3)-(y1-y3)*(x2-x3) // // p3 is at left side to p1p2,then return true // return (p1.x-p3.x)*(p2.y-p3.y)-(p1.y-p3.y)*(p2.x-p3.x) < 0 ? false : true; // }; // // float halfWidth = (topRight.x - bottomLeft.x)/2; // float halfHeight = (topRight.y - bottomLeft.y)/2; // // // caution: bottomLeft and topRight is reverse // // and pos is also reverse // // so when pos in the top left zone,it means the bottom right zone // auto centerPoint = -(bottomLeft + topRight)/2; // auto reversePos = centerPoint*2 - pos; // //// float wh = halfWidth/halfHeight; // float hw = halfHeight/halfWidth; // auto pLeft = ccp(-topRight.x,-topRight.y+halfHeight); // auto pBottom = ccp(-topRight.x+halfWidth,-topRight.y); // auto pRight = ccp(-topRight.x+2*halfWidth, -topRight.y+halfHeight); // auto pTop = ccp(-topRight.x+halfWidth, -topRight.y+2*halfHeight); // // if (pos.x < centerPoint.x && pos.y < centerPoint.y) { // // top right corner // if (pInside(pTop,pRight,reversePos)) { //// if (m_tScrollDistance.x == 0 || m_tScrollDistance.y/m_tScrollDistance.x > wh) { //// pos.x = -wh*(pos.y-pLeft.y)+pLeft.x; //// } else { // pos.y = -hw*(pos.x-pLeft.x)+pLeft.y; //// } // } // // } else if (pos.x < centerPoint.x && pos.y > centerPoint.y) { // // bottom right corner // if (pInside(pRight,pBottom,reversePos)) { //// if (m_tScrollDistance.x == 0 || -m_tScrollDistance.y/m_tScrollDistance.x > wh) { //// pos.x = wh*(pos.y-pTop.y)+pTop.x; //// } else { // pos.y = hw*(pos.x-pTop.x)+pTop.y; //// } // } // // } else if (pos.x > centerPoint.x && pos.y > centerPoint.y) { // // bottom left corner // if (pInside(pBottom,pLeft,reversePos)) { //// if (m_tScrollDistance.x == 0 || m_tScrollDistance.y/m_tScrollDistance.x > wh) { //// pos.x = -wh*(pos.y-pRight.y)+pRight.x; //// } else { // pos.y = -hw*(pos.x-pRight.x)+pRight.y; //// } // } // // } else if (pos.x > centerPoint.x && pos.y < centerPoint.y) { // // top left corner // if (pInside(pLeft,pTop,reversePos)) { //// if (m_tScrollDistance.x == 0 || -m_tScrollDistance.y/m_tScrollDistance.x > wh) { //// pos.x = wh*(pos.y-pBottom.y)+pBottom.x; //// } else { // pos.y = hw*(pos.x-pBottom.x)+pBottom.y; //// } // } // } } return true; }
CCPoint CAScrollView::maxBouncesLenght() { return ccpMult(m_obContentSize, 0.5f); }
void CAScrollView::deaccelerateScrolling(float delay) { if (m_tInertia.getLength() > maxSpeedCache(delay)) { m_tInertia = ccpMult(m_tInertia, maxSpeedCache(delay) / m_tInertia.getLength()); } CCPoint speed; if (m_tInertia.getLength() > maxSpeed(delay)) { speed = ccpMult(m_tInertia, maxSpeed(delay) / m_tInertia.getLength()); } else { speed = m_tInertia; } m_tInertia = ccpMult(m_tInertia, 1 - decelerationRatio(delay)); CCPoint point = m_pContainer->getCenterOrigin(); if (m_bBounces) { CCSize size = this->getContentSize(); CCSize cSize = m_pContainer->getFrame().size; cSize.width = MAX(cSize.width, size.width); cSize.height = MAX(cSize.height, size.height); CCPoint resilience = CCPointZero; if (point.x - cSize.width / 2 > 0) { resilience.x = (point.x - cSize.width / 2) / size.width; } if (point.y - cSize.height / 2 > 0) { resilience.y = (point.y - cSize.height / 2) / size.height; } if ((point.x + cSize.width / 2 - size.width) < 0) { resilience.x = (point.x + cSize.width / 2 - size.width) / size.width; } if ((point.y + cSize.height / 2 - size.height) < 0) { resilience.y = (point.y + cSize.height / 2 - size.height) / size.height; } resilience = ccpMult(resilience, maxBouncesSpeed(delay)); if (speed.getLength() < resilience.getLength()) { speed = ccpSub(speed, resilience); m_tInertia = CCPointZero; } } point = ccpAdd(point, speed); if (this->isScrollWindowNotMaxOutSide()) { m_tInertia = CCPointZero; } if (m_bBounces == false) { point = this->getScrollWindowNotOutPoint(point); } else { if (m_bBounceHorizontal == false) { point.x = this->getScrollWindowNotOutHorizontal(point.x); } if (m_bBounceVertical == false) { point.y = this->getScrollWindowNotOutVertical(point.y); } } if (m_pScrollViewDelegate && point.equals(m_pContainer->getCenter().origin) == false) { m_pScrollViewDelegate->scrollViewDidScroll(this); } m_bDecelerating = true; if (speed.getLength() <= 0.5f) { point = this->getScrollWindowNotOutPoint(point); m_bDecelerating = false; CCDirector::sharedDirector()->getScheduler()->unscheduleSelector(schedule_selector(CAScrollView::deaccelerateScrolling), this); } m_pContainer->setCenterOrigin(point); }
void CAButton::setControlState(const CAControlState& var) { CAControl::setControlState(var); CC_RETURN_IF(var == CAControlStateAll); for (int i=0; i<CAControlStateAll; i++) { this->removeSubview(m_pBackGroundView[i]); } m_eControlState = var; if (m_bControlStateLocked) { m_eControlState = CAControlStateNormal; } if (m_pBackGroundView[m_eControlState] && m_eControlState != CAControlStateNormal) { m_pBackGroundView[m_eControlState]->setFrame(this->getBounds()); this->insertSubview(m_pBackGroundView[m_eControlState], -1); } else if (m_pBackGroundView[CAControlStateNormal]) { m_pBackGroundView[CAControlStateNormal]->setFrame(this->getBounds()); this->insertSubview(m_pBackGroundView[CAControlStateNormal], -1); } if (m_eControlState == CAControlStateSelected) { m_bSelected = true; } else if(m_eControlState != CAControlStateHighlighted) { m_bSelected = false; } CAImage* image = NULL; std::string title = ""; CCRect imageViewCenter = CCRectZero; CCRect rect = CCRectZero; CCRect labelCenter = this->getBounds(); float labelSize = 0; image = m_pImage[m_eControlState]; title = m_sTitle[m_eControlState]; if (image == NULL) { image = this->isSelected() ? m_pImage[CAControlStateSelected] : m_pImage[CAControlStateNormal]; } if (strcmp(title.c_str(), "") == 0) { title = this->isSelected() ? m_sTitle[CAControlStateSelected] : m_sTitle[CAControlStateNormal]; } if (image && title.compare("") == 0) { CCSize size = this->getBounds().size; CCSize iSize = image->getContentSize(); float scaleX = size.width / iSize.width * 0.75f; float scaleY = size.height / iSize.height * 0.75f; float scale = MIN(scaleX, scaleY); scale = MIN(scale, 1.0f); iSize = ccpMult(iSize, scale); imageViewCenter.origin = size / 2; imageViewCenter.size = iSize; } else if (image == NULL && title.compare("") != 0) { labelSize = this->getBounds().size.height * 0.4f; labelCenter.origin = this->getBounds().size / 2 ; } else if (image && title.compare("") != 0) { CCSize size = this->getBounds().size; CCSize iSize = image->getContentSize(); float scaleX = size.width / iSize.width * 0.5f; float scaleY = size.height / iSize.height * 0.45f; float scale = MIN(scaleX, scaleY); scale = MIN(scale, 1.0f); iSize = ccpMult(iSize, scale); imageViewCenter.size = iSize; imageViewCenter.origin.x = size.width / 2; imageViewCenter.origin.y = size.height * 0.35f; labelSize = size.height * 0.2f; labelCenter.origin.x = size.width / 2; labelCenter.origin.y = size.height * 0.75f; } m_pImageView->setColor(m_sImageColor[m_eControlState]); m_pImageView->setCenter(imageViewCenter); if (image != m_pImageView->getImage()) { m_pImageView->setImage(image); } m_pLabel->setColor(m_sTitleColor[m_eControlState]); m_pLabel->setCenter(labelCenter); if (!title.empty()) { m_pLabel->setFontSize(labelSize); } if (strcmp(title.c_str(), m_pLabel->getText().c_str())) { m_pLabel->setText(title.c_str()); } }
void CCParticleSystem::initParticle(tCCParticle* particle) { // timeToLive // no negative life. prevent division by 0 particle->timeToLive = MAX(0, m_fLife + m_fLifeVar * CCRANDOM_MINUS1_1() ); // position particle->pos.x = m_tSourcePosition.x + m_tPosVar.x * CCRANDOM_MINUS1_1(); particle->pos.x *= CC_CONTENT_SCALE_FACTOR(); particle->pos.y = m_tSourcePosition.y + m_tPosVar.y * CCRANDOM_MINUS1_1(); particle->pos.y *= CC_CONTENT_SCALE_FACTOR(); // Color ccColor4F start; start.r = MIN(1, MAX(0, m_tStartColor.r + m_tStartColorVar.r * CCRANDOM_MINUS1_1() ) ); start.g = MIN(1, MAX(0, m_tStartColor.g + m_tStartColorVar.g * CCRANDOM_MINUS1_1() ) ); start.b = MIN(1, MAX(0, m_tStartColor.b + m_tStartColorVar.b * CCRANDOM_MINUS1_1() ) ); start.a = MIN(1, MAX(0, m_tStartColor.a + m_tStartColorVar.a * CCRANDOM_MINUS1_1() ) ); ccColor4F end; end.r = MIN(1, MAX(0, m_tEndColor.r + m_tEndColorVar.r * CCRANDOM_MINUS1_1() ) ); end.g = MIN(1, MAX(0, m_tEndColor.g + m_tEndColorVar.g * CCRANDOM_MINUS1_1() ) ); end.b = MIN(1, MAX(0, m_tEndColor.b + m_tEndColorVar.b * CCRANDOM_MINUS1_1() ) ); end.a = MIN(1, MAX(0, m_tEndColor.a + m_tEndColorVar.a * CCRANDOM_MINUS1_1() ) ); particle->color = start; particle->deltaColor.r = (end.r - start.r) / particle->timeToLive; particle->deltaColor.g = (end.g - start.g) / particle->timeToLive; particle->deltaColor.b = (end.b - start.b) / particle->timeToLive; particle->deltaColor.a = (end.a - start.a) / particle->timeToLive; // size float startS = MAX(0, m_fStartSize + m_fStartSizeVar * CCRANDOM_MINUS1_1() ); // no negative size startS *= CC_CONTENT_SCALE_FACTOR(); particle->size = startS; if( m_fEndSize == kCCParticleStartSizeEqualToEndSize ) { particle->deltaSize = 0; } else { float endS = m_fEndSize + m_fEndSizeVar * CCRANDOM_MINUS1_1(); endS = MAX(0, endS); endS *= CC_CONTENT_SCALE_FACTOR(); particle->deltaSize = (endS - startS) / particle->timeToLive; } // rotation float startA = m_fStartSpin + m_fStartSpinVar * CCRANDOM_MINUS1_1(); float endA = m_fEndSpin + m_fEndSpinVar * CCRANDOM_MINUS1_1(); particle->rotation = startA; particle->deltaRotation = (endA - startA) / particle->timeToLive; // position if( m_ePositionType == kCCPositionTypeFree ) { CGPoint p = this->convertToWorldSpace(CGPointZero); particle->startPos = ccpMult( p, CC_CONTENT_SCALE_FACTOR() ); } else if ( m_ePositionType == kCCPositionTypeRelative ) { particle->startPos = ccpMult( m_tPosition, CC_CONTENT_SCALE_FACTOR() ); } // direction float a = CC_DEGREES_TO_RADIANS( m_fAngle + m_fAngleVar * CCRANDOM_MINUS1_1() ); // Mode Gravity: A if( m_nEmitterMode == kCCParticleModeGravity ) { CGPoint v(cosf( a ), sinf( a )); float s = modeA.speed + modeA.speedVar * CCRANDOM_MINUS1_1(); s *= CC_CONTENT_SCALE_FACTOR(); // direction particle->modeA.dir = ccpMult( v, s ); // radial accel particle->modeA.radialAccel = modeA.radialAccel + modeA.radialAccelVar * CCRANDOM_MINUS1_1(); particle->modeA.radialAccel *= CC_CONTENT_SCALE_FACTOR(); // tangential accel particle->modeA.tangentialAccel = modeA.tangentialAccel + modeA.tangentialAccelVar * CCRANDOM_MINUS1_1(); particle->modeA.tangentialAccel *= CC_CONTENT_SCALE_FACTOR(); } // Mode Radius: B else { // Set the default diameter of the particle from the source position float startRadius = modeB.startRadius + modeB.startRadiusVar * CCRANDOM_MINUS1_1(); float endRadius = modeB.endRadius + modeB.endRadiusVar * CCRANDOM_MINUS1_1(); startRadius *= CC_CONTENT_SCALE_FACTOR(); endRadius *= CC_CONTENT_SCALE_FACTOR(); particle->modeB.radius = startRadius; if( modeB.endRadius == kCCParticleStartRadiusEqualToEndRadius ) particle->modeB.deltaRadius = 0; else particle->modeB.deltaRadius = (endRadius - startRadius) / particle->timeToLive; particle->modeB.angle = a; particle->modeB.degreesPerSecond = CC_DEGREES_TO_RADIANS(modeB.rotatePerSecond + modeB.rotatePerSecondVar * CCRANDOM_MINUS1_1()); } }
/// // Update does the work of mapping the texture onto the triangles for the bar // It now doesn't occur the cost of free/alloc data every update cycle. // It also only changes the percentage point but no other points if they have not // been modified. // // It now deals with flipped texture. If you run into this problem, just use the // sprite property and enable the methods flipX, flipY. /// void CCProgressTimer::updateBar() { if (!m_pSprite) { return; } float alpha = m_fPercentage / 100.0f; CCPoint alphaOffset = ccpMult(ccp(1.0f * (1.0f - m_tBarChangeRate.x) + alpha * m_tBarChangeRate.x, 1.0f * (1.0f - m_tBarChangeRate.y) + alpha * m_tBarChangeRate.y), 0.5f); CCPoint min = ccpSub(m_tMidpoint, alphaOffset); CCPoint max = ccpAdd(m_tMidpoint, alphaOffset); if (min.x < 0.f) { max.x += -min.x; min.x = 0.f; } if (max.x > 1.f) { min.x -= max.x - 1.f; max.x = 1.f; } if (min.y < 0.f) { max.y += -min.y; min.y = 0.f; } if (max.y > 1.f) { min.y -= max.y - 1.f; max.y = 1.f; } if (!m_bReverseDirection) { if(!m_pVertexData) { m_nVertexDataCount = 4; m_pVertexData = (ccV2F_C4B_T2F*)malloc(m_nVertexDataCount * sizeof(ccV2F_C4B_T2F)); CCAssert( m_pVertexData, "CCProgressTimer. Not enough memory"); } // TOPLEFT m_pVertexData[0].texCoords = textureCoordFromAlphaPoint(ccp(min.x,max.y)); m_pVertexData[0].vertices = vertexFromAlphaPoint(ccp(min.x,max.y)); // BOTLEFT m_pVertexData[1].texCoords = textureCoordFromAlphaPoint(ccp(min.x,min.y)); m_pVertexData[1].vertices = vertexFromAlphaPoint(ccp(min.x,min.y)); // TOPRIGHT m_pVertexData[2].texCoords = textureCoordFromAlphaPoint(ccp(max.x,max.y)); m_pVertexData[2].vertices = vertexFromAlphaPoint(ccp(max.x,max.y)); // BOTRIGHT m_pVertexData[3].texCoords = textureCoordFromAlphaPoint(ccp(max.x,min.y)); m_pVertexData[3].vertices = vertexFromAlphaPoint(ccp(max.x,min.y)); } else { if(!m_pVertexData) { m_nVertexDataCount = 8; m_pVertexData = (ccV2F_C4B_T2F*)malloc(m_nVertexDataCount * sizeof(ccV2F_C4B_T2F)); CCAssert( m_pVertexData, "CCProgressTimer. Not enough memory"); // TOPLEFT 1 m_pVertexData[0].texCoords = textureCoordFromAlphaPoint(ccp(0,1)); m_pVertexData[0].vertices = vertexFromAlphaPoint(ccp(0,1)); // BOTLEFT 1 m_pVertexData[1].texCoords = textureCoordFromAlphaPoint(ccp(0,0)); m_pVertexData[1].vertices = vertexFromAlphaPoint(ccp(0,0)); // TOPRIGHT 2 m_pVertexData[6].texCoords = textureCoordFromAlphaPoint(ccp(1,1)); m_pVertexData[6].vertices = vertexFromAlphaPoint(ccp(1,1)); // BOTRIGHT 2 m_pVertexData[7].texCoords = textureCoordFromAlphaPoint(ccp(1,0)); m_pVertexData[7].vertices = vertexFromAlphaPoint(ccp(1,0)); } // TOPRIGHT 1 m_pVertexData[2].texCoords = textureCoordFromAlphaPoint(ccp(min.x,max.y)); m_pVertexData[2].vertices = vertexFromAlphaPoint(ccp(min.x,max.y)); // BOTRIGHT 1 m_pVertexData[3].texCoords = textureCoordFromAlphaPoint(ccp(min.x,min.y)); m_pVertexData[3].vertices = vertexFromAlphaPoint(ccp(min.x,min.y)); // TOPLEFT 2 m_pVertexData[4].texCoords = textureCoordFromAlphaPoint(ccp(max.x,max.y)); m_pVertexData[4].vertices = vertexFromAlphaPoint(ccp(max.x,max.y)); // BOTLEFT 2 m_pVertexData[5].texCoords = textureCoordFromAlphaPoint(ccp(max.x,min.y)); m_pVertexData[5].vertices = vertexFromAlphaPoint(ccp(max.x,min.y)); } updateColor(); }
CCPoint ccpLerp(CCPoint a, CCPoint b, float alpha) { return ccpAdd(ccpMult(a, 1.f - alpha), ccpMult(b, alpha)); }
CCPoint ccpNormalize(const CCPoint v) { return ccpMult(v, 1.0f/ccpLength(v)); }
CCPoint ccpLerp(const CCPoint& a, const CCPoint& b, float alpha) { return ccpAdd(ccpMult(a, 1.f - alpha), ccpMult(b, alpha)); }
void CCParticleSystemFrameQuad::update(float dt) { CC_PROFILER_START_CATEGORY(kCCProfilerCategoryParticles , "CCParticleSystemFrameQuad - update"); if (m_bIsActive && m_fEmissionRate) { float rate = 1.0f / m_fEmissionRate; //issue #1201, prevent bursts of particles, due to too high emitCounter if (m_uParticleCount < m_uTotalParticles) { m_fEmitCounter += dt; } while (m_uParticleCount < m_uTotalParticles && m_fEmitCounter > rate) { this->addParticle(); m_fEmitCounter -= rate; } m_fElapsed += dt; if (m_fDuration != -1 && m_fDuration < m_fElapsed) { this->stopSystem(); } } m_uParticleIdx = 0; CCPoint currentPosition = CCPointZero; if (m_ePositionType == kCCPositionTypeFree) { currentPosition = this->convertToWorldSpace(CCPointZero); } else if (m_ePositionType == kCCPositionTypeRelative) { currentPosition = m_obPosition; } if (m_bVisible) { while (m_uParticleIdx < m_uParticleCount) { tCCParticle *p = &m_pParticles[m_uParticleIdx]; // life p->timeToLive -= dt; if (p->timeToLive > 0) { // Mode A: gravity, direction, tangential accel & radial accel if (m_nEmitterMode == kCCParticleModeGravity) { CCPoint tmp, radial, tangential; radial = CCPointZero; // radial acceleration if (p->pos.x || p->pos.y) { radial = ccpNormalize(p->pos); } tangential = radial; radial = ccpMult(radial, p->modeA.radialAccel); // tangential acceleration float newy = tangential.x; tangential.x = -tangential.y; tangential.y = newy; tangential = ccpMult(tangential, p->modeA.tangentialAccel); // (gravity + radial + tangential) * dt tmp = ccpAdd( ccpAdd( radial, tangential), modeA.gravity); tmp = ccpMult( tmp, dt); p->modeA.dir = ccpAdd( p->modeA.dir, tmp); tmp = ccpMult(p->modeA.dir, dt); p->pos = ccpAdd( p->pos, tmp ); } // Mode B: radius movement else { // Update the angle and radius of the particle. p->modeB.angle += p->modeB.degreesPerSecond * dt; p->modeB.radius += p->modeB.deltaRadius * dt; p->pos.x = - cosf(p->modeB.angle) * p->modeB.radius; p->pos.y = - sinf(p->modeB.angle) * p->modeB.radius; } // color p->color.r += (p->deltaColor.r * dt); p->color.g += (p->deltaColor.g * dt); p->color.b += (p->deltaColor.b * dt); p->color.a += (p->deltaColor.a * dt); // size p->size += (p->deltaSize * dt); p->size = MAX( 0, p->size ); // angle p->rotation += (p->deltaRotation * dt); // // update values in quad // CCPoint newPos; if (m_ePositionType == kCCPositionTypeFree || m_ePositionType == kCCPositionTypeRelative) { CCPoint diff = ccpSub( currentPosition, p->startPos ); newPos = ccpSub(p->pos, diff); } else { newPos = p->pos; } // translate newPos to correct position, since matrix transform isn't performed in batchnode // don't update the particle with the new position information, it will interfere with the radius and tangential calculations if (m_pBatchNode) { newPos.x+=m_obPosition.x; newPos.y+=m_obPosition.y; } updateQuadWithParticle(p, newPos); //updateParticleImp(self, updateParticleSel, p, newPos); // update particle counter ++m_uParticleIdx; } else { // life < 0 int currentIndex = p->atlasIndex; if( m_uParticleIdx != m_uParticleCount-1 ) { m_pParticles[m_uParticleIdx] = m_pParticles[m_uParticleCount-1]; } if (m_pBatchNode) { //disable the switched particle m_pBatchNode->disableParticle(m_uAtlasIndex+currentIndex); //switch indexes m_pParticles[m_uParticleCount-1].atlasIndex = currentIndex; } else if( m_uParticleIdx != m_uParticleCount-1 ) { //switch quads texCoords ccV3F_C4B_T2F_Quad temp = m_pQuads[m_uParticleIdx]; m_pQuads[m_uParticleIdx] = m_pQuads[m_uParticleCount-1]; m_pQuads[m_uParticleCount-1] = temp; } --m_uParticleCount; if( m_uParticleCount == 0 && m_bIsAutoRemoveOnFinish ) { this->unscheduleUpdate(); m_pParent->removeChild(this, true); return; } } } //while m_bTransformSystemDirty = false; } if (! m_pBatchNode) { postStep(); } CC_PROFILER_STOP_CATEGORY(kCCProfilerCategoryParticles , "CCParticleSystemFrameQuad - update"); }
void MapObject::modifyPoint(ContactPoint *point, const cocos2d::CCPoint offset, const float radius) { point->offset = ccpMult(offset, kPointFactor); point->radius = radius * kPointFactor; point->position = ccpAdd(this->getPosition(), point->offset); }
bool RigSimilar(const Rig& compare, const Rig& index, float& similarity) { // Calculate the difference between the two rigs being compared in size. int difference = abs(compare.size() - index.size()); // Threshold of comparison = the bigger one. int del = MAX(compare.size(), index.size()); float percentage = (float)difference / (float)del; // The below is basically found through trial and error, when there are over 25% difference in the number of vertexes it seems displeasing to the eye. if( percentage > 0.25 ) return false; // Ignore the BADLY NAMED variables below - the smaller/bigger rig has nothing to do with the results. Rig smallerRig = compare; Rig biggerRig = index; /* // This code has been commented out as I've updated the function so that it doesn't need to know which rig is smaller/bigger. for(Rig::iterator curPos = biggerRig.begin(); curPos != biggerRig.end();) { Rig::iterator nextPos = curPos + 1; if(nextPos == biggerRig.end()) nextPos = biggerRig.begin(); CCPoint curPoint = (*curPos); CCPoint nextPoint = (*nextPos); if(ccpDistance(curPoint, nextPoint) < tolerance) { curPos = biggerRig.erase(nextPos); } else { curPos++; } } */ // Calculate the center of mass for the smaller rig. // RigCenter basically returns the coordinate of all points added divided by the number of vertexes. // Normalize the points to the center. const CCPoint smallerMid = RigCenter(smallerRig); for(int i = 0; i < smallerRig.size(); i++) { smallerRig[i] = ccpSub(smallerRig[i], smallerMid); } const CCPoint biggerMid = RigCenter(biggerRig); for(int i = 0; i < biggerRig.size(); i++) { biggerRig[i] = ccpSub(biggerRig[i], biggerMid); } // Rig area does some matrix magic to calculate the area of the rig. float smallerArea = RigArea(smallerRig); float biggerArea = RigArea(biggerRig); // Scale the rig so that there wouldn't be big differences in overlaps when comparing similar points. float scale = sqrtf(biggerArea/smallerArea); for(int i = 0; i < smallerRig.size(); i++) { smallerRig[i] = ccpMult(smallerRig[i], scale); } // FIXFIX:: The problem right now is that the Rig's centers are focus around the origin (0,0). That is retarded - fix this so that they will be focused around the centroid. int nearPoints = 0; for(int i = 0; i < smallerRig.size(); i++) { CCPoint curPoint = smallerRig[i]; for(int v = 0; v < biggerRig.size(); v++) { if(PointToleranceEquals(biggerRig[v], curPoint)) { nearPoints++; break; } } } // Double iteration to find the closest points Rig combination = biggerRig; for(int i = 0; i < smallerRig.size(); i++) { CCPoint curPoint = smallerRig[i]; bool skip = false; for(int v = 0; v < combination.size(); v++) { // The function below is a very simple function that gives a bit of tolerence for equality when comparing nearby points. This accounts for humans not having perfect eyesight. if(PointToleranceEquals(combination[v], curPoint)) { skip = true; } } if(!skip) combination.push_back(curPoint); } //Notice how I'm using smaller size instead of bigger rig's. //This is because rig2 is the goal polygon - (lol refactor this so it has better naming.) //return nearPoints == compare.size(); similarity = (float)nearPoints / combination.size(); // If the similarity is over 1, it means that the goal polygon is smaller than the comparing polygon. return similarity >= 0.75f && similarity <= 1.f; }
/// // Update does the work of mapping the texture onto the triangles // It now doesn't occur the cost of free/alloc data every update cycle. // It also only changes the percentage point but no other points if they have not // been modified. // // It now deals with flipped texture. If you run into this problem, just use the // sprite property and enable the methods flipX, flipY. /// void CCProgressTimer::updateRadial() { if (!m_pSprite) { return; } float alpha = m_fPercentage / 100.f; float angle = 2.f*((float)M_PI) * ( m_bReverseDirection ? alpha : 1.0f - alpha); // We find the vector to do a hit detection based on the percentage // We know the first vector is the one @ 12 o'clock (top,mid) so we rotate // from that by the progress angle around the m_tMidpoint pivot CCPoint topMid = ccp(m_tMidpoint.x, 1.f); CCPoint percentagePt = ccpRotateByAngle(topMid, m_tMidpoint, angle); int index = 0; CCPoint hit = CCPoint::zero; if (alpha == 0.f) { // More efficient since we don't always need to check intersection // If the alpha is zero then the hit point is top mid and the index is 0. hit = topMid; index = 0; } else if (alpha == 1.f) { // More efficient since we don't always need to check intersection // If the alpha is one then the hit point is top mid and the index is 4. hit = topMid; index = 4; } else { // We run a for loop checking the edges of the texture to find the // intersection point // We loop through five points since the top is split in half float min_t = FLT_MAX; for (int i = 0; i <= kProgressTextureCoordsCount; ++i) { int pIndex = (i + (kProgressTextureCoordsCount - 1))%kProgressTextureCoordsCount; CCPoint edgePtA = boundaryTexCoord(i % kProgressTextureCoordsCount); CCPoint edgePtB = boundaryTexCoord(pIndex); // Remember that the top edge is split in half for the 12 o'clock position // Let's deal with that here by finding the correct endpoints if(i == 0){ edgePtB = ccpLerp(edgePtA, edgePtB, 1-m_tMidpoint.x); } else if(i == 4){ edgePtA = ccpLerp(edgePtA, edgePtB, 1-m_tMidpoint.x); } // s and t are returned by ccpLineIntersect float s = 0, t = 0; if(ccpLineIntersect(edgePtA, edgePtB, m_tMidpoint, percentagePt, &s, &t)) { // Since our hit test is on rays we have to deal with the top edge // being in split in half so we have to test as a segment if ((i == 0 || i == 4)) { // s represents the point between edgePtA--edgePtB if (!(0.f <= s && s <= 1.f)) { continue; } } // As long as our t isn't negative we are at least finding a // correct hitpoint from m_tMidpoint to percentagePt. if (t >= 0.f) { // Because the percentage line and all the texture edges are // rays we should only account for the shortest intersection if (t < min_t) { min_t = t; index = i; } } } } // Now that we have the minimum magnitude we can use that to find our intersection hit = ccpAdd(m_tMidpoint, ccpMult(ccpSub(percentagePt, m_tMidpoint),min_t)); } // The size of the vertex data is the index from the hitpoint // the 3 is for the m_tMidpoint, 12 o'clock point and hitpoint position. bool sameIndexCount = true; if(m_nVertexDataCount != index + 3){ sameIndexCount = false; CC_SAFE_FREE(m_pVertexData); m_nVertexDataCount = 0; } if(!m_pVertexData) { m_nVertexDataCount = index + 3; m_pVertexData = (ccV2F_C4B_T2F*)malloc(m_nVertexDataCount * sizeof(ccV2F_C4B_T2F)); CCAssert( m_pVertexData, "CCProgressTimer. Not enough memory"); } updateColor(); if (!sameIndexCount) { // First we populate the array with the m_tMidpoint, then all // vertices/texcoords/colors of the 12 'o clock start and edges and the hitpoint m_pVertexData[0].texCoords = textureCoordFromAlphaPoint(m_tMidpoint); m_pVertexData[0].vertices = vertexFromAlphaPoint(m_tMidpoint); m_pVertexData[1].texCoords = textureCoordFromAlphaPoint(topMid); m_pVertexData[1].vertices = vertexFromAlphaPoint(topMid); for(int i = 0; i < index; ++i){ CCPoint alphaPoint = boundaryTexCoord(i); m_pVertexData[i+2].texCoords = textureCoordFromAlphaPoint(alphaPoint); m_pVertexData[i+2].vertices = vertexFromAlphaPoint(alphaPoint); } } // hitpoint will go last m_pVertexData[m_nVertexDataCount - 1].texCoords = textureCoordFromAlphaPoint(hit); m_pVertexData[m_nVertexDataCount - 1].vertices = vertexFromAlphaPoint(hit); }
void PaintLayer::drawLines(CCArray *linePoints, ccColor4F color) { unsigned int numberOfVertices = (linePoints->count() - 1) * 18; LineVertex *vertices = (LineVertex *)calloc(sizeof(LineVertex), numberOfVertices); CCPoint prevPoint = ((LinePoint *)linePoints->objectAtIndex(0))->pos; float prevValue = ((LinePoint *)linePoints->objectAtIndex(0))->width; float curValue; int index = 0; for (int i = 1; i < linePoints->count(); ++i) { LinePoint *pointValue = (LinePoint *)linePoints->objectAtIndex(i); CCPoint curPoint = pointValue->pos; curValue = pointValue->width; //! equal points, skip them if (ccpFuzzyEqual(curPoint, prevPoint, 0.0001f)) { continue; } CCPoint dir = ccpSub(curPoint, prevPoint); CCPoint perpendicular = ccpNormalize(ccpPerp(dir)); CCPoint A = ccpAdd(prevPoint, ccpMult(perpendicular, prevValue / 2)); CCPoint B = ccpSub(prevPoint, ccpMult(perpendicular, prevValue / 2)); CCPoint C = ccpAdd(curPoint, ccpMult(perpendicular, curValue / 2)); CCPoint D = ccpSub(curPoint, ccpMult(perpendicular, curValue / 2)); //! continuing line if (connectingLine || index > 0) { A = prevC; B = prevD; } else if (index == 0) { //! circle at start of line, revert direction circlesPoints->addObject(pointValue); circlesPoints->addObject(linePoints->objectAtIndex(i-1)); } ADD_TRIANGLE(A, B, C, 1.0f); ADD_TRIANGLE(B, C, D, 1.0f); prevD = D; prevC = C; if (finishingLine && (i == linePoints->count() - 1)) { circlesPoints->addObject(linePoints->objectAtIndex(i-1)); circlesPoints->addObject(pointValue); finishingLine = false; } prevPoint = curPoint; prevValue = curValue; //! Add overdraw CCPoint F = ccpAdd(A, ccpMult(perpendicular, overdraw)); CCPoint G = ccpAdd(C, ccpMult(perpendicular, overdraw)); CCPoint H = ccpSub(B, ccpMult(perpendicular, overdraw)); CCPoint I = ccpSub(D, ccpMult(perpendicular, overdraw)); //! end vertices of last line are the start of this one, also for the overdraw if (connectingLine || index > 6) { F = prevG; H = prevI; } prevG = G; prevI = I; ADD_TRIANGLE(F, A, G, 2.0f); ADD_TRIANGLE(A, G, C, 2.0f); ADD_TRIANGLE(B, H, D, 2.0f); ADD_TRIANGLE(H, D, I, 2.0f); } this->fillLineTriangles(vertices, index, color); if (index > 0) { connectingLine = true; } free(vertices); }
NS_CC_BEGIN void ccVertexLineToPolygon(DPoint *points, float stroke, ccVertex2F *vertices, unsigned int offset, unsigned int nuPoints) { nuPoints += offset; if(nuPoints<=1) return; stroke *= 0.5f; unsigned int idx; unsigned int nuPointsMinus = nuPoints-1; for(unsigned int i = offset; i<nuPoints; i++) { idx = i*2; DPoint p1 = points[i]; DPoint perpVector; if(i == 0) perpVector = ccpPerp(ccpNormalize(ccpSub(p1, points[i+1]))); else if(i == nuPointsMinus) perpVector = ccpPerp(ccpNormalize(ccpSub(points[i-1], p1))); else { DPoint p2 = points[i+1]; DPoint p0 = points[i-1]; DPoint p2p1 = ccpNormalize(ccpSub(p2, p1)); DPoint p0p1 = ccpNormalize(ccpSub(p0, p1)); // Calculate angle between vectors float angle = acosf(ccpDot(p2p1, p0p1)); if(angle < CC_DEGREES_TO_RADIANS(70)) perpVector = ccpPerp(ccpNormalize(ccpMidpoint(p2p1, p0p1))); else if(angle < CC_DEGREES_TO_RADIANS(170)) perpVector = ccpNormalize(ccpMidpoint(p2p1, p0p1)); else perpVector = ccpPerp(ccpNormalize(ccpSub(p2, p0))); } perpVector = ccpMult(perpVector, stroke); vertices[idx] = vertex2(p1.x+perpVector.x, p1.y+perpVector.y); vertices[idx+1] = vertex2(p1.x-perpVector.x, p1.y-perpVector.y); } // Validate vertexes offset = (offset==0) ? 0 : offset-1; for(unsigned int i = offset; i<nuPointsMinus; i++) { idx = i*2; const unsigned int idx1 = idx+2; ccVertex2F p1 = vertices[idx]; ccVertex2F p2 = vertices[idx+1]; ccVertex2F p3 = vertices[idx1]; ccVertex2F p4 = vertices[idx1+1]; float s; //BOOL fixVertex = !ccpLineIntersect(DPoint(p1.x, p1.y), DPoint(p4.x, p4.y), DPoint(p2.x, p2.y), DPoint(p3.x, p3.y), &s, &t); bool fixVertex = !ccVertexLineIntersect(p1.x, p1.y, p4.x, p4.y, p2.x, p2.y, p3.x, p3.y, &s); if(!fixVertex) if (s<0.0f || s>1.0f) fixVertex = true; if(fixVertex) { vertices[idx1] = p4; vertices[idx1+1] = p3; } } }
CCPoint CAScrollView::getContentOffset() { return ccpMult(m_pContainer->getFrameOrigin(), -1); }
// ParticleSystem - MainLoop void CCParticleSystem::update(ccTime dt) { if( m_bIsActive && m_fEmissionRate ) { float rate = 1.0f / m_fEmissionRate; m_fEmitCounter += dt; while( m_nParticleCount < m_nTotalParticles && m_fEmitCounter > rate ) { this->addParticle(); m_fEmitCounter -= rate; } m_fElapsed += dt; if(m_fDuration != -1 && m_fDuration < m_fElapsed) { this->stopSystem(); } } m_nParticleIdx = 0; #if CC_ENABLE_PROFILERS /// @todo CCProfilingBeginTimingBlock(_profilingTimer); #endif CGPoint currentPosition = CGPointZero; if( m_ePositionType == kCCPositionTypeFree ) { currentPosition = this->convertToWorldSpace(CGPointZero); currentPosition.x *= CC_CONTENT_SCALE_FACTOR(); currentPosition.y *= CC_CONTENT_SCALE_FACTOR(); } else if ( m_ePositionType == kCCPositionTypeRelative ) { currentPosition = m_tPosition; currentPosition.x *= CC_CONTENT_SCALE_FACTOR(); currentPosition.y *= CC_CONTENT_SCALE_FACTOR(); } while( m_nParticleIdx < m_nParticleCount ) { tCCParticle *p = &m_pParticles[m_nParticleIdx]; // life p->timeToLive -= dt; if( p->timeToLive > 0 ) { // Mode A: gravity, direction, tangential accel & radial accel if( m_nEmitterMode == kCCParticleModeGravity ) { CGPoint tmp, radial, tangential; radial = CGPointZero; // radial acceleration if(p->pos.x || p->pos.y) radial = ccpNormalize(p->pos); tangential = radial; radial = ccpMult(radial, p->modeA.radialAccel); // tangential acceleration float newy = tangential.x; tangential.x = -tangential.y; tangential.y = newy; tangential = ccpMult(tangential, p->modeA.tangentialAccel); // (gravity + radial + tangential) * dt tmp = ccpAdd( ccpAdd( radial, tangential), modeA.gravity); tmp = ccpMult( tmp, dt); p->modeA.dir = ccpAdd( p->modeA.dir, tmp); tmp = ccpMult(p->modeA.dir, dt); p->pos = ccpAdd( p->pos, tmp ); } // Mode B: radius movement else { // Update the angle and radius of the particle. p->modeB.angle += p->modeB.degreesPerSecond * dt; p->modeB.radius += p->modeB.deltaRadius * dt; p->pos.x = - cosf(p->modeB.angle) * p->modeB.radius; p->pos.y = - sinf(p->modeB.angle) * p->modeB.radius; } // color p->color.r += (p->deltaColor.r * dt); p->color.g += (p->deltaColor.g * dt); p->color.b += (p->deltaColor.b * dt); p->color.a += (p->deltaColor.a * dt); // size p->size += (p->deltaSize * dt); p->size = MAX( 0, p->size ); // angle p->rotation += (p->deltaRotation * dt); // // update values in quad // CGPoint newPos; if( m_ePositionType == kCCPositionTypeFree || m_ePositionType == kCCPositionTypeRelative ) { CGPoint diff = ccpSub( currentPosition, p->startPos ); newPos = ccpSub(p->pos, diff); } else { newPos = p->pos; } updateQuadWithParticle(p, newPos); //updateParticleImp(self, updateParticleSel, p, newPos); // update particle counter ++m_nParticleIdx; } else { // life < 0 if( m_nParticleIdx != m_nParticleCount-1 ) { m_pParticles[m_nParticleIdx] = m_pParticles[m_nParticleCount-1]; } --m_nParticleCount; if( m_nParticleCount == 0 && m_bIsAutoRemoveOnFinish ) { this->unscheduleUpdate(); m_pParent->removeChild(this, true); return; } } } #if CC_ENABLE_PROFILERS /// @todo CCProfilingEndTimingBlock(_profilingTimer); #endif //#ifdef CC_USES_VBO this->postStep(); //#endif }
void CATabBar::showItems() { do { CC_BREAK_IF(m_pViews.empty() == false); unsigned int count = MIN(m_nMaxShowCount, m_pItems.size()); float width = m_obContentSize.width / count; float height = m_obContentSize.height; m_cItemSize = CCSize(width, height); for (unsigned int i=0; i<count; i++) { CAView* view = CAView::createWithFrame(CCRect(i * width, 0, width, height), ccc4(0, 0, 0, 0)); this->insertSubview(view, 3); view->setDisplayRange(false); m_pViews.push_back(view); CAImageView* imageView = NULL; CCLabelTTF* title = NULL; if (m_pItems.at(i)->getImage()) { imageView = CAImageView::createWithImage(m_pItems.at(i)->getImage()); imageView->setTag(0xffff); view->addSubview(imageView); } if (m_pItems.at(i)->getTitle().compare("") != 0) { int fontSize = this->getContentSize().height / 5.0f; title = CCLabelTTF::create(m_pItems.at(i)->getTitle().c_str(), "Arial", fontSize); title->setTag(0xfffe); view->addSubview(title); } if (imageView && title == NULL) { CCSize imageViewSize = imageView->getBounds().size; float scaleX = width / imageViewSize.width * 2/3.0f; float scaleY = height / imageViewSize.height * 2/3.0f; float scale = MIN(scaleX, scaleY); scale = MIN(scale, 1.0f); imageViewSize = ccpMult(imageViewSize, scale); CCRect rect; rect.origin = view->getBounds().size/2; rect.size = imageViewSize; imageView->setCenter(rect); } else if (title && imageView == NULL) { int fontSize = this->getContentSize().height / 2.0f; title->setFontSize(fontSize); CCSize titleSize = title->getBounds().size; float titleScale = height / titleSize.height * 1/2.0f; titleSize = ccpMult(titleSize, titleScale); CCRect rect; rect.origin = view->getBounds().size/2; rect.size = titleSize; title->setCenter(rect); } else if (title && imageView) { CCSize imageViewSize = imageView->getBounds().size; float scaleX = width / imageViewSize.width * 1/2.0f; float scaleY = height / imageViewSize.height * 1/2.0f; float scale = MIN(scaleX, scaleY); scale = MIN(scale, 1.0f); imageViewSize = ccpMult(imageViewSize, scale); CCRect rect; rect.size = imageViewSize; rect.origin = view->getBounds().size; rect.origin.x *= 1/2.0f; rect.origin.y *= 7/20.0f; imageView->setCenter(rect); CCSize titleSize = title->getBounds().size; float titleScale = height / titleSize.height * 3/10; titleSize = ccpMult(titleSize, titleScale); CCRect rect2; rect2.size = titleSize; rect2.origin = view->getBounds().size; rect2.origin.x *= 1/2.0f; rect2.origin.y *= 15/20.0f; title->setCenter(rect2); } } } while (0); }
void JoyStickLayer::update(float t) { if(INSTANCE(FightManager)->enoughAnger()){ skillBtn->setEnabled(true); skillPro->setPercentage(100); }else{ skillBtn->setEnabled(false); skillPro->setPercentage(INSTANCE(FightManager)->getAnger() * 100); } if(INSTANCE(GuideManager)->getIsGuiding()){ GuideStep step = INSTANCE(GuideManager)->getCurrentStep(); if(step == GuideStep_10007){ skillBtn->setEnabled(true); } if(step == GuideStep_10003 || step == GuideStep_10004 ||step == GuideStep_10006 || step == GuideStep_10007 || step == GuideStep_10003){ if(!attackBtn->isEnabled()){ attackBtn->setEnabled(true); } }else{ if(attackBtn->isEnabled()){ attackBtn->setEnabled(false); } } }else{ if(!attackBtn->isEnabled()){ attackBtn->setEnabled(true); } } if(attackBtn->isHighlighted()) { CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_attack)); return; } if(skillBtn->isHighlighted()){ CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_skill)); return; } CCPoint poi = ccpMult(joystick->getVelocity(), 50); if(poi.x == 0 && poi.y == 0){ if(lastPoi.x !=0 || lastPoi.y != 0){ CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_none)); lastPoi = poi; } return; } lastPoi = poi; float degree = atan2(poi.y, poi.x)*180/atan2(0.0, -1.0); if(degree <0){ degree += 360; } if(degree >= 22.5 && degree < 67.5){ //右上 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_right_up)); }else if(degree >= 67.5 && degree < 112.5){ //上 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_up)); }else if(degree >= 112.5 && degree < 157.5){ //左上 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_left_up)); }else if(degree >= 157.5 && degree < 202.5){ //左 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_left)); }else if(degree >= 202.5 && degree < 247.5){ //左下 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_left_down)); }else if(degree >= 247.5 && degree < 292.5){ //下 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_down)); }else if(degree >= 292.5 && degree < 337.5){ //右下 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_right_down)); }else{ //右 CCNotificationCenter::sharedNotificationCenter()->postNotification(JoyStick_status,CCStringMake(JoyStick_right)); } }
void CATableView::ccTouchEnded(CATouch *pTouch, CAEvent *pEvent) { CAScrollView::ccTouchEnded(pTouch, pEvent); if (m_pHighlightedTableCells) { m_pContainer->stopAllActions(); CAIndexPath2E deselectedIndexPath = CAIndexPath2EZero; CAIndexPath2E selectedIndexPath = CAIndexPath2E(m_pHighlightedTableCells->getSection(), m_pHighlightedTableCells->getRow()); m_pHighlightedTableCells = NULL; if (m_pSelectedTableCells.count(selectedIndexPath) > 0 && m_bAllowsMultipleSelection) { deselectedIndexPath = selectedIndexPath; selectedIndexPath = CAIndexPath2EZero; m_pSelectedTableCells.erase(deselectedIndexPath); } else { if (!m_pSelectedTableCells.empty() && m_bAllowsMultipleSelection == false) { deselectedIndexPath = *m_pSelectedTableCells.begin(); m_pSelectedTableCells.clear(); } m_pSelectedTableCells.insert(selectedIndexPath); } if (deselectedIndexPath != CAIndexPath2EZero) { if (CATableViewCell* cell = m_pUsedTableCells[deselectedIndexPath]) { cell->setControlStateNormal(); } if (m_pTableViewDelegate) { m_pTableViewDelegate->tableViewDidDeselectRowAtIndexPath(this, deselectedIndexPath.section, deselectedIndexPath.row); } } if (selectedIndexPath != CAIndexPath2EZero) { if (CATableViewCell* cell = m_pUsedTableCells[selectedIndexPath]) { cell->setControlStateSelected(); } if (m_pTableViewDelegate) { m_pTableViewDelegate->tableViewDidSelectRowAtIndexPath(this, selectedIndexPath.section, selectedIndexPath.row); } } } if (m_pTableViewDelegate && m_nTablePullViewHeight > 0) { CCPoint point = m_pContainer->getFrameOrigin(); if (m_pTablePullDownView && point.y >= m_nTablePullViewHeight) { m_bToUpdate = CATableViewToUpdatePullDown; point.y = m_nTablePullViewHeight; this->setContentOffset(ccpMult(point, -1), true); } if (m_pTablePullUpView && point.y <= this->getBounds().size.height - m_pContainer->getFrame().size.height - m_nTablePullViewHeight) { m_bToUpdate = CATableViewToUpdatePullUp; point.y = this->getBounds().size.height - m_pContainer->getFrame().size.height - m_nTablePullViewHeight; this->setContentOffset(ccpMult(point, -1), true); } } }