Call update each frame
@param  {number} deltaTime Frame time
960623
function (deltaTime) {

        deltaTime = deltaTime || 16;

        if (this._rotating) {
            var radian = (this.autoRotateDirection === 'cw' ? 1 : -1)
                * this.autoRotateSpeed / 180 * Math.PI;
            this._phi -= radian * deltaTime / 1000;
            this._needsUpdate = true;
        }
        else if (this._rotateVelocity.len() > 0) {
            this._needsUpdate = true;
        }

        if (Math.abs(this._zoomSpeed) > 0.01 || this._panVelocity.len() > 0) {
            this._needsUpdate = true;
        }

        if (!this._needsUpdate) {
            return;
        }

        // Fixed deltaTime
        this._updateDistanceOrSize(Math.min(deltaTime, 50));
        this._updatePan(Math.min(deltaTime, 50));

        this._updateRotate(Math.min(deltaTime, 50));

        this._updateTransform();

        this.target.update();

        this.trigger('update');

        this._needsUpdate = false;
    }
857835
public void updateMorphTime(float delta) {
		offset += delta;
		if (offset < 0) {
			int index = shapes.indexOf(current);
			if (index < 0) {
				index = shapes.size() - 1;
			}
			
			int nframe = rational(index+1);
			setFrame(index, nframe, offset);
			offset += 1;
		} else if (offset > 1) {
			int index = shapes.indexOf(next);
			if (index < 1) {
				index = 0;
			}
			
			int nframe = rational(index+1);
			setFrame(index, nframe, offset);
			offset -= 1;
		} else {
			pointsDirty = true;
		}
	}
1215375
public void update(final float delta) {
        if (transitionInProgress) {
            currentValue += (targetValue - initialValue) * delta / transitionLength;
            if (isInitialGreater) {
                if (currentValue <= targetValue) {
                    finalizeTransition();
                }
            } else {
                if (currentValue >= targetValue) {
                    finalizeTransition();
                }
            }
        }
    }
762396
function updateAnimation () {
    if (!animationActive && shouldAnimate()) {
      animationStartTime = Date.now()
      lastFrameNumber = 0
      window.requestAnimationFrame(frame)
      animationActive = true
    }
  }
424967
public void updateNoDraw() {
		if (autoUpdate) {
			long now = getTime();
			long delta = now - lastUpdate;
			if (firstUpdate) {
				delta = 0;
				firstUpdate = false;
			}
			lastUpdate = now;
			nextFrame(delta);
		}
	}
928205
public void deltaTotalUsageTime(long delta)
   {
      if (enabled.get() && delta > 0)
      {
         totalUsageTime.addAndGet(delta);
         totalUsageTimeInvocations.incrementAndGet();

         if (delta > maxUsageTime.get())
            maxUsageTime.set(delta);
      }
   }
996934
private void tick(long index, long timestamp) {
    this.currentIndex = index;

    // If the entry timestamp is less than the current state machine timestamp
    // and the delta is not yet set, set the delta and do not change the current timestamp.
    // If the entry timestamp is less than the current state machine timestamp
    // and the delta is set, update the current timestamp to the entry timestamp plus the delta.
    // If the entry timestamp is greater than or equal to the current timestamp, update the current
    // timestamp and reset the delta.
    if (timestamp < currentTimestamp) {
      if (timestampDelta == 0) {
        timestampDelta = currentTimestamp - timestamp;
      } else {
        currentTimestamp = timestamp + timestampDelta;
      }
    } else {
      currentTimestamp = timestamp;
      timestampDelta = 0;
    }

    // Set the current operation type to COMMAND to allow events to be sent.
    setOperation(OperationType.COMMAND);

    service.tick(WallClockTimestamp.from(timestamp));
  }
