Render this particle
776133
public void render() {
		if ((engine.usePoints() && (usePoints == INHERIT_POINTS))
				|| (usePoints == USE_POINTS)) {
			TextureImpl.bindNone();
			GL.glEnable(SGL.GL_POINT_SMOOTH);
			GL.glPointSize(size / 2);
			color.bind();
			GL.glBegin(SGL.GL_POINTS);
			GL.glVertex2f(x, y);
			GL.glEnd();
		} else if (oriented || scaleY != 1.0f) {
			GL.glPushMatrix();

			GL.glTranslatef(x, y, 0f);

			if (oriented) {
				float angle = (float) (Math.atan2(y, x) * 180 / Math.PI);
				GL.glRotatef(angle, 0f, 0f, 1.0f);
			}

			// scale
			GL.glScalef(1.0f, scaleY, 1.0f);

			image.draw((int) (-(size / 2)), (int) (-(size / 2)), (int) size,
					(int) size, color);
			GL.glPopMatrix();
		} else {
			color.bind();
			image.drawEmbedded((int) (x - (size / 2)), (int) (y - (size / 2)),
					(int) size, (int) size);
		}
	}
445701
private void renderRenderable(IAnimatedRenderable renderable)
	{
		this.renderable = renderable;
		set(renderable.getWorld(), renderable.getPos());
		posOffset = new Vec3d(pos.getX(), pos.getY(), pos.getZ());

		renderable.renderAnimated(block, this);
	}
345585
function render (state) {
    if (update) return update(state)
    const loop = mainLoop(state, renderFn(rend), vdom)
    update = loop.update
    return loop.target
  }
1322796
def render(self):
        """"""
        return FRAME_HTML % {
            'id': self.id,
            'filename': escape(self.filename),
            'lineno': self.lineno,
            'function_name': escape(self.function_name),
            'current_line': escape(self.current_line.strip())
        }
740714
def render(self, screen):
        """"""
        self.rect.render(screen)
        super(MenuElement, self).render(screen)
99406
def render(self, target, data):
        """"""
        rows = self.get_rows(target, data)
        rows = self._filter_rows(rows)
        renderer = getattr(self, "_render_%s" % target.name, None)
        if renderer is None:
            raise ValueError(
                "Cannot render %r for %s." % (self.value, target))
        else:
            return renderer(rows)
412601
@Override public void render() {
    Video video = getContent();
    renderThumbnail(video);
    renderTitle(video);
    renderMarker(video);
    renderLabel();
  }
519388
function(){

    var gl = this.gl;
    gl.bindRenderbuffer(    RENDERBUFFER,  this.id );
    gl.renderbufferStorage( RENDERBUFFER,  this.format , this.width, this.height );
    gl.bindRenderbuffer(    RENDERBUFFER,  null );

  }
86033
def render(self, renderer=None, **kwargs):
        
        return Markup(get_renderer(current_app, renderer)(**kwargs).visit(
            self))
5086
def Render(self):
        
        xs = [self.xs[0]]
        ps = [0.0]
        for i, p in enumerate(self.ps):
            xs.append(self.xs[i])
            ps.append(p)

            try:
                xs.append(self.xs[i + 1])
                ps.append(p)
            except IndexError:
                pass
        return xs, ps
59946
def render(self, context, request=None):
        """"""
        context['component'] = self
        return render_to_string(self.template_name, context, request)
105964
protected void render() {
		if (graphicsHandler.getHandlerGroup() != null) {
			invisibleClickArea = createInvisibleMask();
			invisibleClickArea.addDoubleClickHandler(this);
			invisibleClickArea.addClickHandler(this);
			invisibleClickArea.addMouseDownHandler(this);
			invisibleClickArea.addMouseUpHandler(this);
			invisibleClickArea.addMouseMoveHandler(this);
		}
	}
