def draw_circle(cx, cy, r, num_segments=None, mode=gl.GL_POLYGON, color=(1, 1, 1, 1)):
	if not num_segments:
		num_segments = get_num_circle_segments(r)

	theta = 2 * math.pi / float(num_segments)
	tangetial_factor = math.tan(theta)
	radial_factor = math.cos(theta)

	x = float(r)
	y = 0.0

	gl.glColor4f(color[0], color[1], color[2], color[3])
	gl.glBegin(mode)
	for i in xrange(num_segments):
		gl.glVertex2f(x + cx, y + cy)

		tx = y * -1
		ty = x

		x += tx * tangetial_factor
		y += ty * tangetial_factor

		x *= radial_factor
		y *= radial_factor
	gl.glEnd()

def nakresli_caru(x1, y1, x2, y2):
   
    gl.glBegin(gl.GL_LINES)
    #  gl.glBegin(gl.GL_TRIANGLE_FAN)
    gl.glVertex2f(x1, y1)
    gl.glVertex2f(x2, y2)   
    gl.glEnd()

    def draw_points(self):
        self.points_lock.acquire()
        
        try:
            from pyglet.gl import glBegin, glEnd, GL_POINTS, glColor4f, glVertex2f
                   
            glBegin(GL_POINTS)
               
            for i in xrange(0, len(self.points)):
                p = self.points[i]
                parameter_index = self.parameter_indices[0]
                state_index = self.state_indices[0]

                glColor4f(1, 1, 1, p.age / (self.age_max*2.0))
                glVertex2f(p.parameters[parameter_index], p.state[state_index])
                
                p.state = self.system.iterate(p.state, p.parameters)
                p.age += 1
                
                #if p.age >= self.age_max:
                #    self.points[i] = OrbitPoint(tool=self, varying_parameter=p.parameters[parameter_index])
            
            glEnd()
        except Exception, detail:
            print 'draw_points()', type(detail), detail

def draw_block(block):
    transformed = [world_to_screen(block.GetWorldPoint(p)) for p in POINTS]
    gl.glColor3f(1.0, 0.1, 0)
    gl.glBegin(gl.GL_LINE_LOOP)
    for p in transformed:
        gl.glVertex2f(*p)
    gl.glEnd()

    def draw_points(self):
        self.points_lock.acquire()

        try:
            from pyglet.gl import glCallList, glBegin, GL_LINE_STRIP, glColor4f, glVertex2f, glEnd

            # line from previous iterate to next iterate of function
            glBegin(GL_LINE_STRIP)
            glColor4f(1, 1, 1, 0.3)

            state_index = self.state_indices[0]

            for i in [1, 2]:
                state_previous = self.point.state[state_index]
                self.point.state = self.system.iterate(self.point.state, self.point.parameters)

                glVertex2f(state_previous, state_previous)
                glVertex2f(state_previous, self.point.state[state_index])

            glEnd()

            # call display lists, doesn't work in init_points()
            if self.server.iteration <= 1:
                glCallList(self.iterate_list)
                glCallList(self.reflection_list)
        except Exception, detail:
            print "draw_points()", type(detail), detail

 def draw(self, colour=(0., 0., 1.)):
   s = self.size # just a shorthand
   gl.glColor3f(*colour)
   gl.glBegin(gl.GL_LINE_LOOP)
   for vertex in self.verticies:
     gl.glVertex2f(*vertex)
   gl.glEnd()

 def draw(self):
   r = self.size.x
   gl.glColor3f(1.0, .7, 0.0)
   with shiftView(self.body.position):
     gl.glBegin(gl.GL_LINE_LOOP)
     for angle in xrange(0, 360, 360/12):
       gl.glVertex2f(*self.size.rotated_degrees(angle))
     gl.glEnd()

def display_pointer(angle, color, radius):
    x_value = math.cos(angle)
    y_value = math.sin(angle)
    glBegin(GL_LINES)
    glColor3ub(*color)
    glVertex2f(0.0, 0.0)
    glVertex2f(x_value * radius, y_value * radius)
    glEnd()

def draw_line(a, b, color):
    gl.glPushMatrix()
    gl.glColor3f(color[0], color[1], color[2])
    gl.glLineWidth(2)
    gl.glBegin(gl.GL_LINES)
    gl.glVertex2f(a[0], a[1])
    gl.glVertex2f(b[0], b[1])
    gl.glEnd()
    gl.glPopMatrix()

