Render animation frame.

@return {Void}
514102
function render() {
            // If first render call, wait for next animationFrame
            if (!renderID) {
                renderID = rAF(render);
                if (dragging.released) {
                    trigger('moveStart');
                }
                return;
            }

            // If immediate repositioning is requested, SLIDEE is being dragged, or animation duration would take
            // less than 2 frames, don't animate
            if (animation.immediate || (!dragging.released ? dragging.source === 'slidee' : o.speed < 33)) {
                pos.cur = animation.to;
            }
            // Use tweesing for animations without known end point
            else if (!dragging.released && dragging.source === 'handle') {
                pos.cur += (animation.to - pos.cur) * o.syncFactor;
            }
            // Use tweening for basic animations with known end point
            else {
                animation.time = Math.min(+new Date() - animation.start, o.speed);
                pos.cur = animation.from + animation.delta * jQuery.easing[o.easing](animation.time/o.speed, animation.time, 0, 1, o.speed);
            }

            // If there is nothing more to render (animation reached the end, or dragging has been released),
            // break the rendering loop, otherwise request another animation frame
            if (animation.to === Math.round(pos.cur) && (!dragging.released || animation.time >= o.speed)) {
                pos.cur = pos.dest;
                renderID = 0;
            } else {
                renderID = rAF(render);
            }

            trigger('move');

            // Update SLIDEE position
            if (!parallax) {
                if (transform) {
                    $slidee[0].style[transform] = gpuAcceleration + (o.horizontal ? 'translateX' : 'translateY') + '(' + (-pos.cur) + 'px)';
                } else {
                    $slidee[0].style[o.horizontal ? 'left' : 'top'] = -Math.round(pos.cur) + 'px';
                }
            }

            // When animation reached the end, and dragging is not active, trigger moveEnd
            if (!renderID && dragging.released) {
                trigger('moveEnd');
            }

            syncScrollbar();
        }
789871
protected function renderMessage()
    {
        $view = $this->getView();
        BootstrapNotifyAsset::register($view);
        if ($this->useAnimation) {
            AnimateAsset::register($view);
        }
        $js = "$.notify({$this->getOptions()},{$this->getClientOptions()});";
        $view->registerJs($js, $view::POS_END);
    }
