Renderable serves as the base class for any object with a width and height (most notably excluding lines and dots). The Renderable class does extend the Object class which tracks location and updates.


We can initialize the default 3 shapes by calling their respective constructors:
rectangle = Rectangle(screen, x, y, width, height)
oval = Oval(screen, x, y, width, height)
triangle = Triangle(screen, x, y, width, height)
The constructor has more arguments that are optional:
Renderable(screen, x, y, width, height, color, border, fill, rotation, visible)
It's crucial to note that all Renderables are rendered from the top-left. So the passed (x, y) for a Rectangle would be its top left corner.


There are a few different Renderables that can be created:
rectangle = Rectangle(screen, x, y, width, height)
oval = Oval(screen, x, y, width, height)
triangle = Triangle(screen, x, y, width, height)
# Note that for Polygon we specify num_sides before (x, y)
polygon = Polygon(screen, num_sides, x, y, width, height)
# We can create an irregular polygon by specifying vertices
irregular = CustomPolygon(screen, vertices, color, border, fill, rotation, visible)
Although Text is classified as a Renderable, it is not directly resizable and has specific methods unique to Text: Reference.


Moving any Renderable is alike to moving a Location:
renderable.x(new_x) # Get or set the x-coordinate
renderable.y(new_y) # Get or set the y-coordinate
renderable.move(dx, dy) # Move by (dx, dy)
renderable.move((dx, dy)) # Tuple representation of (dx, dy)
renderable.move(dx=100) # Move the x-coordinate by +100
renderable.moveto(x, y) # Move to (x, y)
renderable.moveto((x, y)) # Tuple representation of (x, y)
renderable.moveto(y=100) # Move the y-coordinate to +100
We can also make a Renderable move forward at its current heading/angle via:
renderable.forward(distance) # Move forward at current angle by distance
renderable.backward(distance) # Move backward at current angle by distance
Note that these methods utilize the Renderables rotation.


You can also retrieve the Location with:


You can get the Location of the center of any Renderable:
Note: This calculates the centroid of the shape.


You can get or modify the rotation of a Renderable like so:
renderable.rotation() # Get the current angle
renderable.rotation(angle) # Set a new angle of rotation
renderable.rotate(angle_change) # Change the angle by a specified argument
You can also just make a Renderable look at a Location or Renderable:
renderable.lookat(other) # Look at another Renderable
renderable.lookat(location) # Look at a Location


You can retrieve or modify the size of the Renderable like so:
renderable.width() # Get the current width
renderable.width(width) # Modify the width
renderable.width(width, ratio=True) # Maintain the ratio of the Renderable
erable.height() # Get the current height
renderable.height(height) # Modify the height
renderable.height(height, ratio=True) # Maintain the ratio of the Renderable
Note: Width and Height refer to the width and height of the original shape, regardless of rotation.


All Renderables have a default Color of black; the color can be retrieved or set via:
renderable.color() # Get the color
renderable.color(color) # Set a new color

Border and Fill

Renderables also have an optional border that is set to Color.NONE by default. You can set or retrieve the border like so:
renderable.border() # Get the border's color. If none is set, returns Color.NONE
renderable.border(color) # Set a new color for the border
renderable.border(color, width=5) # Set a new color and a borderwidth
renderable.border(color, fill=False) # Set a new color and disable the fill
Fill exists (as seen above) to create Framed Renderables with ease. Fill can be toggled without calling the border() method like so:
renderable.fill(False) # Change the fill to False.


You can make any Object in pyDraw invisible with:
renderable.visible(False) # Make the Object invisible


You can move objects to the front or back of layers with:
renderable.front() # Move to the front
renderable.back() # Move to the back


You can get the distance between a Renderable and another Renderable, or Location like so:
renderable.distance(other) # Pass in another renderable
renderable.distance(location) # Pass in a Location

Transform and Cloning

A transform is a data structure that represents the width, height, and rotation. You can copy the transform of a Renderable and set it to another transform:
renderable.transform() # Retrieve the transform
renderable.transform(transform) # Set a new transform
You should only set the transform to other transforms retrieved from Renderables, however, it is possible to create one yourself:
transform = (width, height, angle);
You can also clone a Renderable by calling the aptly named:


For those who want to perform more advanced mathematics with their shapes, you can retrieve a (copy) list of vertices:
Vertices usually will begin at the top left and work clockwise.

Contains and Overlaps

You can check if a point is contained in any Renderable like so:
renderable.contains(location) # Pass in a normal location
renderable.contains(x, y) # Or you can specify x and y
renderable.contains((x, y)) # Or you can pass in a tuple
Or you can check if two Renderables are overlapping: