Translations by 이어진

Displayables

A displayable is an object that can be shown to the user. Ren'Py displayables can be used in many ways.

Assignment to an image name using the image statement.

Added to a screen using the screen language add statement.

Assignment to certain config variables.

Assignment to certain style properties.

When a Ren'Py function or variable expects a displayable, there are four things that can be provided:

An object of type Displayable, created by calling one of the functions given below.

A string with a dot (.) in it. Such a string is interpreted as a filename by :func:`Image`.

An image name. Any other string is interpreted as a reference to an image defined with the image statement.

Images

The most commonly used displayable is Image, which loads a file from disk and displays it. Since Image is so commonly used, when a string giving a filename is used in a context that expects a displayable, an Image is automatically created. The only time it's necessary to use Image directly is when you want to create an image with style properties.

Loads an image from a file. `filename` is a string giving the name of the file.

`filename` should be a JPEG or PNG file with an appropriate extension.

Loading an Image from from a file on disk and decoding it so it can be drawn to the screen takes a long amount of time. While measured in the tenths or hundreds of seconds, the duration of the loading process is long enough that it can prevent an acceptable framerate, and become annoying to the user.

Since an Image is of a fixed size, and doesn't change in response to input, game state, or the size of the area available to it, an Image can be loaded before it is needed, and placed into an area of memory known as the image cache. Once an Image is decoded and in the cache, it can be quickly drawn to the screen.

Ren'Py attempts to predict the images that will be used in the future, and loads them into the image cache before they are used. When space in the cache is needed for other images, Ren'Py will remove images that are no longer being used.

By default, Ren'Py will predictively cache up to 8 screens worth of image data. (If your screen is 800x600, then a screen's worth of data is one 800x600 image, two 400x600 images, and so on.) This can be changed with the :var:config.image_cache_size configuration variable.

Although the precise amount is dependent on implementation details and there is significant overhead, as a rule of thumb, each pixel in the image cache consumes 4 bytes of main memory and 4 bytes of video memory.

Image-Like Displayables

We call these displayables image-like because they take up a rectangular area of the screen, and do not react to input. These differ from normal images by varying their size to fill an area (Frame, LiveTile, and Solid), or by allowing the user to specify their size (LiveComposite, LiveCrop, Null). They are not image manipulators.

Image-like displayables take :ref:`position-style-properties`.

This flattens `child`, which may be made up of multiple textures, into a single texture.

Certain operations, like the alpha transform property, apply to every texture making up a displayable, which can yield incorrect results when the textures overlap on screen. Flatten creates a single texture from multiple textures, which can prevent this problem.

Flatten is a relatively expensive operation, and so should only be used when absolutely required.

A displayable that resizes an image to fill the available area, while preserving the width and height of its borders. is often used as the background of a window or button.

Using a frame to resize an image to double its size.

`image`

An image manipulator that will be resized by this frame.

`left`

The size of the border on the left side.

`top`

The size of the border on the top.

`right`

The size of the border on the right side. If None, defaults to `left`.

`bottom`

The side of the border on the bottom. If None, defaults to `top`.

`tile`

If true, tiling is used to resize sections of the image, rather than scaling.

This created a displayable by cropping `child` to `rect`, where `rect` is an (x, y, width, height) tuple. ::

Tiles `child` until it fills the area allocated to this displayable.

A displayable that creates an empty box on the screen. The size of the box is controlled by `width` and `height`. This can be used when a displayable requires a child, but no child is suitable, or as a spacer inside a box.

A displayable that fills the area its assigned with `color`.

Dynamic Displayables

Dynamic displayables display a child displayable based on the state of the game. They do not take any properties, as layout is controlled by the properties of the child displayable they return.

This is a displayable that changes what it is showing based on python conditions. The positional argument should be given in groups of two, where each group consists of:

A string containing a python condition.

A displayable to use if the condition is true.

The first true condition has its displayable shown, at least one condition should always be true.

A displayable that can change its child based on a Python function, over the course of an interaction.