void CCFollow::step(ccTime dt)
{
    CC_UNUSED_PARAM(dt);

	CCPoint oldPos = m_pTarget->getPosition();
	CCPoint pos;

	if(m_bBoundarySet)
	{
		// whole map fits inside a single screen, no need to modify the position - unless map boundaries are increased
		if(m_bBoundaryFullyCovered)
			return;

		CCPoint tempPos = ccpSub( m_obHalfScreenSize, m_pobFollowedNode->getPosition());

		pos = ccp(clampf(tempPos.x, m_fLeftBoundary, m_fRightBoundary), 
								   clampf(tempPos.y, m_fBottomBoundary, m_fTopBoundary));
	}
	else
	{
		pos = ccpSub(m_obHalfScreenSize, m_pobFollowedNode->getPosition());
	}

	CCPoint moveVect;

	double dist = ccpDistance(pos, oldPos);

	if(dist > 1){
		moveVect = ccpMult(ccpSub(pos, oldPos), 0.05);
		oldPos = ccpAdd(oldPos, moveVect);
		m_pTarget->setPosition(oldPos);
	}
}

// Estimate the velocity of the new point relative to previous points
// in points/second.
void LineSmoother::CalculateVelocities(uint32 newPointIndex)
{

   const float TS_MIN = 0.010f;  // 5 ms
   const float TS_MAX = 0.100f;  // 100 ms
   
   if(newPointIndex < 3)
   {  // Must be the first couple of points.
      _orgPoints[newPointIndex].pointsPerSecond = PPS_MIN;
   }
   else
   {
      
      ORIGINAL_POINT& p0 = _orgPoints[newPointIndex-2];
      ORIGINAL_POINT& p1 = _orgPoints[newPointIndex-1];
      ORIGINAL_POINT& p2 = _orgPoints[newPointIndex-0];
      
      float dist = ccpDistance(p2.point, p1.point);
      float dt = clampf(p2.timestamp-p1.timestamp,TS_MIN,TS_MAX);
      
      float ppsRaw = clampf(dist/dt,PPS_MIN,PPS_MAX);
      // The velocity is the mostly the previous and some of the current point.
      p2.pointsPerSecond = (ppsRaw + p1.pointsPerSecond + p0.pointsPerSecond)/3.0;
      // Round to the nearest 10 pps.
      //      p2.pointsPerSecond = roundf(p2.pointsPerSecond/25)*25;
      /*
      CCLOG("PPS(final):%f, dist:%f, dt:%f ms, PPS(raw):%f, PPS(rawClamped):%f",
            p2.pointsPerSecond,
            dist,
            dt*1000,
            dist/dt,
            ppsRaw);
       */
   }
}

void CGraphics_Threaded::SetColorVertex(const CColorVertex *pArray, int Num)
{
	dbg_assert(m_Drawing != 0, "called Graphics()->SetColorVertex without begin");

	for(int i = 0; i < Num; ++i)
	{
		if(m_UseOpenGL3_3)
		{
			float r = pArray[i].m_R, g = pArray[i].m_G, b = pArray[i].m_B, a = pArray[i].m_A;
			clampf(r, 0.f, 1.f);
			clampf(g, 0.f, 1.f);
			clampf(b, 0.f, 1.f);
			clampf(a, 0.f, 1.f);
			m_aColor[pArray[i].m_Index].r = (unsigned char)(r*255.f);
			m_aColor[pArray[i].m_Index].g = (unsigned char)(g*255.f);
			m_aColor[pArray[i].m_Index].b = (unsigned char)(b*255.f);
			m_aColor[pArray[i].m_Index].a = (unsigned char)(a*255.f);
		} 
		else
		{				
			m_aColorOld[pArray[i].m_Index].r = pArray[i].m_R;
			m_aColorOld[pArray[i].m_Index].g = pArray[i].m_G;
			m_aColorOld[pArray[i].m_Index].b = pArray[i].m_B;
			m_aColorOld[pArray[i].m_Index].a = pArray[i].m_A;
		}
	}
}

v3dmc_color rgbf(GLclampf r, GLclampf g, GLclampf b){
	v3dmc_color color;
	color.r = clampf(r);
	color.g = clampf(g);
	color.b = clampf(b);
	color.a = 1.0;
	return color;
}

v3dmc_color rgbai(GLint r, GLint g, GLint b, GLint a){
	v3dmc_color color;
	color.r = clampf((float)r/255.0);
	color.g = clampf((float)g/255.0);
	color.b = clampf((float)b/255.0);
	color.a = clampf((float)a/255.0);
	return color;
}

v3dmc_color rgbaf(GLclampf r, GLclampf g, GLclampf b, GLclampf a){
	v3dmc_color color;
	color.r = clampf(r);
	color.g = clampf(g);
	color.b = clampf(b);
	color.a = clampf(a);
	return color;
}

v3dmc_color rgbi(GLint r, GLint g, GLint b){
	v3dmc_color color;
	color.r = clampf((float)r/255.0);
	color.g = clampf((float)g/255.0);
	color.b = clampf((float)b/255.0);
	color.a = 1.0;
	return color;
} 

