часы :: гиф анимация (гифки - ПРИКОЛЬНЫЕ gif анимашки)

50 минут и у меня все ок будет

Они не пиздят ровно 12 секунд в день

Ты сам то откуда свои посты брал, неужто все самостоятельно делал?

и не благодари
/* @pjs globalKeyEvents="true"; */

BezierDigitAnimator hoursTensDigit;
BezierDigitAnimator hoursUnitsDigit;

BezierDigitAnimator minutesTensDigit;
BezierDigitAnimator minutesUnitsDigit;

BezierDigitAnimator secondsTensDigit;
BezierDigitAnimator secondsUnitsDigit;

BezierDigit[] digits = new BezierDigit[10];

boolean drawControlLines = false;
boolean continualAnimation = false;
boolean onlyCustomAnimSecondsDigit = false;
boolean showContinualShadows = false;

int animationType = 4; // 1 for linear, 2 for quadratic, 3 for cubic, 4 for sinuisoidial
float visualScaling = 0.5;
int animTypeChangeCounter = 1000;
String input = "";
float animDurationUser = 1.0;

void mousePressed() {
drawControlLines = !drawControlLines;
}
void keyPressed() {
if (key == ' ') {
continualAnimation = !continualAnimation;
}
if (key == 'a') {
animationType += 1;
animTypeChangeCounter = 0;
if (animationType > 4) {
animationType = 1;
}
}
if (key == 's') {
showContinualShadows = !showContinualShadows;
}

if( key >= '0' && key 0) {
int idxOf = input.indexOf(".");
if (idxOf == -1) {
input += new String(key);
}
}
else if( key == BACKSPACE && input.length() > 0 ){
input = input.substring( 0, input.length()-1 );
}
else if (key == RETURN || key == ENTER){
animDurationUser = float( input );
input = "";
}
}

void setup( )
{
background(255);
rectMode(CENTER);
strokeWeight(2);
textAlign(CENTER, BOTTOM);
smooth();
frameRate(100);
digits[0] = new BezierDigit(0);
digits[1] = new BezierDigit(1);
digits[2] = new BezierDigit(2);
digits[3] = new BezierDigit(3);
digits[4] = new BezierDigit(4);
digits[5] = new BezierDigit(5);
digits[6] = new BezierDigit(6);
digits[7] = new BezierDigit(7);
digits[8] = new BezierDigit(8);
digits[9] = new BezierDigit(9);

int dist = 0;
// In each the following, the ratio at which the numbers start
// animating is calculated as the ratio of the pause time to the animation time.
// The fact that they add up to the correct amt of seconds is just to make it easier to tweak.
int yOff = 50;
hoursTensDigit = new BezierDigitAnimator(0 * visualScaling, yOff*visualScaling, 35995.0, 5.0);
hoursUnitsDigit = new BezierDigitAnimator((dist+=300) * visualScaling, yOff*visualScaling, 3595.0, 5.0);
minutesTensDigit = new BezierDigitAnimator((dist+=500) * visualScaling, yOff*visualScaling, 595.0, 5.0);
minutesUnitsDigit = new BezierDigitAnimator((dist+=300) * visualScaling, yOff*visualScaling, 55.0, 5.0);
secondsTensDigit = new BezierDigitAnimator((dist+=500) * visualScaling, yOff*visualScaling, 5.0, 5.0);
secondsUnitsDigit = new BezierDigitAnimator((dist+=300) * visualScaling, yOff*visualScaling, 0.0, 1.0);

size(round((dist + 480) * visualScaling), round(600 * visualScaling));

}
void draw() {
background(255);
// if (frameCount % 100 == 0) {
// println(frameRate);

// }
if (animTypeChangeCounter 0) {
fill(50);
text("Set maximum animation duration to: " + input + "s (press enter to confirm)", width/2, height-15);
}

animTypeChangeCounter += 1;
noFill();

// Seconds
// long millis = System.currentTimeMillis() % 1000;
var d = new Date();
var millis = d.getMilliseconds();
int secondTotal = second();
int secondsUnit = secondTotal % 10;
int secondsTen = (secondTotal % 100 - secondTotal % 10) / 10;
float secondsUnitRatio = millis / 1000.0;
float secondsTenRatio = (secondsUnit * 1000 + millis) / 10000.0;
secondsUnitsDigit.animationStartRatio = getAnimStartRatio(1.0);
secondsUnitsDigit.update(secondsUnit, getNextInt(secondsUnit,9), secondsUnitRatio);

// int savedAnimType = animationType;
// if (onlyCustomAnimSecondsDigit) {
// animationType = 1;
// }

secondsTensDigit.animationStartRatio = getAnimStartRatio(10.0);
secondsTensDigit.update(secondsTen, getNextInt(secondsTen,5), secondsTenRatio);

// Minutes
int minuteTotal = minute();
int minutesUnit = minuteTotal % 10;
int minutesTen = (minuteTotal % 100 - minuteTotal % 10) / 10;
float minutesUnitRatio = (secondTotal * 1000 + millis) / 60000.0;
float mintuesTenRatio = (minutesUnit * 60000 + secondTotal * 1000 + millis) / 600000.0;
minutesTensDigit.animationStartRatio = getAnimStartRatio(600.0);
minutesTensDigit.update(minutesTen, getNextInt(minutesTen,5), mintuesTenRatio);
minutesUnitsDigit.animationStartRatio = getAnimStartRatio(60.0);
minutesUnitsDigit.update(minutesUnit, getNextInt(minutesUnit,9), minutesUnitRatio);

// Hours
int hoursTotal = hour();
int hoursUnit = hoursTotal % 10;
int hoursTen = (hoursTotal % 100 - hoursTotal % 10) / 10;
float hoursUnitRatio = ( minuteTotal * 60000 + secondTotal * 1000 + millis) / 3600000.0;
float hoursTenRatio;
int hoursUnitNext;
if (hoursTen == 2 && hoursUnit == 3) {
hoursUnitNext = 0;
hoursTenRatio = ( hoursUnit * 3600000 + minuteTotal * 60000 + secondTotal * 1000 + millis) / ( 4 * 3600000.0); // because only 20, 21, 22, 23 and not up to 29
hoursTensDigit.animationStartRatio = getAnimStartRatio(3600 * 4);
} else {
hoursUnitNext = getNextInt(hoursUnit, 9);
hoursTenRatio = ( hoursUnit * 3600000 + minuteTotal * 60000 + secondTotal * 1000 + millis) / 36000000.0;
hoursTensDigit.animationStartRatio = getAnimStartRatio(3600 * 10);
}
hoursTensDigit.update(hoursTen, getNextInt(hoursTen,2), hoursTenRatio);
hoursUnitsDigit.animationStartRatio = getAnimStartRatio(3600);
hoursUnitsDigit.update(hoursUnit, hoursUnitNext, hoursUnitRatio);

// animationType = savedAnimType;
}