998359
function () {
            var hash = me.utils.getUriFragment();

            // add a few new debug flag (if not yet defined)
            me.debug.renderHitBox   = me.debug.renderHitBox   || hash.hitbox || false;
            me.debug.renderVelocity = me.debug.renderVelocity || hash.velocity || false;
            me.debug.renderQuadTree = me.debug.renderQuadTree || hash.quadtree || false;

            var _this = this;
            var bounds = new me.Rect(0, 0, 0, 0);

            // patch me.game.update
            me.plugin.patch(me.game, "update", function (dt) {
                var frameUpdateStartTime = window.performance.now();

                this._patched.apply(this, arguments);

                // calculate the update time
                _this.frameUpdateTime = window.performance.now() - frameUpdateStartTime;
            });

            // patch me.game.draw
            me.plugin.patch(me.game, "draw", function () {
                var frameDrawStartTime = window.performance.now();

                _this.counters.reset();

                this._patched.apply(this, arguments);

                // calculate the drawing time
                _this.frameDrawTime = window.performance.now() - frameDrawStartTime;
            });

            // patch sprite.js
            me.plugin.patch(me.Sprite, "draw", function (renderer) {

                // call the original me.Sprite.draw function
                this._patched(renderer);

                // don't do anything else if the panel is hidden
                if (_this.visible) {

                    // increment the sprites counter
                    _this.counters.inc("sprites");

                    // draw the sprite rectangle
                    if (me.debug.renderHitBox) {
                        var bounds = this.getBounds();
                        var ax = this.anchorPoint.x * bounds.width,
                            ay = this.anchorPoint.y * bounds.height;

                        var ancestor = this.ancestor;
                        if (ancestor instanceof me.Container && ancestor.root === false) {
                            ax -= ancestor._absPos.x;
                            ay -= ancestor._absPos.y;
                        } else if (ancestor instanceof me.Entity) {
                            ancestor = ancestor.ancestor;
                            if (ancestor instanceof me.Container && ancestor.root === false) {
                                // is this correct ???
                                ax = ay = 0;
                            }
                        }

                        // translate back as the bounds position
                        // is already adjusted to the anchor Point
                        renderer.translate(ax, ay);

                        renderer.setColor("green");
                        renderer.stroke(bounds);

                        renderer.translate(-ax, -ay);

                        // the sprite mask if defined
                        if (typeof this.mask !== "undefined") {
                            renderer.setColor("orange");
                            renderer.stroke(this.mask);
                        }

                        if (typeof this.body !== "undefined") {
                            renderer.translate(this.pos.x, this.pos.y);
                            // draw all defined shapes
                            renderer.setColor("red");
                            for (var i = this.body.shapes.length, shape; i--, (shape = this.body.shapes[i]);) {
                                renderer.stroke(shape);
                                _this.counters.inc("shapes");
                            }
                        }
                    }
                }
            });


            me.plugin.patch(me.BitmapText, "draw", function (renderer) {
                // call the original me.Sprite.draw function
                this._patched.apply(this, arguments);

                // draw the font rectangle
                if (_this.visible && me.debug.renderHitBox && this.name !== "debugPanelFont") {
                    var bounds = this.getBounds();

                    if (typeof this.ancestor !== "undefined") {
                        var ax = this.anchorPoint.x * bounds.width,
                            ay = this.anchorPoint.y * bounds.height;
                        // translate back as the bounds position
                        // is already adjusted to the anchor Point
                        renderer.translate(ax, ay);
                    } else {
                        renderer.save();
                    }

                    renderer.setColor("orange");
                    renderer.stroke(bounds);
                    _this.counters.inc("bounds");

                    if (typeof this.ancestor === "undefined") {
                        renderer.restore();
                    }
                }
            });

            // patch font.js
            me.plugin.patch(me.Text, "draw", function (renderer, text, x, y) {
                // call the original me.Text.draw function
                this._patched.apply(this, arguments);

                // call the original me.Sprite.draw function
                if (_this.visible && me.debug.renderHitBox) {
                    if (typeof this.ancestor === "undefined") {
                        renderer.save();
                    }
                    renderer.setColor("orange");
                    renderer.stroke(this.getBounds());
                    _this.counters.inc("bounds");
                    if (typeof this.ancestor === "undefined") {
                        renderer.restore();
                    }
                }
            });

            // patch font.js
            me.plugin.patch(me.Text, "drawStroke", function (renderer, text, x, y) {
                // call the original me.Font.drawStroke function
                this._patched.apply(this, arguments);

                // draw the font rectangle
                if (_this.visible && me.debug.renderHitBox) {
                    if (typeof this.ancestor === "undefined") {
                        renderer.save();
                    }
                    renderer.setColor("orange");
                    renderer.stroke(this.getBounds());
                    _this.counters.inc("bounds");
                    if (typeof this.ancestor === "undefined") {
                        renderer.restore();
                    }
                }
            });

            // patch entities.js
            me.plugin.patch(me.Entity, "postDraw", function (renderer) {
                // don't do anything else if the panel is hidden
                if (_this.visible) {
                    // increment the bounds counter
                    _this.counters.inc("bounds");

                    // check if debug mode is enabled
                    if (me.debug.renderHitBox) {
                        renderer.save();

                        renderer.translate(
                            -this.pos.x - this.body.pos.x - this.ancestor._absPos.x,
                            -this.pos.y - this.body.pos.y - this.ancestor._absPos.y
                        );

                        if (this.renderable instanceof me.Renderable) {
                            renderer.translate(
                                -this.anchorPoint.x * this.body.width,
                                -this.anchorPoint.y * this.body.height
                            );
                        }

                        // draw the bounding rect shape
                        renderer.setColor("orange");
                        renderer.stroke(this.getBounds());

                        renderer.translate(
                            this.pos.x + this.ancestor._absPos.x,
                            this.pos.y + this.ancestor._absPos.y
                        );

                        // draw all defined shapes
                        renderer.setColor("red");
                        for (var i = this.body.shapes.length, shape; i--, (shape = this.body.shapes[i]);) {
                            renderer.stroke(shape);
                            _this.counters.inc("shapes");
                        }
                        renderer.restore();
                    }

                    if (me.debug.renderVelocity && (this.body.vel.x || this.body.vel.y)) {
                        bounds.copy(this.getBounds());
                        bounds.pos.sub(this.ancestor._absPos);
                        // draw entity current velocity
                        var x = bounds.width / 2;
                        var y = bounds.height / 2;

                        renderer.save();
                        renderer.setLineWidth(1);

                        renderer.setColor("blue");
                        renderer.translate(-x, -y);
                        renderer.strokeLine(0, 0, ~~(this.body.vel.x * (bounds.width / 2)), ~~(this.body.vel.y * (bounds.height / 2)));
                        _this.counters.inc("velocity");

                        renderer.restore();
                    }
                }
                // call the original me.Entity.postDraw function
                this._patched.apply(this, arguments);
            });

            // patch container.js
            me.plugin.patch(me.Container, "draw", function (renderer, rect) {
                // call the original me.Container.draw function
                this._patched.apply(this, arguments);

                // check if debug mode is enabled
                if (!_this.visible) {
                    // don't do anything else if the panel is hidden
                    return;
                }

                // increment counters
                _this.counters.inc("bounds");
                _this.counters.inc("children");

                if (me.debug.renderHitBox) {
                    renderer.save();
                    renderer.setLineWidth(1);

                    if (!this.root) {
                        renderer.translate(
                            -this._absPos.x,
                            -this._absPos.y
                        );
                    }

                    // draw the bounding rect shape
                    renderer.setColor("orange");
                    renderer.stroke(this.getBounds());

                    // draw the children bounding rect shape
                    renderer.setColor("purple");
                    renderer.stroke(this.childBounds);

                    renderer.restore();
                }
            });
        }