Point GameCamera::clamp(Rect _b, Point _p)
{
	if (Rect::ZERO.equals(_b)) return _p;

	return Point(
		clampf(_p.x, _b.getMinX(), _b.getMaxX()),
		clampf(_p.y, _b.getMinY(), _b.getMaxY())
		);
}

		explicit color(float r, float g, float b, float a=1.0f)
		{
			rgbaf_[0] = clampf(r);
			rgbaf_[1] = clampf(g);
			rgbaf_[2] = clampf(b);
			rgbaf_[3] = clampf(a);
			c_.rgba[0] = int(rgbaf_[0]*255.0f);
			c_.rgba[1] = int(rgbaf_[1]*255.0f);
			c_.rgba[2] = int(rgbaf_[2]*255.0f);
			c_.rgba[3] = int(rgbaf_[3]*255.0f);
		}

inline QColor FColor_to_QColor( const FColor& theColor )
{
	FColor	clampedColor;

	// avoid QT warning: QColor::fromRgbF: RGB parameters out of range
	clampedColor.R = clampf( theColor.R, 0.0001f, 0.999f );
	clampedColor.G = clampf( theColor.G, 0.0001f, 0.999f );
	clampedColor.B = clampf( theColor.B, 0.0001f, 0.999f );
	clampedColor.A = clampf( theColor.A, 0.0001f, 0.999f );

	return QColor::fromRgbF( clampedColor.R, clampedColor.G, clampedColor.B, clampedColor.A );
}

void SpritePolygonPerformance::update(float dt)
{
    dt = dt*0.3 + prevDt*0.7;
    prevDt = dt;
    elapsedTime += dt;
    int loops = (0.025-dt)*1000;
    if(dt < 0.025 && loops>0)
    {
        continuousHighDtTime = clampf(continuousHighDtTime-dt*2, 0.0, 1.0);
        waitingTime = clampf(waitingTime-dt, 0.0, 5.0);
        continuousLowDt++;
    }
    else
    {
        continuousHighDtTime+=dt;
        continuousLowDt = 0;
    }
    if (continuousLowDt >= 5 && loops > 0) {
        for(int i = 0; i < loops; i++)
        {
            if(_posX >= _rightX)
            {
                goRight = false;
            }
            else if(_posX <= _leftX)
            {
                goRight = true;
            }
            auto s = makeSprite();
            addChild(s);
            s->setPosition(_posX, _posY);
            if(goRight)
                _posX++;
            else
                _posX--;
            
            incrementStats();
        }
        updateLabel();
    }

    //if we have 10 continuous low dt, then we will start to create more sprites
    else if(continuousHighDtTime >= .5 || waitingTime > 3.0){
        // its now 1 seconds with high DT time, time to end
        ended = true;
        unscheduleUpdate();
        perfLabel->setString("Test ended in " + Value(elapsedTime).asString() + " seconds\nNodes: " + Value(spriteCount).asString() + "   Triangles: " + Value(triCount).asString() + "\nPixels: " + Value(pixelCount).asString() + "   Vertices: " + Value(vertCount).asString());
        _subtitleLabel->setString("Test ended");
    }
    else{
        waitingTime += dt;
    }
}

static inline void YUV2RGB( int y, int u, int v, uint8_t *rgb ) {
#ifdef HAVE_FLOAT_CONVERSION
	rgb[0] = clampf( y +                 1.402*(u-128) );
	rgb[1] = clampf( y - 0.344*(v-128) - 0.714*(u-128) );
	rgb[2] = clampf( y + 1.772*(v-128)                 );
#else
	const int C = y -  16;
	const int D = u - 128;
	const int E = v - 128;
	rgb[0] = clampi( (298*C         + 409*E + 128) >> 8 );
	rgb[1] = clampi( (298*C - 100*D - 208*E + 128) >> 8 );
	rgb[2] = clampi( (298*C + 516*D         + 128) >> 8 );
#endif
}

size_t CCAssetInputStream_android::seek(int offset, int mode) {
    switch(mode) {
        case SEEK_CUR:
            m_position = clampf(m_position + offset, 0, m_length);
            break;
        case SEEK_END:
            m_position = clampf(m_length + offset, 0, m_length);
            break;
        case SEEK_SET:
            m_position = clampf(offset, 0, m_length);
            break;
    }
	
	return m_position;
}

EXPORT void
framefunc_get_rgba_f32( rgba_f32 *result, FrameFunctionHolder *holder, double frame ) {
    if( holder->funcs && holder->funcs->get_values ) {
        double dresult[4];

        holder->funcs->get_values( holder->source, 1, &frame, &dresult );

        *result = (rgba_f32) { (float) dresult[0], (float) dresult[1],
            (float) dresult[2], clampf( (float) dresult[3], 0.0f, 1.0f ) };
    }
    else {
        *result = (rgba_f32) { (float) holder->constant[0], (float) holder->constant[1],
            (float) holder->constant[2], clampf( (float) holder->constant[3], 0.0f, 1.0f ) };
    }
}