float getAnimStartRatio(float totalDuration) {
if (animDurationUser > totalDuration) {
return 0;
} else {
return 1.0 - (animDurationUser / totalDuration)
}
}

int getNextInt(int current, int max) {
if (current >= max) {
return 0;
} else {
return current + 1;
}
}

void bezierVertexFromArrayListsRatios(float[] from, float[] to, float ratio, float offsetX, float offsetY) {
bezierVertex(lerp(from[0], to[0], ratio) + offsetX,
lerp(from[1], to[1], ratio) + offsetY,
lerp(from[2], to[2], ratio) + offsetX,
lerp(from[3], to[3], ratio) + offsetY,
lerp(from[4], to[4], ratio) + offsetX,
lerp(from[5], to[5], ratio) + offsetY);
}

class BezierDigitAnimator {
float animationStartRatio; // ratio after which we start the animation

float origX;
float origY;

BezierDigitAnimator (float origX, float origY, float pauseDuration, float animDuration) {
this.origX = origX;
this.origY = origY;
animationStartRatio = pauseDuration / (pauseDuration + animDuration);
}

void update(int currentDigit, int nextDigit, float ratio) {
BezierDigit current = digits[currentDigit];
BezierDigit next = digits[nextDigit];
float animationRatio = 0.0;
if (ratio > animationStartRatio) { animationRatio = (ratio - animationStartRatio) / (1 - animationStartRatio); }
if (continualAnimation) {animationRatio = ratio;}
if (ratio 1.0) {animationRatio = 1;}
if (animationType == 2) { // quad
animationRatio = sq(animationRatio);
ratio = sq(ratio); // we don't need ratio any more
}
else if (animationType == 3) { // cub
animationRatio = animationRatio * sq(animationRatio);
ratio = ratio * sq(ratio);
}
else if (animationType == 4) { // sin
animationRatio = 0.5 * (-cos(animationRatio * PI) + 1);
ratio = 0.5 * (-cos(ratio * PI) + 1);
}

noFill();

if (showContinualShadows && !continualAnimation) {
strokeWeight(3);
stroke(0,40);
beginShape();
// First point
vertex(lerp(current.getVertexX(), next.getVertexX(), animationRatio) + origX, lerp(current.getVertexY(), next.getVertexY(), ratio) + origY);
for (int i = 0; i

Вот и пиздуй на хабрахабра.