C++ clampf函数代码示例

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);
}