Renderering

Contents

• Renderering
  • Renderer
  • Layers
    • RenderingLayer
    • Layer
    • VirtualLayer
  • Cameras
    • Camera
    • NullCamera

Renderer

class serge.render.Renderer(width=640, height=480, title='Serge', backcolour=(0, 0, 0), icon=None, fullscreen=False)

Bases: serge.common.Loggable, serge.serialize.Serializable, serge.common.EventAware

The main rendering component

addLayer(layer)

Add a layer to the rendering

clearLayers()

Clear all the layers

clearSurface()

Clear the surface

getCamera()

Return our camera

getLayer(name)

Return the named layer

getLayerBefore(layer)

Return the layer before the specified one in terms of rendering order

getLayers()

Return all the layers

getRenderingOrder(layer)

Return the order that a layer will be rendered in (0 = first)

getRenderingOrderDictionary()

Return a dictionary of the rendering orders of each layer by name ({name:0, name:1} etc)

The dictionary is actually a live copy that will be updated if you add layers to the renderer so it is safe for you to cache it and re-use it.

Changing the dictionary results in undefined behaviour.

getScreenSize()

Returns the screen size

getSurface()

Return the overall surface

init()

Initialise from serialized state

orderActors(actors)

Return the list of actors sorted by who should be processed first to correctly render

The actors are checked to see which layer they reside on and then this is used to order the returned list.

preRender()

Prepare for new rendering

removeLayer(layer)

Remove the layer from the rendering

removeLayerNamed(name)

Remove the layer with the specific name

render()

Render all the layers

resetSurfaces()

Recreate the surfaces for our layers

When layers are added we sometimes need to reset the layers, for instance, virtual layers need to be shifted around so that they have the right order.

setCamera(camera)

Set our camera

Layers

RenderingLayer

class serge.render.RenderingLayer(name, order)

Bases: serge.common.Loggable, serge.serialize.Serializable, serge.common.EventAware

A layer on which to render things

This is the abstract version of the layer. Create subclasses of this to do useful things.

clearSurface()

Clear our surface

getNiceName()

Return the nice name for this layer

getSurface()

Return the surface

init()

Initialise from serialized state

initSurface(renderer)

Create the surface that we need to draw on

postRender()

Called after the layer has has had everything rendered on it

preRender()

Called before the layer has anything rendered to

render(surface)

Render to a surface

setStatic(static)

Determine whether this layer is static with respect to camera movements or not

setSurface(surface)

Set our surface

Layer

class serge.render.Layer(name, order)

Bases: serge.render.RenderingLayer

A rendering layer with its own surface

This type of layer is useful for compositing because you can do things to this layer once it has been rendered (eg shadows, glows, blurs etc).

clearSurface()

Clear our surface

initSurface(renderer)

Create the surface that we need to draw on

We create a surface that is identical to the background for the main renderer.

render(surface)

Render to a surface

VirtualLayer

class serge.render.VirtualLayer(name, order)

Bases: serge.render.RenderingLayer

A rendering layer that doesn’t have its own surface

This layer will render to the layer immediately before it in the rendering cycle.

clearSurface()

Clear our surface

Nothing to do here - handled by the real owner of the surface.

initSurface(renderer)

Create the surface that we need to draw on

We do not want a surface ourself but we need the next surface in line as far as the renderer is concerned.

render(surface)

Render to a surface

Nothing to do here - handled by the real owner of the surface.

Cameras

Camera

class serge.camera.Camera

Bases: serge.common.Loggable, serge.geometry.Rectangle

Represents a camera

canSee(actor)

Return True if we can see the actor

canSeeActors(actors)

Return the actors that we can see from a list of actors

getRelativeLocation(other)

Return the relative location of one from another

getTarget()

Return the camera’s target location

init()

Initialise from serialized

setTarget(target)

Set the target for the camera to head towards

setZoom(zoom, x, y)

Set the new zoom centered on the given x and y

update(interval)

Update the location of the camera

NullCamera

class serge.camera.NullCamera

Bases: serge.camera.Camera

A camera that can see everything

canSee(actor)

Can we see it? Yes we can

init()

Initialise