Transitions can be used as part of the with statement, as well as in other parts of Ren'Py, to apply effects to changes in the scene. Ren'Py comes with a small number of pre-defined transitions, which can be given directly to the with statement. It also includes transition classes, which can be used to create new transitions.
Pre-defined transitions can be given directly to the with statement. For example:
show bg washington
with dissolve
fade
linkTakes 0.5 seconds to fade to black, and then 0.5 seconds to
fade to the new screen. An instance of the Fade()
transition
class.
dissolve
linkTakes 0.5 seconds to dissolve from the old to the new screen. An
instance of the Dissolve()
transition class.
pixellate
linkPixellates the old scene for .5 seconds, and the new scene for
another .5 seconds. An instance of the Pixellate()
transition class.
move
linkTakes 0.5 seconds to the move images that have changed location to
their new locations. An instance of the MoveTransition()
transition class.
moveinright
linkAlso: moveinleft, moveintop, moveinbottom
These move entering images onto the screen from the appropriate side, taking 0.5 seconds to do so.
moveoutright
linkAlso: moveoutleft, moveouttop, moveoutbottom
These move leaving images off the screen via the appropriate side, taking 0.5 seconds to do so.
ease
linkAlso: easeinright, easeinleft, easeintop, easeinbottom, easeoutright, easeoutleft, easeouttop, easeoutbottom
These are similar to the move- family of transitions, except that they use a cosine-based curve to slow down the start and end of the transition.
zoomin
linkThis zooms in entering images, taking 0.5 seconds to do so.
zoomout
linkThis zooms out leaving images, taking 0.5 seconds to do so.
zoominout
linkThis zooms in entering images and zooms out leaving images, taking 0.5 seconds to do so.
vpunch
linkWhen invoked, this transition shakes the screen vertically for a quarter second.
hpunch
linkWhen invoked, this transition shakes the screen horizontally for a quarter second.
blinds
linkTransitions the screen in a vertical blinds effect lasting 1
second. An instance of the ImageDissolve()
transition class.
squares
linkTransitions the screen in a squares effect lasting 1 second.
wipeleft
linkAlso: wiperight, wipeup, wipedown
Wipes the scene in the given direction. Instances of the
CropMove()
transition class.
slideleft
linkAlso: slideright, slideup, slidedown
Slides the new scene in the given direction. Instances of the
CropMove()
transition class.
slideawayleft
linkAlso: slideawayright, slideawayup, slideawaydown
Slides the old scene in the given direction. Instances of the
CropMove()
transition class.
pushright
linkAlso: pushleft, pushup, pushdown
These use the new scene to slide the old scene out the named
side. Instances of the PushMove()
transition class.
irisin
linkAlso: irisout
Use a rectangular iris to display the new screen, or hide the old
screen. Instances of the CropMove()
transition class.
Transition classes are functions that can be called to create new transitions. These functions are parameterized, allowing entire families of transitions to be created.
Calling transition classes can be done as part of the with statement. For example:
# A very long dissolve.
with Dissolve(10.0)
If we find ourselves calling the same transition class repeatedly, we can use the define statement to assign the transition to a variable:
define annoytheuser = Dissolve(1.0)
label start:
show bg washington
with annoytheuser
The time_warp argument taken by many transition classes can be given
builtin warpers found in the _warper
module,
see warpers.
AlphaDissolve
(control, delay=0.0, alpha=False, reverse=False, **properties) linkReturns a transition that uses a control displayable (almost always some sort of animated transform) to transition from one screen to another. The transform is evaluated. The new screen is used where the transform is opaque, and the old image is used when it is transparent.
When the dissolve will be scaled to less than half its natural size, the
mipmap
style property can be set to True. This will cause mipmaps
to be generated, which will make the dissolve consume more GPU resources,
but will reduce artifacts.
ComposeTransition
(trans, before, after) linkReturns a transition that composes up to three transitions. If not None, the before and after transitions are applied to the old and new scenes, respectively. These updated old and new scenes are then supplied to the trans transition.
# Move the images in and out while dissolving. (This is a fairly expensive transition.)
define moveinoutdissolve = ComposeTransition(dissolve, before=moveoutleft, after=moveinright)
CropMove
(time, mode="slideright", startcrop=(0.0, 0.0, 0.0, 1.0), startpos=(0.0, 0.0), endcrop=(0.0, 0.0, 1.0, 1.0), endpos=(0.0, 0.0), topnew=True) linkReturns a transition that works by cropping a scene and positioning it on the screen. This can be used to implement a variety of effects, all of which involve changing rectangular slices of scenes.
The name of the mode of the transition. There are three groups of modes: wipes, slides, and other. This can also be "custom", to allow a custom mode to be defined.
In a wipe, the image stays fixed, and more of it is revealed as the transition progresses. For example, in "wiperight", a wipe from left to right, first the left edge of the image is revealed at the left edge of the screen, then the center of the image, and finally the right side of the image at the right of the screen. Other supported wipes are "wipeleft", "wipedown", and "wipeup".
In a slide, the image moves. So in a "slideright", the right edge of the image starts at the left edge of the screen, and moves to the right as the transition progresses. Other slides are "slideleft", "slidedown", and "slideup".
There are also slideaways, in which the old image moves on top of the new image. Slideaways include "slideawayright", "slideawayleft", "slideawayup", and "slideawaydown".
We also support a rectangular iris in with "irisin" and a rectangular iris out with "irisout".
The following parameters are only respected if the mode is "custom". Positions are relative to the size of the screen, while the crops are relative to the size of the image. So a crop of (0.25, 0.0, 0.5, 1.0) takes the middle half of an image.
define wiperight = CropMove(1.0, "wiperight")
define wipeleft = CropMove(1.0, "wipeleft")
define wipeup = CropMove(1.0, "wipeup")
define wipedown = CropMove(1.0, "wipedown")
define slideright = CropMove(1.0, "slideright")
define slideleft = CropMove(1.0, "slideleft")
define slideup = CropMove(1.0, "slideup")
define slidedown = CropMove(1.0, "slidedown")
define slideawayright = CropMove(1.0, "slideawayright")
define slideawayleft = CropMove(1.0, "slideawayleft")
define slideawayup = CropMove(1.0, "slideawayup")
define slideawaydown = CropMove(1.0, "slideawaydown")
define irisout = CropMove(1.0, "irisout")
define irisin = CropMove(1.0, "irisin")
Dissolve
(time, alpha=False, time_warp=None, **properties) linkReturns a transition that dissolves from the old scene to the new scene.
When the dissolve will be scaled to less than half its natural size, the
mipmap
style property can be set to True. This will cause mipmaps
to be generated, which will make the dissolve consume more GPU resources,
but will reduce artifacts.
Fade
(out_time, hold_time, in_time, *, color="#000") linkReturns a transition that takes out_time seconds to fade to a screen filled with color, holds at that screen for hold_time seconds, and then takes in_time to fade to then new screen.
# Fade to black and back.
define fade = Fade(0.5, 0.0, 0.5)
# Hold at black for a bit.
define fadehold = Fade(0.5, 1.0, 0.5)
# Camera flash - quickly fades to white, then back to the scene.
define flash = Fade(0.1, 0.0, 0.5, color="#fff")
ImageDissolve
(image, time, ramplen=8, reverse=False, alpha=True, time_warp=None, **properties) linkReturns a transition that dissolves the old scene into the new scene, using an image to control the dissolve process. This means that white pixels will dissolve in first, and black pixels will dissolve in last.
define circirisout = ImageDissolve("circiris.png", 1.0)
define circirisin = ImageDissolve("circiris.png", 1.0, reverse=True)
define circiristbigramp = ImageDissolve("circiris.png", 1.0, ramplen=256)
When the dissolve will be scaled to less than half its natural size, the
mipmap
style property can be set to True. This will cause mipmaps
to be generated, which will make the dissolve consume more GPU resources,
but will reduce artifacts.
MoveTransition
(delay, enter=None, leave=None, old=False, layers=['master'], time_warp=None, enter_time_warp=None, leave_time_warp=None) linkReturns a transition that interpolates the position of images (with the same tag) in the old and new scenes.
MultipleTransition
(args) linkReturns a transition that allows multiple transitions to be displayed, one after the other.
A list containing an odd number of items. The first, third, and other odd-numbered items must be scenes, and the even items must be transitions. A scene can be one of:
Almost always, the first argument will be False and the last True.
The transitions in args are applied in order. For each transition, the old scene is the screen preceding it, and the new scene is the scene following it. For example:
define logodissolve = MultipleTransition([
False, Dissolve(0.5),
"logo.jpg", Pause(1.0),
"logo.jpg", dissolve,
True])
This example will dissolve to logo.jpg, wait 1 second, and then dissolve to the new scene.
Pause
(delay) linkReturns a transition that only displays the new screen for delay seconds. It can be useful as part of a MultipleTransition.
Pixellate
(time, steps) linkReturns a transition that pixellates out the old screen, and then pixellates in the new screen.
PushMove
(time, mode="pushright") linkReturns a transition that works by taking the new scene and using it to "push" the old scene off the screen.
define pushright = PushMove(1.0, "pushright")
define pushleft = PushMove(1.0, "pushleft")
define pushup = PushMove(1.0, "pushup")
define pushdown = PushMove(1.0, "pushdown")
Swing
(delay=1.0, vertical=False, reverse=False, background="#000", flatten=True) linkA transitions that rotates the old scene 90 degrees around an axis, so that it is edge on with the viewer, switches to the new scene, and then rotates that scene another 90 degrees to show the new scene to the viewer.
Transition families are functions that define a large family of related transitions.
define.
move_transitions
(prefix, delay, time_warp=None, in_time_warp=None, out_time_warp=None, old=False, layers=[u'master'], **kwargs) linkThis defines a family of move transitions, similar to the move and ease transitions. For a given prefix, this defines the transitions:
Time warp functions that are given a time from 0.0 to 1.0 representing the fraction of the move that is complete, and return a value in the same range giving the fraction of a linear move that is complete.
This can be used to define functions that ease the images around, rather than moving them at a constant speed.
The three arguments are used for images remaining on the screen, newly shown images, and newly hidden images, respectively.
# This defines all of the pre-defined transitions beginning
# with "move".
init python:
define.move_transitions("move", 0.5)
In many places where Ren'Py takes a transition, it's possible to instead specify a dictionary that maps layer names to this transition. When this is the case, Ren'Py applies each transition to the appropriate layer.
When a dict is used, the pause that usually occurs when a transition takes place does not occur. Instead, the statement taking the dictionary returns immediately, and the transitions are scheduled to occur at the start of the next interaction.
This can be used with the master layer to cause transitions to occur while dialogue is being shown on the screen. For example, if we wrote:
define dis = { "master" : Dissolve(1.0) }
and:
show eileen happy
with dis
e "Hello, world."
The dissolve will take place while the text is displayed on the screen.
Dict layer transitions can't be used every place a transition can be used,
only places where applying transitions to a layer is possible. It can be
used with the with
statement and with
cause of the scene, show, and
hide statements. It can also be used with renpy.with_statement()
and
renpy.transition()
, the Show()
and Hide()
actions, and
various config variables that take transitions. Dict layer transitions will not
work inside things that don't work with layers, such as ATL, ComposeTransition()
and MultipleTransition()
.
This can interact poorly with statements that cause a transition to occur
themselves, like the transitions caused by window auto
. That can often be
solved with a second dict transition that applies to a different layer.
For example, if you are seeing weird blinking when the dialogue window shows
and hides, consider changing options.rpy to have:
define config.window_show_transition = { "screens" : Dissolve(.25) }
define config.window_hide_transition = { "screens" : Dissolve(.25) }
This works because the dialogue window exists entirely on the screens layer.
ATL Transitions, Transitions using Python : how to create transitions using the ATL system and Python, respectively