706924
function _enterFrame(timeStamp) { // @arg DOMHighResTimeStamp|undefined - requestAnimationFrame give us timeStamp.
                                  // @bind this
    if (!this._active) {
        return;
    }
    switch (this._mode) {
    case MODE_RAF_EMULATE: this._timerID = setTimeout(this._enterFrame, 4); break;
    case MODE_RAF:         this._timerID = global["requestAnimationFrame"](this._enterFrame);
    }
    if (!this._ticks.length) {
        return;
    }
    // setInterval and setTimeout does not give us the timeStamp.
    if (this._mode === MODE_INTERVAL ||
        this._mode === MODE_RAF_EMULATE) {
      //timeStamp = this["now"](); // inlining WMClock#now
        timeStamp = (Date.now() - this._baseTimeDiff);
    }
    // reduce the suspended time
    timeStamp -= this._suspend.total;

    var garbageFunctions = 0; // functions that are no longer needed.
    var deltaTime = 0;        // elapsed time since the last frame.
    var count = this._counter++;

    // --- adjust timeStamp and deltaTime ---
    if (this._timeStamp < 0) { // init
        if (this._pulse) { // overwrite timeStamp
            timeStamp = this._pulse;
        }
    } else {
        if (this._pulse) { // overwrite timeStamp
            timeStamp = this._pulse + this._timeStamp;
            deltaTime = this._pulse;
        } else {
            deltaTime = timeStamp - this._timeStamp;
        }
    }
    this._timeStamp = timeStamp; // update time stamp

    // --- callback tick function ---
    for (var i = 0, iz = this._ticks.length; i < iz; ++i) {
        var tick = this._ticks[i];

        if (tick) {
            tick(timeStamp,  // @arg Number - current time
                 deltaTime,  // @arg Number - delta time
                 count);     // @arg Integer - callback count
        } else {
            ++garbageFunctions;
        }
    }
    if (garbageFunctions) {
        _garbageCollection(this);
    }
}
588786
private void updateReversing(double extrp)
    {
        current -= speed * extrp;

        // First frame reached, done
        if (Double.compare(current, first) <= 0)
        {
            current = first;

            if (repeat)
            {
                state = AnimState.PLAYING;
                current += 1.0;
            }
            else
            {
                state = AnimState.FINISHED;
            }
        }
    }
1030269
function (dt) {
            if (this.isAnimated) {
                var result = false;
                for (var i = 0; i < this.animatedTilesets.length; i++) {
                    result = this.animatedTilesets[i].update(dt) || result;
                }
                return result;
            }

            return false;
        }
1312827
def increment(self):
        
        if self._starttime is not None:
            self._delta = datetime.datetime.now() - self._starttime
        else:
            self._delta = datetime.timedelta()
        
        self.refresh()
        self.ticked.emit()
27748
function(deltaTime){

            var currentTime = new Date().getTime();
            deltaTime = deltaTime || currentTime-this.lastUpdated;

            //Ignore minor updates
            if (deltaTime < 5){
                return this;
            }

            deltaTime /= 1000; //convert to seconds

            //Calculate deltas based on how much time has passed since last update
            var data = this.attributes;

            if (data.isAccelerating){

                var deltaVelocity = this.ACCELERATION * deltaTime;
                var deltaTime1 = 0;

                //Calculate new velocities
                var newVelocityX = data.velocityX + (Math.cos(data.angle) * deltaVelocity);
                var newVelocityY = data.velocityY + (Math.sin(data.angle) * deltaVelocity);

                //If velocities exceed maximums, we have to do some additional logic to calculate new positions
                if (newVelocityX > this.MAX_VELOCITY_X || newVelocityX < -this.MAX_VELOCITY_X){
                    newVelocityX = (newVelocityX > 0) ? this.MAX_VELOCITY_X : -this.MAX_VELOCITY_X;

                    deltaTime1 = getTime(data.velocityX, newVelocityX, this.ACCELERATION);
                    data.posX += getDistance(data.velocityX, newVelocityX, deltaTime1) + (newVelocityX*(deltaTime-deltaTime1));
                }
                else{
                    data.posX += getDistance(data.velocityX, newVelocityX, deltaTime);
                }

                if (newVelocityY > this.MAX_VELOCITY_Y || newVelocityY < -this.MAX_VELOCITY_Y){
                    newVelocityY = (newVelocityY > 0) ? this.MAX_VELOCITY_Y : -this.MAX_VELOCITY_Y;

                    deltaTime1 = getTime(data.velocityY, newVelocityY, this.ACCELERATION);
                    data.posY += getDistance(data.velocityY, newVelocityY, deltaTime1) + (newVelocityY*(deltaTime-deltaTime1));
                }else{
                    data.posY += getDistance(data.velocityY, newVelocityY, deltaTime);
                }

                data.velocityX = newVelocityX;
                data.velocityY = newVelocityY;
            }
            else{
                data.posX +=  data.velocityX * deltaTime;
                data.posY +=  data.velocityY * deltaTime;
            }

            //Check to see if player has exceeded zone boundary, in which case send them to opposite side
            var radius = this.SIZE/2;
            var maxPosX =  Constants.Zone.WIDTH+radius;
            var maxPosY =  Constants.Zone.HEIGHT+radius;

            while (data.posX > maxPosX) data.posX -= maxPosX+radius;
            while (data.posX < -radius) data.posX += maxPosX+radius;

            while (data.posY > maxPosY) data.posY -= maxPosY+radius;
            while (data.posY < -radius) data.posY += maxPosY+radius;

            //Update last updated timestamp
            this.lastUpdated = currentTime;

            return this;
        }