684155
function (animation) {
            var chart = this,
              axes = chart.axes,
              series = chart.series,
              pointer = chart.pointer,
              legend = chart.legend,
              redrawLegend = chart.isDirtyLegend,
              hasStackedSeries,
              hasDirtyStacks,
              hasCartesianSeries = chart.hasCartesianSeries,
              isDirtyBox = chart.isDirtyBox, // todo: check if it has actually changed?
              seriesLength = series.length,
              i = seriesLength,
              serie,
              renderer = chart.renderer,
              isHiddenChart = renderer.isHidden(),
              afterRedraw = [];

            setAnimation(animation, chart);

            if (isHiddenChart) {
                chart.cloneRenderTo();
            }

            // Adjust title layout (reflow multiline text)
            chart.layOutTitles();

            // link stacked series
            while (i--) {
                serie = series[i];

                if (serie.options.stacking) {
                    hasStackedSeries = true;

                    if (serie.isDirty) {
                        hasDirtyStacks = true;
                        break;
                    }
                }
            }
            if (hasDirtyStacks) { // mark others as dirty
                i = seriesLength;
                while (i--) {
                    serie = series[i];
                    if (serie.options.stacking) {
                        serie.isDirty = true;
                    }
                }
            }

            // handle updated data in the series
            each(series, function (serie) {
                if (serie.isDirty) { // prepare the data so axis can read it
                    if (serie.options.legendType === 'point') {
                        redrawLegend = true;
                    }
                }
            });

            // handle added or removed series
            if (redrawLegend && legend.options.enabled) { // series or pie points are added or removed
                // draw legend graphics
                legend.render();

                chart.isDirtyLegend = false;
            }

            // reset stacks
            if (hasStackedSeries) {
                chart.getStacks();
            }


            if (hasCartesianSeries) {
                if (!chart.isResizing) {

                    // reset maxTicks
                    chart.maxTicks = null;

                    // set axes scales
                    each(axes, function (axis) {
                        axis.setScale();
                    });
                }

                chart.adjustTickAmounts();
            }

            chart.getMargins(); // #3098

            if (hasCartesianSeries) {
                // If one axis is dirty, all axes must be redrawn (#792, #2169)
                each(axes, function (axis) {
                    if (axis.isDirty) {
                        isDirtyBox = true;
                    }
                });

                // redraw axes
                each(axes, function (axis) {

                    // Fire 'afterSetExtremes' only if extremes are set
                    if (axis.isDirtyExtremes) { // #821
                        axis.isDirtyExtremes = false;
                        afterRedraw.push(function () { // prevent a recursive call to chart.redraw() (#1119)
                            fireEvent(axis, 'afterSetExtremes', extend(axis.eventArgs, axis.getExtremes())); // #747, #751
                            delete axis.eventArgs;
                        });
                    }

                    if (isDirtyBox || hasStackedSeries) {
                        axis.redraw();
                    }
                });
            }

            // the plot areas size has changed
            if (isDirtyBox) {
                chart.drawChartBox();
            }


            // redraw affected series
            each(series, function (serie) {
                if (serie.isDirty && serie.visible &&
                  (!serie.isCartesian || serie.xAxis)) { // issue #153
                    serie.redraw();
                }
            });

            // move tooltip or reset
            if (pointer) {
                pointer.reset(true);
            }

            // redraw if canvas
            renderer.draw();

            // fire the event
            fireEvent(chart, 'redraw'); // jQuery breaks this when calling it from addEvent. Overwrites chart.redraw

            if (isHiddenChart) {
                chart.cloneRenderTo(true);
            }

            // Fire callbacks that are put on hold until after the redraw
            each(afterRedraw, function (callback) {
                callback.call();
            });
        }