def line(x, y, size, angle, color=(1, 0, 0, 1), thickness=1):
    x1, y1 = x, y
    x2, y2 = x1 + cos(angle) * size, y1 + sin(angle) * size
    glColor4f(*color)
    glLineWidth(thickness)
    glBegin(GL_LINES)
    glVertex2f(x1, y1)
    glVertex2f(x2, y2)
    glEnd()

def draw_fan(center, vertices, color):
    gl.glPushMatrix()
    gl.glColor4f(*color)
    gl.glBegin(gl.GL_TRIANGLE_FAN)
    gl.glVertex2f(center[0], center[1])
    for vertex in vertices:
        gl.glVertex2f(vertex[0], vertex[1])
    gl.glEnd()
    gl.glPopMatrix()

    def draw(self):
        gl.glColor3f(1, 1, 1)
        gl.glBegin(gl.GL_LINES)
        gl.glVertex2f(0, 50)
        gl.glVertex2f(self.window.width, 50)
        gl.glEnd()

        for label in self.labels:
            label.draw()

    def draw_bone(self, bone):
        p1 = bone.get_start()
        p2 = bone.get_end()

        gl.glColor4ub(*self.color)
        gl.glLineWidth(5)
        gl.glBegin(gl.GL_LINES)
        gl.glVertex2f(*p1)
        gl.glVertex2f(*p2)
        gl.glEnd()

 def draw(self):
     if not self.visible:
         return
     gl.glLineWidth(2)  # deprecated
     gl.glColor3ub(*self.color3)
     gl.glBegin(gl.GL_LINE_STRIP)
     for v in self.vertexes:
         gl.glVertex2f(*v)
     gl.glVertex2f(*self.vertexes[0])
     gl.glEnd()

def circle(x, y, radius):
    iterations = int(tau * radius) * 2
    s = sin(tau / iterations)
    c = cos(tau / iterations)
    gl.glBegin(gl.GL_TRIANGLE_FAN)
    gl.glVertex2f(x, y)
    dx, dy = radius, 0
    for i in range(iterations + 1):
        gl.glVertex2f(x + dx, y + dy)
        dx, dy = (dx * c - dy * s), (dy * c + dx * s)
    gl.glEnd()

    def render_change_vectors(self):
        glBegin(GL_LINES)

        color = [0.0, 0.0, 0.0]
        for i, (factor, vec) in enumerate(self.change_vectors):
            color[i % 3] = 1.0
            glColor3f(*color)
            glVertex2f(0.0, 0.0)
            glVertex2f(*[i * factor * _CHANGE_VECTOR_LENGTH for i in vec])
            color[i % 3] = 0.0
        glEnd()

 def blit(self, x, y, w, h, z=0, s=(0,1), **kwargs):
     ''' Draw texture to active framebuffer. '''
     gl.glEnable (gl.GL_TEXTURE_2D)
     gl.glDisable (gl.GL_TEXTURE_1D)
     gl.glBindTexture(self.target, self._id)
     gl.glBegin(gl.GL_QUADS)
     gl.glTexCoord2f(s[0], 1), gl.glVertex2f(x,   y)
     gl.glTexCoord2f(s[0], 0), gl.glVertex2f(x,   y+h)
     gl.glTexCoord2f(s[1], 0), gl.glVertex2f(x+w, y+h)
     gl.glTexCoord2f(s[1], 1), gl.glVertex2f(x+w, y)
     gl.glEnd()

def on_draw():
    global vertices
    gl.glClear(gl.GL_COLOR_BUFFER_BIT)

    gl.glColor3f(0, 0, 0)

    gl.glBegin(gl.GL_TRIANGLES)
    for vertex in vertices:
        gl.glVertex2f(*vertex)

    gl.glEnd()

    def render_view(self):
        glColor3f(0.6, 0.1, 0.1)
        glBegin(GL_LINE_LOOP)

        step = 10
        # render a circle for the boid's view
        for i in range(-_BOID_VIEW_ANGLE, _BOID_VIEW_ANGLE + step, step):
            glVertex2f(_BOID_RANGE * math.sin(math.radians(i)),
                       (_BOID_RANGE * math.cos(math.radians(i))))
        glVertex2f(0.0, 0.0)
        glEnd()

def on_draw():
    gl.glClear(gl.GL_COLOR_BUFFER_BIT)
    gl.glMatrixMode(gl.GL_MODELVIEW)
    gl.glLoadIdentity()

    transformed = [world_to_screen(block.GetWorldPoint(p)) for p in POINTS]
    gl.glColor3f(1.0, 0.1, 0)
    gl.glBegin(gl.GL_QUADS)
    for p in transformed:
        gl.glVertex2f(*p)
    gl.glEnd()