287787
function(deg) {
            this.callBase({
                beginValue: 0,
                finishValue: deg,
                setter: function(target, value, timeline) {
                    var delta = timeline.getDelta();
                    target.rotate(delta);
                }
            });
        }
162831
function(delta){
      events.childNodesModified.call(this, delta);

      var array;
      if (array = delta.inserted)
      {
        for (var i = 0, child; child = array[i++];)
        {
          child.groupId_ = child.delegate ? child.delegate.basisObjectId : child.data.id;
          this.map_[child.groupId_] = child;
        }

        if (this.dataSource && this.nullGroup.first)
        {
          var parentNode = this.owner;
          var nodes = arrayFrom(this.nullGroup.nodes); // basis.array.from, because nullGroup.nodes may be transformed
          for (var i = nodes.length; i-- > 0;)
            parentNode.insertBefore(nodes[i], nodes[i].nextSibling);
        }
      }
    }
1233218
function updateMulti( viewer ) {
    updateOnce( viewer );

    // Request the next frame, unless we've been closed
    if ( viewer.isOpen() ) {
        viewer._updateRequestId = scheduleUpdate( viewer, updateMulti );
    } else {
        viewer._updateRequestId = false;
    }
}
145914
public void deltaTotalGetTime(long delta)
   {
      if (enabled.get() && delta > 0)
      {
         totalGetTime.addAndGet(delta);
         totalGetTimeInvocations.incrementAndGet();

         if (delta > maxGetTime.get())
            maxGetTime.set(delta);
      }
   }
980760
function Delta(id, silent) {
    var scutt = Scuttlebutt(id)
        , delta = new EventEmitter()
        , updates = {}
        , state = { id: scutt.id }
        , log = silent ? noop : error

    id = delta.id = scutt.id

    scutt.applyUpdate = applyUpdate
    // history is a global variable -.-
    scutt.history = $history

    delta.validate = validate
    delta.set = set
    delta.get = get
    delta.has = has
    // stupid tokens
    delta.delete = $delete
    delta.toJSON = toJSON
    delta.createStream = scutt.createStream.bind(scutt)

    return delta

    function applyUpdate(update) {
        var key = update[0]
            , value = update[1]
            , recentUpdate = updates[key]

        // If the most recent update for that key is newer then the incoming
        // update. Then ignore it
        if (recentUpdate && recentUpdate[2] > update[2]) {
            return
        }

        updates[key] = update

        if (value === undefined) {
            delete state[key]
        } else {
            state[key] = value
        }

        delta.emit("change", key, value)
        delta.emit("change:" + key, value)

        return true
    }

    function $history(sources) {
        return reduce(updates, isRecent, sources, []).sort(byTimestamp)
    }

    function validate(changes) {
        try {
            delta.emit("validate", changes)
            return true
        } catch (e) {
            log("[DELTA-STREAM]: validation", e.message, e)
            return false
        }
    }

    function set(key, value) {
        if (key === "id" && value !== id) {
            console.log("invalid", key, value)
            throw Error("id cannot be changed")
        }

        if (typeof key === "string") {
            scutt.localUpdate(key, value)
        } else {
            forEach(key, setKeyValue)
        }
    }

    function setKeyValue(value, key) {
        set(key, value)
    }

    function get(key) {
        return state[key]
    }

    function has(key) {
        return key in state
    }

    function $delete(key) {
        set(key, undefined)
    }

    function toJSON() {
        return state
    }
}