578824
function getRenderer(attrs, scope) {
    var statics = function() {
      return {
        enter: function (element, target, cb) { target.after(element); cb(); },
        leave: function (element, cb) { element.remove(); cb(); }
      };
    };

    if ($animate) {
      return {
        enter: function(element, target, cb) {
          var promise = $animate.enter(element, null, target, cb);
          if (promise && promise.then) promise.then(cb);
        },
        leave: function(element, cb) {
          var promise = $animate.leave(element, cb);
          if (promise && promise.then) promise.then(cb);
        }
      };
    }

    if ($animator) {
      var animate = $animator && $animator(scope, attrs);

      return {
        enter: function(element, target, cb) {animate.enter(element, null, target); cb(); },
        leave: function(element, cb) { animate.leave(element); cb(); }
      };
    }

    return statics();
  }
332259
def __render_videoframe(self):
		

		new_videoframe = self.clip.get_frame(self.clock.time)
		# Pass it to the callback function if this is set
		if callable(self.__videorenderfunc):
			self.__videorenderfunc(new_videoframe)
		# Set current_frame to current frame (...)
		self.__current_videoframe = new_videoframe
178806
private void renderAnimations() {
        Keyframe kf0, kf1, kf2, kf3;
        float midwayPoint = 0.2f;
        int duration = 500;

        // Set up animator for disappearing.
        kf0 = Keyframe.ofFloat(0f, 1);
        kf1 = Keyframe.ofFloat(midwayPoint, mTransitionMidRadiusMultiplier);
        kf2 = Keyframe.ofFloat(1f, mTransitionEndRadiusMultiplier);
        PropertyValuesHolder radiusDisappear = PropertyValuesHolder.ofKeyframe(
                "animationRadiusMultiplier", kf0, kf1, kf2);

        kf0 = Keyframe.ofFloat(0f, 1f);
        kf1 = Keyframe.ofFloat(1f, 0f);
        PropertyValuesHolder fadeOut = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1);

        mDisappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
                this, radiusDisappear, fadeOut).setDuration(duration);
        mDisappearAnimator.addUpdateListener(mInvalidateUpdateListener);


        // Set up animator for reappearing.
        float delayMultiplier = 0.25f;
        float transitionDurationMultiplier = 1f;
        float totalDurationMultiplier = transitionDurationMultiplier + delayMultiplier;
        int totalDuration = (int) (duration * totalDurationMultiplier);
        float delayPoint = (delayMultiplier * duration) / totalDuration;
        midwayPoint = 1 - (midwayPoint * (1 - delayPoint));

        kf0 = Keyframe.ofFloat(0f, mTransitionEndRadiusMultiplier);
        kf1 = Keyframe.ofFloat(delayPoint, mTransitionEndRadiusMultiplier);
        kf2 = Keyframe.ofFloat(midwayPoint, mTransitionMidRadiusMultiplier);
        kf3 = Keyframe.ofFloat(1f, 1);
        PropertyValuesHolder radiusReappear = PropertyValuesHolder.ofKeyframe(
                "animationRadiusMultiplier", kf0, kf1, kf2, kf3);

        kf0 = Keyframe.ofFloat(0f, 0f);
        kf1 = Keyframe.ofFloat(delayPoint, 0f);
        kf2 = Keyframe.ofFloat(1f, 1f);
        PropertyValuesHolder fadeIn = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1, kf2);

        mReappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
                this, radiusReappear, fadeIn).setDuration(totalDuration);
        mReappearAnimator.addUpdateListener(mInvalidateUpdateListener);
    }
