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;
}
void ResolveOverlap( const glm::vec2& Ncoll, float depth, float spring_value, float spring_damper,
const glm::vec2& C0, const glm::vec2& P0, glm::vec2& V0, float w0,
const glm::vec2& C1, const glm::vec2& P1, glm::vec2& V1, float w1,
glm::vec2& Fspring)
{
glm::vec2 R0 = C0 - P0;
glm::vec2 R1 = C1 - P1;
glm::vec2 T0 = glm::vec2(-R0.y, R0.x);
glm::vec2 T1 = glm::vec2(-R1.y, R1.x);
glm::vec2 VP0 = V0 - T0 * w0; // point velocity (SIGN IS WRONG)
glm::vec2 VP1 = V1 - T1 * w1; // point velocity (SIGN IS WRONG)
glm::vec2 D = C0 - C1;
glm::vec2 V = VP0 - VP1;
float vn = glm::dot(V, Ncoll);
float dn = glm::dot(D, Ncoll);
// if (dn > 0.0f) dn = 0.0f;
float f = (spring_value * dn) - (spring_damper * vn);
f = clampf(f, -1000.0f, 1000.0f);
Fspring = -f * Ncoll;
}
/* Calculates the fade time from the changes in gain and listener to source
* angle between updates. The result is a the time, in seconds, for the
* transition to complete.
*/
static ALfloat CalcFadeTime(ALfloat oldGain, ALfloat newGain, const aluVector *olddir, const aluVector *newdir)
{
ALfloat gainChange, angleChange, change;
/* Calculate the normalized dB gain change. */
newGain = maxf(newGain, 0.0001f);
oldGain = maxf(oldGain, 0.0001f);
gainChange = fabsf(log10f(newGain / oldGain) / log10f(0.0001f));
/* Calculate the angle change only when there is enough gain to notice it. */
angleChange = 0.0f;
if(gainChange > 0.0001f || newGain > 0.0001f)
{
/* No angle change when the directions are equal or degenerate (when
* both have zero length).
*/
if(newdir->v[0] != olddir->v[0] || newdir->v[1] != olddir->v[1] || newdir->v[2] != olddir->v[2])
{
ALfloat dotp = aluDotproduct(olddir, newdir);
angleChange = acosf(clampf(dotp, -1.0f, 1.0f)) / F_PI;
}
}
/* Use the largest of the two changes, and apply a significance shaping
* function to it. The result is then scaled to cover a 15ms transition
* range.
*/
change = maxf(angleChange * 25.0f, gainChange) * 2.0f;
return minf(change, 1.0f) * 0.015f;
}
EXPORT void
video_copy_frame_alpha_f32( rgba_frame_f32 *out, rgba_frame_f32 *in, float alpha ) {
alpha = clampf(alpha, 0.0f, 1.0f);
if( out == in && alpha == 1.0f )
return;
if( alpha == 0.0f ) {
box2i_set_empty( &out->current_window );
return;
}
box2i inner;
box2i_intersect( &inner, &out->full_window, &in->current_window );
out->current_window = inner;
if( box2i_is_empty( &inner ) )
return;
int width = inner.max.x - inner.min.x + 1;
for( int y = inner.min.y; y <= inner.max.y; y++ ) {
rgba_f32 *row_out = video_get_pixel_f32( out, inner.min.x, y );
rgba_f32 *row_in = video_get_pixel_f32( in, inner.min.x, y );
memcpy( row_out, row_in, sizeof(rgba_f32) * width );
if( alpha != 1.0f ) {
for( int x = 0; x < width; x++ )
row_out[x].a *= alpha;
}
}
}
EXPORT void
video_mix_over_gl( rgba_frame_gl *out, rgba_frame_gl *a, rgba_frame_gl *b, float mix_b ) {
// Really, this is almost exactly the same code as video_mix_cross_gl; the two
// should probably be combined (difference is just the shader text)
GQuark shader_quark = g_quark_from_static_string( "cprocess::video_mix::over_shader" );
// Gather the mix factor
mix_b = clampf(mix_b, 0.0f, 1.0f);
void *context = getCurrentGLContext();
gl_shader_state *shader = (gl_shader_state *) g_dataset_id_get_data( context, shader_quark );
if( !shader ) {
// Time to create the program for this context
shader = g_new0( gl_shader_state, 1 );
shader->program = video_create_filter_program( over_shader_text, "Video mix over shader" );
shader->mix_b_uniform = glGetUniformLocation( shader->program->program, "mix_b" );
g_dataset_id_set_data_full( context, shader_quark, shader, (GDestroyNotify) destroy_shader );
}
glUseProgram( shader->program->program );
glUniform1f( shader->mix_b_uniform, mix_b );
video_render_gl_frame_filter2( shader->program, out, a, b );
}
EXPORT void
video_mix_cross_f32_pull( rgba_frame_f32 *out, video_source *a, int frame_a, video_source *b, int frame_b, float mix_b ) {
mix_b = clampf(mix_b, 0.0f, 1.0f);
if( mix_b == 0.0 ) {
video_get_frame_f32( a, frame_a, out );
}
else if( mix_b == 1.0 ) {
video_get_frame_f32( b, frame_b, out );
}
else {
rgba_frame_f32 tempFrame;
v2i size;
box2i_get_size( &out->full_window, &size );
tempFrame.data = g_slice_alloc( sizeof(rgba_f32) * size.y * size.x );
tempFrame.full_window = out->full_window;
video_get_frame_f32( a, frame_a, out );
video_get_frame_f32( b, frame_b, &tempFrame );
video_mix_cross_f32( out, out, &tempFrame, mix_b );
g_slice_free1( sizeof(rgba_f32) * size.y * size.x, tempFrame.data );
}
}
extern int
mkbrmap(void) /* make dynamic range map */
{
double Tdb, b, s;
double ceiling, trimmings;
register int i;
/* copy initial histogram */
memcpy((void *)modhist, (void *)bwhist, sizeof(modhist));
s = (bwmax - bwmin)/HISTRES; /* s is delta b */
/* loop until satisfactory */
do {
mkcumf(); /* sync brightness mapping */
if (mhistot <= histot*CVRATIO)
return(-1); /* no compression needed! */
Tdb = mhistot * s;
trimmings = 0.; /* clip to envelope */
for (i = 0, b = bwmin + .5*s; i < HISTRES; i++, b += s) {
ceiling = Tdb*clampf(Lb(b));
if (modhist[i] > ceiling) {
trimmings += modhist[i] - ceiling;
modhist[i] = ceiling;
}
}
} while (trimmings > histot*CVRATIO);
#if ADJ_VEIL
mkcrfimage(); /* contrast reduction image */
#endif
return(0); /* we got it */
}
EXPORT void
video_mix_cross_gl( rgba_frame_gl *out, rgba_frame_gl *a, rgba_frame_gl *b, float mix_b ) {
GQuark shader_quark = g_quark_from_static_string( "cprocess::video_mix::crossfade_shader" );
g_debug( "In video_mix_cross_gl, mix_b=%f", mix_b );
// Gather the mix factor
mix_b = clampf(mix_b, 0.0f, 1.0f);
void *context = getCurrentGLContext();
gl_shader_state *shader = (gl_shader_state *) g_dataset_id_get_data( context, shader_quark );
if( !shader ) {
// Time to create the program for this context
shader = g_new0( gl_shader_state, 1 );
shader->program = video_create_filter_program( crossfade_shader_text, "Video mix crossfade shader" );
shader->mix_b_uniform = glGetUniformLocation( shader->program->program, "mix_b" );
g_dataset_id_set_data_full( context, shader_quark, shader, (GDestroyNotify) destroy_shader );
}
glUseProgram( shader->program->program );
glUniform1f( shader->mix_b_uniform, mix_b );
video_render_gl_frame_filter2( shader->program, out, a, b );
}
void FXLightning::render(){
float angle = atan2f(end.y - start.y , end.x - start.x);
float x = cosf(angle - M_PI/2.0) * width;
float y = sinf(angle - M_PI/2.0) * width;
float rx = cosf(angle - M_PI/2.0) * spread;
float ry = sinf(angle - M_PI/2.0) * spread;
static int counter = 0;
int n_samples = ccpDistance(start, end)/480 * K_NUMBER_OF_LIGHTNING_SAMPLES;
if (n_samples > K_NUMBER_OF_LIGHTNING_SAMPLES) {
n_samples = K_NUMBER_OF_LIGHTNING_SAMPLES;
}
for (int i=0; i < n_samples; i+=2) {
CCPoint p = ccpLerp(start, end, i/(float)(n_samples-1));
float r = ((rand()%100) / 100.0 - 0.5) * 7;
// float r = 20* noise1(counter*speed);
float w = 0;
if (i < n_samples*0.5) {
w = i/(float)n_samples * 3;
}
else{
w = (n_samples-i-2)/(float)n_samples * 3;
}
w = clampf(w, 0, 1);
if (tapper == 0) {
vtx[ i+0 ].x = p.x + x + rx*r*w;
vtx[ i+0 ].y = p.y + y + ry*r*w;
vtx[ i+1 ].x = p.x - x + rx*r*w;
vtx[ i+1 ].y = p.y - y + ry*r*w;
}
else{
vtx[ i+0 ].x = p.x + x*tapper*(1-i/(float)n_samples) + rx*r;
vtx[ i+0 ].y = p.y + y*tapper*(1-i/(float)n_samples) + ry*r;
vtx[ i+1 ].x = p.x - x*tapper*(1-i/(float)n_samples) + rx*r;
vtx[ i+1 ].y = p.y - y*tapper*(1-i/(float)n_samples) + ry*r;
}
counter+=5;
}
pShaderProgram->use();
pShaderProgram->setUniformsForBuiltins();
ccGLBindTexture2D(texture->getName());
glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vtx);
glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, uvs);
glDrawArrays(GL_TRIANGLE_STRIP, 0,n_samples);
//DEBUG
// glDrawArrays(GL_LINE_STRIP, 0, n_samples);
CC_INCREMENT_GL_DRAWS(1);
}
void HowToPlayScene::onPressRight(cocos2d::Ref *sender, cocos2d::extension::Control::EventType pControlEvent)
{
if (pControlEvent == Control::EventType::TOUCH_UP_INSIDE && !IS_LOCKED)
{
m_currentPage = clampf(m_currentPage + 1, 0, m_maxPages - 1);
fixArrows();
}
}
void ProgressTimer::setPercentage(float fPercentage)
{
if (_percentage != fPercentage)
{
_percentage = clampf(fPercentage, 0, 100);
updateProgress();
}
}