803026
def draw(self):
        """"""
        # update or particle positions by calling the OpenCL kernel
        # self.cle.execute(10)
        OpenGL.GL.glFlush()

        OpenGL.GL.glClear(
            OpenGL.GL.GL_COLOR_BUFFER_BIT | OpenGL.GL.GL_DEPTH_BUFFER_BIT
        )
        if self.white == -1:
            OpenGL.GL.glClearColor(1, 1, 1, 1)
        else:
            OpenGL.GL.glClearColor(0, 0, 0, 0)
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_MODELVIEW)
        OpenGL.GL.glLoadIdentity()

        # handle mouse transformations
        OpenGL.GL.glTranslatef(
            self.initrans.x, self.initrans.y, self.initrans.z
        )
        OpenGL.GL.glRotatef(self.rotate.x, 1, 0, 0)
        OpenGL.GL.glRotatef(
            self.rotate.y, 0, 1, 0
        )  # we switched around the axis so make this rotate_z
        OpenGL.GL.glTranslatef(
            self.translate.x, self.translate.y, self.translate.z
        )

        # render the matrix
        self.render_image()
        # render the particles
        self.render()

        # draw the x, y and z axis as lines
        glutil.draw_axes()
        # enable 2d display #
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_PROJECTION)
        OpenGL.GL.glPushMatrix()
        OpenGL.GL.glLoadIdentity()
        OpenGL.GL.glOrtho(0.0, self.width, self.height, 0.0, -1.0, 10.0)
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_MODELVIEW)
        # glPushMatrix()        ----Not sure if I need this
        OpenGL.GL.glLoadIdentity()
        OpenGL.GL.glDisable(OpenGL.GL.GL_CULL_FACE)

        OpenGL.GL.glClear(OpenGL.GL.GL_DEPTH_BUFFER_BIT)

        # glBegin(GL_LINES)
        # glColor3f(0.0, 1.0, 0.0)
        # glVertex2f(0.0, 0.0)
        # glVertex2f(100.0, 0.0)
        # glVertex2f(100.0, 100.0)
        # glVertex2f(0.0, 100.0)
        # glEnd()

        if self.white == 1:
            self.glut_print(
                10,
                15,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_cycle,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                30,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_temp,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                45,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_id_frag,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                60,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_likelihood,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                75,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_n_contigs,
                0.0,
                1.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                90,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_dist,
                0.0,
                1.0,
                0.0,
                1.0,
            )
        else:
            self.glut_print(
                10,
                15,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_cycle,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                30,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_temp,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                45,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_id_frag,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                60,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_likelihood,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                75,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_n_contigs,
                0.0,
                0.0,
                0.0,
                1.0,
            )
            self.glut_print(
                10,
                90,
                OpenGL.GLUT.GLUT_BITMAP_9_BY_15,
                self.str_curr_dist,
                0.0,
                0.0,
                0.0,
                1.0,
            )

        # self.glut_print( 10 , 15 , GLUT_BITMAP_9_BY_15 , self.str_curr_cycle
        # , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 10 , 30 ,
        # GLUT_BITMAP_9_BY_15 , self.str_curr_temp , 1.0 , 1.0 , 1.0 , 1.0)
        # self.glut_print( 10 , 45 , GLUT_BITMAP_9_BY_15 ,
        # self.str_curr_id_frag , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 10 ,
        # 60 , GLUT_BITMAP_9_BY_15 , self.str_likelihood , 1.0 , 1.0 , 1.0 ,
        # 1.0) self.glut_print( 10.1 , 60.1 , GLUT_BITMAP_9_BY_15 ,
        # self.str_likelihood , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 9.9 ,
        # 59.9, GLUT_BITMAP_9_BY_15 , self.str_likelihood , 1.0 , 1.0 , 1.0 ,
        # 1.0) self.glut_print( 10 , 75 , GLUT_BITMAP_9_BY_15 ,
        # self.str_n_contigs , 1.0 , 1.0 , 1.0 , 1.0) self.glut_print( 10 , 90
        # , GLUT_BITMAP_9_BY_15 , self.str_curr_dist , 1.0 , 1.0 , 1.0 , 1.0)

        # self.glut_print( 10 , 15 , GLUT_BITMAP_9_BY_15 , self.str_curr_cycle
        # , 0.0 , 0.0 , 0.0 , 1.0) self.glut_print( 10 , 30 ,
        # GLUT_BITMAP_9_BY_15 , self.str_curr_temp , 0.0 , 0.0 , 0.0 , 1.0)
        # self.glut_print( 10 , 45 , GLUT_BITMAP_9_BY_15 ,
        # self.str_curr_id_frag , 0.0 , 0.0 , 0.0 , 1.0) self.glut_print( 10 ,
        # 60 , GLUT_BITMAP_9_BY_15 , self.str_likelihood , 0.0 , 0.0 , 0.0 ,
        # 1.0) self.glut_print( 10 , 75 , GLUT_BITMAP_9_BY_15 ,
        # self.str_n_contigs , 0.0 , 0.0 , 0.0 , 1.0) self.glut_print( 10 , 90
        # , GLUT_BITMAP_9_BY_15 , self.str_curr_dist , 0.0 , 0.0 , 0.0 , 1.0)

        # Making sure we can render 3d again
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_PROJECTION)
        OpenGL.GL.glPopMatrix()
        OpenGL.GL.glMatrixMode(OpenGL.GL.GL_MODELVIEW)
        # glPopMatrix()##        ----and this?

        #############
        OpenGL.GLUT.glutSwapBuffers()