1346750
function render(Frame $frame) {
    $style = $frame->get_style(); 
    list($x, $y, $w, $h) = $frame->get_border_box();
    
    $this->_set_opacity( $frame->get_opacity( $style->opacity ) );

    if ( $frame->get_node()->nodeName === "body" ) {
      $h = $frame->get_containing_block("h") - $style->length_in_pt(array(
        $style->margin_top,
        $style->padding_top,
        $style->border_top_width,
        $style->border_bottom_width,
        $style->padding_bottom,
        $style->margin_bottom),
      $style->width);
    }
    
    // Draw our background, border and content
    if ( ($bg = $style->background_color) !== "transparent" ) {
      $this->_canvas->filled_rectangle( $x, $y, $w, $h, $bg );
    }

    if ( ($url = $style->background_image) && $url !== "none" )
      $this->_background_image($url, $x, $y, $w, $h, $style);

    $this->_render_border($frame);
    $this->_render_outline($frame);
    
    if (DEBUG_LAYOUT && DEBUG_LAYOUT_BLOCKS) {
      $this->_debug_layout($frame->get_border_box(), "red");
      if (DEBUG_LAYOUT_PADDINGBOX) {
        $this->_debug_layout($frame->get_padding_box(), "red", array(0.5, 0.5));
      }
    }
    
    if (DEBUG_LAYOUT && DEBUG_LAYOUT_LINES && $frame->get_decorator()) {
      foreach ($frame->get_decorator()->get_line_boxes() as $line) {
        $frame->_debug_layout(array($line->x, $line->y, $line->w, $line->h), "orange");
      }
    }
  }
1317969
public function render()
    {
        if (!$this->visible) {
            return;
        }

        parent::render();

        if ($this->isSensitive()) {
            $this->renderSensitive();
        } else {
            $this->renderInsensitive();
        }
    }
418241
function nextFrame(fn) {
    let frame;
    let cancelFrame;

    if (window.requestAnimationFrame) {
        frame = requestAnimationFrame(() => {
            frame = requestAnimationFrame(fn);
        });
        cancelFrame = cancelAnimationFrame;
    } else {
        frame = setTimeout(fn, 26); // 16ms to simulate RAF, 10ms to ensure called after the frame.
        cancelFrame = clearTimeout;
    }

    return () => {
        if (frame) {
            cancelFrame(frame);
            frame = undefined;
        }
    };
}
534048
function() {
		switch( this.cycles ) {
		case 3728:
		case 7457:
		case 11186:
		case 14915:
			this.doQuarterFrame();
			break;
		}

		switch( this.cycles ) {
		case 7457:
		case 14915:
			this.doHalfFrame();
			break;
		}

		if ( this.cycles >= 14915 ) {
			this.cycles = 0;

			if( this.frameCounterInterrupt ) {
				this.system.cpu.requestIRQ();
			}
		}
	}
333239
function(template) {

		var animation = this._animations_by_template_guid[template.guid];

		if (!animation && template.isInDOM()) {

			animation = this._createAnimation(template);

		}

		if (animation) {

			animation.reverseDirection();
			animation.safeStart();

		}

	}