static float
sminf(float a, float b)
{
	float k = 0.1;
	float h = clampf(0.5+0.5*(b-a)/k, 0.0, 1.0);
	return lerpf(b, a, h) - k*h*(1.0-h);
}

void Tank::rotateGun(float dt)
{
    if (_rotationSpeed != 0.0f) {
        _angle = clampf(_angle + _angleStep * _rotationSpeed * dt, _angleMin, _angleMax);
        draw();
    }
}

void CCScrollBar::syncThumbPositionSizeForScrollView(ScrollView* scrollView) {
	CCSize svSize = scrollView->getSize();
	CCSize innerSize = scrollView->getInnerContainerSize();
	CCSize sbSize = getContentSize();
	CCSize thumbSize = m_thumb ? m_thumb->getContentSize() : m_fixedThumb->getContentSize();
	float percentage = 0;
    float thumbLength = 0;
	if(m_horizontal) {
		float minX = svSize.width - innerSize.width;
		percentage = (scrollView->getInnerContainer()->getPosition().x - minX) / -minX;
        thumbLength = MIN(1, svSize.width / innerSize.width) * sbSize.height;
	} else {
		float minY = svSize.height - innerSize.height;
		percentage = (scrollView->getInnerContainer()->getPosition().y - minY) / -minY;
        thumbLength = MIN(1, svSize.height / innerSize.height) * sbSize.height;
	}
	percentage = clampf(percentage, 0, 1);
	if(m_thumb) {
        m_thumb->setPreferredSize(CCSizeMake(sbSize.width, thumbLength));
		m_thumb->setPosition(ccp(sbSize.width / 2,
								 sbSize.height - percentage * (sbSize.height - thumbSize.height) - thumbSize.height / 2));
	} else {
		m_fixedThumb->setPosition(ccp(sbSize.width / 2,
									  sbSize.height - percentage * (sbSize.height - thumbSize.height) - thumbSize.height / 2));
	}
}

void MagicJoystick::onTouchMoved(Touch* touch, Event* event)
{
    float distance = touch->getLocation().getDistance( this->getPosition());
    distance =  clampf(distance, 0, kMaxDistance);
    float angle = angleBetween(getPosition(), touch->getLocation());
    
    float vx = cos(angle * M_PI / 180) * (distance * 1.5);
    float vy = sin(angle * M_PI / 180) * (distance * 1.5);
    
    _direction = Point(vx / distance, vy / distance);
    
    float darkness = (127 * (vy / kMaxDistance));
    
    float i = 0;
    float count = this->getChildren().size();
    for (Node *layer : this->getChildren()) {
        Point addition = Point(vx / getContentSize().width,vy / getContentSize().height) * i / count;
        layer->setPosition(joystickNormalizedCenter + addition);
        if (std::strcmp(layer->getName().c_str(), kStickTag) == 0) {
            layer->setColor(Color3B(0,0,.8 - (( darkness / 200.0) * (i / count))));
        }
        i ++;
    }
    if (joystickDirection) {
        joystickDirection(Point(vx / getContentSize().width,vy / getContentSize().height));
    }
}

EXPORT void
video_mix_cross_gl_pull( rgba_frame_gl *out, video_source *a, int frame_a, video_source *b, int frame_b, float mix_b ) {
    // Gather the mix factor
    g_debug( "In video_mix_cross_gl_pull, mix_b=%f", mix_b );
    mix_b = clampf(mix_b, 0.0f, 1.0f);

    if( mix_b == 1.0f ) {
        // We only need frame B
        video_get_frame_gl( b, frame_b, out );
        return;
    }
    else if( mix_b == 0.0f ) {
        video_get_frame_gl( a, frame_a, out );
        return;
    }

    rgba_frame_gl fa = *out, fb = *out;

    video_get_frame_gl( a, frame_a, &fa );
    video_get_frame_gl( b, frame_b, &fb );

    video_mix_cross_gl( out, &fa, &fb, mix_b );

    glDeleteTextures( 1, &fa.texture );
    glDeleteTextures( 1, &fb.texture );
}

std::vector<Vec2> AutoPolygon::reduce(const std::vector<Vec2>& points, const Rect& rect , const float& epsilon)
{
    auto size = points.size();
    // if there are less than 3 points, then we have nothing
    if(size<3)
    {
        log("AUTOPOLYGON: cannot reduce points for %s that has less than 3 points in input, e: %f", _filename.c_str(), epsilon);
        return std::vector<Vec2>();
    }
    // if there are less than 9 points (but more than 3), then we don't need to reduce it
    else if (size < 9)
    {
        log("AUTOPOLYGON: cannot reduce points for %s e: %f",_filename.c_str(), epsilon);
        return points;
    }
    float maxEp = MIN(rect.size.width, rect.size.height);
    float ep = clampf(epsilon, 0.0, maxEp/_scaleFactor/2);
    std::vector<Vec2> result = rdp(points, ep);
    
    auto last = result.back();
    if(last.y > result.front().y && last.getDistance(result.front()) < ep*0.5)
    {
        result.front().y = last.y;
        result.pop_back();
    }
    return result;
}