1276602
public function actionParticle()
	{
		$this->pageTitle = Yii::t('phrase', 'Particle Template | Dora. - Coming Soon Page Template');
		$this->pageDescription = '';
		$this->pageMeta = '';
		$this->render('/dora/template/front_particle');
	}
456904
def render(self):
        """"""
        self.screen.fill(self.BACKGROUND_COLOR)

        for wid, cond in self._widgets:
            if cond():
                wid.render(self.screen)

        if self.BORDER_COLOR is not None:
            pygame.draw.rect(self.screen, self.BORDER_COLOR, ((0, 0), self.SCREEN_SIZE), 1)

        if self.SHOW_FPS:
            self.fps.render(self.screen)
941714
def render options = {}
      validate!
      self.compose do
        # Allow 'yield' to embed all children
        self.children.each do |child|
          fragment child
        end
      end.render(options)
    end
796279
function render(data) {
                if (!this._rendered) {
                    if (this.template) {
                        if (data) {
                            this.data = data;
                        }
                        var options = this._options,
                            parentChildren = this._parentChildren,
                            decoder = new Decoder(this.template),
                            template = decoder.render(this.data);
                        if (this.el) {
                            var parent = this.el.parentNode;
                            if (parent) {
                                parent.replaceChild(template.fragment, this.el);
                            }
                            if (this.elGroup && this.elGroup.get(this.el)) {
                                this.elGroup.delete(this.el);
                                this.el = template.fragment;
                                this.elGroup.set(template.fragment, this);
                            }
                        } else {
                            this.el = template.fragment;
                        }

                        this.root = new dom.Element(template.fragment, {
                            name: 'root',
                            data: {}
                        });

                        this.children = applyElement(template.children, options);
                        applyParent(this, parentChildren, this.data);
                        this.bindings = setBinders(this.children, true);

                        if (this.data) {
                            this.applyBinders(this.data, this);
                        }

                        setRoutes(this.children, this.context);
                        addChildren(this, this.root);
                        this.rendered.apply(this, _toConsumableArray(this._arguments));
                        this._rendered = true;
                    } else {
                        var HTMLelement = document.createElement('div');
                        this.root = new dom.Element(HTMLelement, {
                            name: 'root',
                            data: {}
                        });
                        if (this.el) {
                            var _parent = this.el.parentNode;
                            if (_parent) {
                                _parent.replaceChild(HTMLelement, this.el);
                            }
                        }
                        this.el = HTMLelement;
                        this.children = {};
                        addChildren(this, this.root);

                        this.rendered.apply(this, _toConsumableArray(this._arguments));
                        this._rendered = true;
                    }
                }
            }