805005
function animationLoop() {
  var
    // grab current time
    t = time(),
    // calculate how many millisends we have
    fps = 1000 / next.minFPS,
    // used to flag overtime in case we exceed milliseconds
    overTime = false,
    // take current frame queue length
    length = getLength(qframe, qframex)
  ;
  // if there is actually something to do
  if (length) {
    // reschedule upfront next animation frame
    // this prevents the need for a try/catch within the while loop
    requestAnimationFrame(animationLoop);
    // reassign qframex cleaning current animation frame queue
    qframex = qframe.splice(0, length);
    while (qframex.length) {
      // if some of them fails, it's OK
      // next round will re-prioritize the animation frame queue
      exec(qframex.shift());
      // if we exceeded the frame time, get out this loop
      overTime = (time() - t) >= fps;
      if ((next.isOverloaded = overTime)) break;
    }
    // if overtime and debug is true, warn about it
    if (overTime && next.debug) console.warn('overloaded frame');
  } else {
    // all frame callbacks have been executed
    // we can actually stop asking for animation frames
    frameRunning = false;
    // and flag it as non busy/overloaded anymore
    next.isOverloaded = frameRunning;
  }
}
1150187
private void renderAnimations() {
        Keyframe kf0, kf1;

        // Set up animator for disappearing.
        kf0 = Keyframe.ofFloat(0f, 1f);
        kf1 = Keyframe.ofFloat(1f, 0.8f);
        PropertyValuesHolder radius = PropertyValuesHolder.ofKeyframe(
                "animationRadiusMultiplier", kf0, kf1);

        kf0 = Keyframe.ofFloat(0f, 1f);
        kf1 = Keyframe.ofFloat(1f, 0f);
        PropertyValuesHolder fade = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1);

        kf0 = Keyframe.ofFloat(0f, 0f);
        kf1 = Keyframe.ofFloat(1f, 70f);
        PropertyValuesHolder rotation = PropertyValuesHolder.ofKeyframe("rotation", kf0, kf1);

        mDisappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
                this, radius, fade, rotation).setDuration(300);
        mDisappearAnimator.addUpdateListener(mInvalidateUpdateListener);


        // Set up animator for reappearing.
        kf0 = Keyframe.ofFloat(0f, 0.8f);
        kf1 = Keyframe.ofFloat(1f, 1f);
        radius = PropertyValuesHolder.ofKeyframe(
                "animationRadiusMultiplier", kf0, kf1);

        kf0 = Keyframe.ofFloat(0f, 0f);
        kf1 = Keyframe.ofFloat(1f, 1f);
        fade = PropertyValuesHolder.ofKeyframe("alpha", kf0, kf1);

        kf0 = Keyframe.ofFloat(0f, -70f);
        kf1 = Keyframe.ofFloat(1f, 0f);
        rotation = PropertyValuesHolder.ofKeyframe("rotation", kf0, kf1);

        mReappearAnimator = ObjectAnimator.ofPropertyValuesHolder(
                this, radius, fade, rotation).setDuration(300);
        mReappearAnimator.addUpdateListener(mInvalidateUpdateListener);
    }
1132994
function renderStream() {
    es.addEventListener('css:processed', function (event) {
      // Inject the CSS
      var style = document.getElementById('jsbin-css');
      if (style.styleSheet) {
        style.styleSheet.cssText = event.data;
      } else {
        style.innerHTML = event.data;
      }
    });

    es.addEventListener('reload', reload);
    // Update the url when the revision is bumped
    es.addEventListener('bump-revision', function (event) {
      window.location.pathname = cleanPath(event.data);
    });
    // Javascript and HTML cause a reload. Would be nice to make it possible to
    // inject HTML changes in future.
    es.addEventListener('javascript:processed', reload);
    es.addEventListener('html:processed', reload);
  }
492345
function () {
    this.updateConfig();
    this.animation.began = true;
    this.time = 0;
    this.animationIsPlaying = true;
    this.stopRelatedAnimations();
    this.el.emit('animationbegin', this.eventDetail, false);
  }
717032
public function Render()
    {
        if (strlen($this->_ankor) > 0) {
            WebApplication::$app->getResponse()->addJavaScript("window.location='#" . $this->_ankor . "'", true);
            $this->_ankor = '';
        }
        $this->beforeRender();
        $this->RenderImpl();
        $this->afterRender();
    }