head	1.1;
access;
symbols;
locks; strict;
comment	@ * @;


1.1
date	2026.07.23.14.03.50;	author ryoon;	state Exp;
branches;
next	;
commitid	385Ohg8RzdQ6GMOG;


desc
@@


1.1
log
@games/py-renpy: Update to 8.5.3

Changelog:
8.5.3

Dependency Updates

Ren'Py now supports and requires Live2D 5.3. You may need to update Live2D to
continue to use it in Ren'Py 8.5.3 or later.

Ren'Py Stores as Python Packages

Ren'Py now treats Ren'Py stores as Python packages, as was documented but not
implemented. This means imports can work from other stores. For example:

init python in store.substore1:
    A = 42

init python in store.substore2:
    B = 37

init python:
    from store.substore1 import A
    from store.substore2 import B

Note that such imports assign names, but do not create aliases. Updating A in
the main store will not change its value in substore1, and vice versa.

Parse Error Improvements

Parse errors are now reported at the end of each priority level (libs, then the
game, then mods). Within a priority level, parse errors in filenames that begin
with a number (like 01statement.rpy or 01lib/statement.rpy) are reported before
parse errors in files that begin with letters.

This change is meant to allow parse errors in files defining creator-defined
statements to be reported before parse errors in the game script caused by the
use of a statement that is not properly defined. This allows creators to more
easily identify and fix problems with their creator-defined statements.

Fixes and Changes

renpy.pause() now always pauses for at least one frame. Previously, it could
avoid pausing after rollback.

There have been several improvements to dragging viewports that cure situations
where the viewport could be dragged without the mouse button being held down.

Automatic detection of language on macOS should work in more situations.

The new config.mesh_oversample variable can be configured to control how much a
mesh texture can be oversampled by, preventing additional blurriness when
scaled up. This defaults to 1.0 (disabled) in this version, but this will
change in Ren'Py 8.6.

The new config.say_menu_text_filters list of functions supplements the existing
config.say_menu_text_filter function.

An issue that could cause Ren'Py to corrupt data in a very specific case has
been fixed. The issue would occur when a Python finally or except block would
run as the stack was unwound after a load, and it would restore old data
inappropriately. This is an unlikely error, but could happen in Python-heavy
games.

Several low-probability crashes and memory leaks have been fixed.

Anisotropy is now disabled when nearest_neighbor sampling is used, preventing
blurriness.

The default value of the synchro_start parameter to
renpy.audio.register_channel(), which controls if music waits for queued music
on other channels to be played, is now the default loop value of the channel,
in all cases.

The value of mouse_visible is now properly restored when exiting the game menu.

The say behavior (used by dialogue) no longer lets you dismiss dialogue if the
screen is grabbed by another displayable, such as a viewport being dragged.

The camera statement is now documented to propagate transform state. (This was
always true, but was not documented.)

The nestled and nestled-close click-to-continue indicators now detect and
respect RTL languages.

Nestled and nestled-close click-to-continue indicators are now rendered at 0
width in all circumstances. This prevents a class of issues that could occur
with NVL-mode, retained bubbles, and other configurations. This is equivalent
to rendering the text without a click-to-continue indicator, and then placing
the CTC indicator next to the end of the rendered text. (This is similar to how
{w}, {p}, and extend were already handled.)

Translations

A Portuguese translation of the Ren'Py tutorial has been added.

An Italian translation of the Ren'Py tutorial has been added.

The Persian translation of the Ren'Py tutorial has been updated.

Features

When defining styles used by ruby text or style text tags, more style
properties can be set to None to use the value from the parent text. As of this
version, the following properties may be set to None: antialias, axis,
black_color, bold, color, font , font_features, hinting, instance, italic, size
, and textshader.

Due to that change, When using ruby text, you may now set font None, and the
font will be inherited. For example:

style ruby_style is default:
    size 12
    yoffset -20
    color None # Use the same color as the parent text.
    font None # Use the same font as the parent text.

The mouse_visible variable now has a new "always" value, which makes the mouse
always visible. This is useful for games that need to force the mouse to be
shown for minigame purposes.

Support has been added for a system-installed copy of the VSCodium text editor.
This is a libre build of the same source code that makes Visual Studio Code.

The Transform.unique() method has been added, which marks a transform as
unique. This prevents the transform from being copied when added to a
displayable, which allows the transform to maintain state across multiple uses,
or be referenced from outside its function argument.

8.5.2

Fixes

Fixes an issue where each time Ren'Py checked to see if rollback is possible,
one level of rollback would be consumed.

8.5.1

Fixes

Ren'Py will now properly compute the auto-forward time for text ending with the
no-wait ({nw}) text tag, followed by extend, as in:

e "This is {nw}"
extend "more text."

Ren'Py now unwinds the call stack before performing a rollback or load. This
prevents issues with caused except and finally blocks being executed after a
rollback, which could lead to the rolled-back data being changed.

Ren'Py now skips files and directories beginning with a dot (e.g. .hidden.rpy)
when scanning the filesystem. These files often have special meaning on unix
and mac platforms.

Speech bubble dialogue is only retained at the end of a sequence of pauses, not
every time.

Mouse Changes/Fixes

Ren'Py now cycles through a set of possible mouse cursor names when determining
which cursor to use. This includes the cursor based on the displayable (eg.
button), the screen type (eg. gamemenu), and the default.

MouseDisplayable now allows a mouse cursor to be None, to use the system
cursor.

Ren'Py now merges MOUSEMOTION events that occur in rapid succession at a lower
level, making the game more responsive when faced with mice that produce many
events per frame.

Other Changes

There is now a text safe mode that will display text with text-tag errors, when
the config.safe_text is set. This variable defaults to True in released games,
and False in developer mode.

Ren'Py now includes a cut-down version of the brotli python module. This
version supports the decompress method and Decompressor object, but leaves out
the Compressor object. It's intended to allow requests to handle
brotli-compressed responses.

Playing a voice line now stops ongoing self-voicing playback.

The new config.tlid_only_considers_say variable prevents non-say statements,
such as the voice statement, from contributing to translation identifiers.
(Translation identifiers are used for other things as well, like tracking
speech bubbles.) This variable defaults to False, but will become True in
Ren'Py 8.6. Setting this to true has the potential to change Translation
identifier if your game uses voice statements.

The bubble.area_property variable has become documented. This controls how the
area of a speech bubble is supplied to dialogue. It's now documented how to
supply the area as an argument to the bubble screen for further control.

There is a new "interact_done" character callback, which is called after each
interaction ends.

8.5.0

Live2D Web

Ren'Py now supports Live2D models on the web platform. This support includes
both launcher support for installing the Cubism SDK for Web, and support in
Ren'Py for loading Live2D models in the web environment.

Automated Testing

Ren'Py now includes a testing framework that makes it possible to define and
run automate tests of games and of Ren'Py itself. The testing framework is
designed to perform automated functional testing - for example, clicking
through a predefined sequence of dialogue and choice, and making sure the game
reaches the end without crashing, even when the game or engine is changed.

The testing framework is intended to be run in an environment with working GUI
support - most notably, working OpenGL is required, as the testing framework
exercises the full engine, including the portions of the engine that render the
game.

Testing can be run from the launcher, or from the command line using the test
command. The 'Run testcases' command is only present if at least one testcase
exists in the game. The Tutorial is a good project to use to see automated
testing in action.

Local Labels

Local labels have been relaxed so that they can be declared with any global
label. It's now possible to have in chapter_1_part_1.rpy:

label chapter_1:
label chapter_1.part_1:
    # ...

And then in chapter_1_part_2.rpy:

label chapter_1.part_2:
    # ...

Steam Support

Ren'Py now uses and requires Steamworks SDK 1.62.

When config.automatic_steam_timeline is set, Ren'Py will now use save_name to
set the game phase. (It's best to consider save_name to be a chapter name).
Previously, it would annotate timeline states instead of game phases.

Font and Unicode Support

Ren'Py now supports the WOFF2 font format, a modern and highly-compressed font
format. Support for the older WOFF format has been made official. The
config.font_name_map and config.font_replacement_map variables may be useful to
creators that wish to replace TrueType fonts with WOFF2 fonts.

Ren'Py's unicode support has been updated to include support for Unicode 17
characters.

The emoji font used by Ren'Py has been updated to include 435 more glyphs, with
other glyphs having been updated. (This includes most Unicode 16 emoji, but not
unicode 17 emoji.)

Gui Default Changes

There have been multiple changes to how the gui namespace interacts with the
default statement, designed to make how Ren'Py behaves match how it was
documented to behave. As of this release, gui variables set with default...

  * ... are set when the game starts or restarts.

  * ... can be changed in python blocks.

  * ... retain the last set value when the language changes.

  * ... are saved and loaded like other variables.

These changes only apply to variables that are initially set with default. All
variables in the gui namespace should be set with one of default or define.

Pygame_SDL2 Removal

Ren'Py no longer depends on the pygame_sdl2 project. To support future
development, such as a port to SDL3, most of pygame_sdl2 has been merged into
Ren'Py as the renpy.pygame package. For compatibility's sake, renpy.pygame is
importable as pygame or pygame_sdl2, though:

import renpy.pygame as pygame

is now the recommended way to import pygame-like functionality.

This change simplifies the Ren'Py build process. On Linux, it's now possible to
create a build of Ren'Py for development purposes using the uv tool.

Other Changes

Ren'Py's support for 32-bit ARM platforms is now built using 16 KB pages, which
prevents the Play Console from producing a warning.

Multiline input displayables now support the use of the up arrow and down arrow
keys to move the cursor to the next and previous line. As this works using the
character offset, it will work best with monospaced fonts.

The thumb_align property is now a style property rather than a keywork
property, and is supported in styles.

When exporting dialogue, Ren'Py will detect the special extend character and
include the prior character's name in the exported dialogue line.

The xmaximum and ymaximum properties can now increase the size offered to a
displayable beyond what is offered by its container.

The screen statement now requires a block. It always was documented as
requiring a block, but this was not enforced.

Setting config.tracesave_screenshot makes it possible to control if a
screenshot is taken when a traceback save is made.

The new before_load special label and config.before_load_callbacks make it
possible to change what is displayed and what sounds are played as a load
happens.

The new config.locale_to_language_map variable is a dictionary mapping locale
strings to language names, allowing config.enable_language_autodetect to be
customized more easily.

Movie() displayables now allocate channels dynamically when the movie is
playing. Previously, each Movie would allocate a channel when the movie was
created, which could lead to large amounts of memory in use to store the
channels and associated buffers.

The init_priority argument to the renpy.register_statement() function can now
be a function that returns the init priority, rather than an integer.

Ren'Py will no longer attempt to load .rpy files beginning with a dot (e.g.
.hidden.rpy), as these are hidden files on unix-like platforms.

When running the execute_init or execute_default functions in a creator-defined
statement, renpy.get_filename_line() will return the statements's filename and
line number.

The renpy.filename_line_override() context manager makes it possible to
override the filename and line number returned by renpy.get_filename_line().

The config.images_directory variable has been superseded by
config.image_directories, which is a list of directories that Ren'Py searches
for images.

The new config.context_callbacks variable makes it possible to define multiple
callbacks that are called when a new context is entered.

The game.zip file produced by the web platform no longer contains .py files.

Ren'Py will now prompt you to close other Ren'Py games before an upgrade. This
addresses problems on Windows that could be caused by launcher files in use by
games that are running during the upgra

Support for RTL languages is now enabled by default, so it is no longer
necessary to set config.rtl.

The new config.adjust_audio_amplitude allows a global adjustment of the
amplitude of all audio played through Ren'Py.

Fixes

A crash caused by improperly stored video textures has been fixed.

Alpha premultiplication is now properly performed on image-based fonts,
allowing proper alpha blending of these fonts.

Several problems editing the script (manifesting in in the interactive director
and the add from to calls command) hav been fixed.

An issue with the scaling of oversampled videos has been fixed.

8.4.1

Fixes

Ren'Py will no longer report "Leaking texture: 0" warnings, which could be
spurious in some cases.

On the web platform, textures are reloaded when the browser window is resized,
preventing the textures from appearing transparent or black.

Playing a movie on the web platform no longer causes Ren'Py to produce a stream
of warnings.

The gui.SetPreference() action once again rebuilds the styles after the
preference is set.

The config.dissolve_shrinks option, which provides backwards compatibility for
AlphaDissolve transitions and AlphaBlend() displayables with mismatched child
sizes, now works as intended.

Copying translations between games now works correctly. This is especially
important for transferring translations from the launcher to newly-created
games, ensuring new non-English games are set up properly.

Diagnostic print statements that could appear when playing movies on the web
platform have been eliminated.

The pixellate transition now functions as expected.

Features

Ren'Py now scans for templates in subdirectories of the projects directory.

Ren'Py now supports Python's importlib.resources module. This provides a way to
load the resources in a Python package, even if that Python package is stored
in an RPA archive or an Android APK or asset pack.

Other Changes

The lint check for when translation functions are called with the wrong number
of arguments was too slow, to be included in lint, and so this check has been
removed for the time being.

Support for right-to-left languages is now enabled by default.

When loading a Python module or package from disk, Ren'Py will now set the
__file__ attribute to the absolute path of the module or package. This reverts
a change made in Ren'Py 8.4.0, which set the __file__ attribute to the path
relative to the game directory. When loading a module from an RPA archive or
Android APK, this changes to a relative path starting with $game. This change
is meant to help more pure Python packages work with Ren'Py, but we recommend
that you do not rely on the __file__ attribute in your code, and use
importlib.resources instead.

It's now possible to revert the audio volume drop caused by the constant power
panning change in Ren'Py 8.1. (This can also be worked around by adjusting
mixer volumes.)

8.4.0

Requirement and Dependency Changes

Ren'Py now requires Windows 10 or later to run. This means that it will no
longer run on Windows 7, 8, or 8.1.

Ren'Py now targets Ubuntu 20.04. This also means it targets the "soldier"
version of the Steam Linux Runtime.

Ren'Py is no longer built for 32-bit ARM Linux. This drops support for the
Raspberry Pi 3, and very old Chromebooks. Ren'Py is still being built for
32-bit ARM Android. Ren'Py will now prefer the gles2 renderer on ARM Linux
devices, such as the Raspberry Pi.

The Android version of Ren'Py is now being built with 16KB pages, for future
Android devices that will require 16 KB page support.

Python 3.12

Ren'Py now uses Python 3.12 on all platforms. This makes avilable several years
of Python improvements. To finds all of them, please see:

  * What's New in Python 3.10

  * What's New in Python 3.11

  * What's New in Python 3.12

One of the most visible changes caused by this is that Ren'Py will now report
the location of Python errors at sub-line granularity, rather than at line
granularity. In tracebacks, the portions of a line that contribute to an error
will be colored or underlined.

Performance Improvements

Script Loading The internal respresentation of the game script has been changed
to reduce the amount of memory used and to improve loading time, by only
representing data that varies from the default. For a large game where initial
startup is dominated by script loading, this improved the time it takes to load
the script by 50%.

Persistent Data The persistent data format has been changed to use numeric
hashes of visited script locations, rather than the full script location. These
hashes can be saved and loaded much more quickly, which improves game
performance when the persistent data is large.

OpenGL Drawing Ren'Py's OpenGL drawing code has been changed to remove
allocations of matrix objects, and to reduce the amount of math that needs to
be done in many cases. This can improve performance when drawing scenes with
large numbers of drawing operations, as those scenes can be CPU-bound.

Similarly, the OpenGL drawing code has been changed to avoid the repeated
allocation of dictionaries that contain shader variables.

Live2D When rendering Live2D models, Ren'Py will avoid doing unproductive work
to create Renders for layers that are not visible, and masks that are not used.
This can improve performance when using Live2D models with many layers.

Shaders

Ren'Py's GLSL shader support now allows uniforms of types int, bool, ivec2,
ivec3, ivec4, and bvec2, bvec3, bvec4, in addition to the support for float,
vec2, vec3, vec4, mat2, mat3, mat4 and sampler2D that Ren'Py has always had.

Ren'Py's GLSL shader support now allows one-dimensions arrays of uniforms of
scalar and vector types, but not arrays of matrices or samplers.

Ren'Py now can supply separate model to world (u_model), world to camera view
(u_view), and camera view to viewport (u_projection) matrices to shaders. These
matrices are supplied as uniforms. There are also a u_projectionview matrix
that combines u_projection and u_view, and the existing u_transform matrix is
all three. Breaking these out allows OpenGL shaders to support lighting.

Ren'Py's GLSL shader support now supports performing operations on the
underlying data before passing it to a uniform. For example, if u_color is an
RGBA uniform, u_color__premul is that color, premultiplied by its alpha
channel. Other suffixes get the resolution of a texture, and can perform
inverse, transpose, and inverse transpose operations on matrices.

Inside Transforms, Ren'Py now supports uniforms of type sampler2D. These are
textures that are set up to sample textures. These transforms can be supplied a
displayable or a string that becomes a displayable.

GLTF Model Loading

Ren'Py now has a minimal ability to load 3D models defined in the GLTF format,
using the Open Asset Importer library. Models can be loaded using the GLTFModel
displayable.

Right now, the GLTFModel loading only supports loading the mesh and textures of
a model. There's no support for animation or other features of GLTF. What's
more, the default Ren'Py shaders only show the base colors, and a custom shader
is required to handle the other portions of physical-based rendering (PBR) that
GLTF supports.

The current GLTFModel support is is likely useful for people who want to use 3D
backgrounds in their games, but may require a skilled developer to position the
model in 3D space. It's also intended for developers that want to experiment
and contribute insights and development back to Ren'Py. A future release will
include more tools for working with objects in three dimensions.

Optional Mipmaps

Mipmaps are smaller versions of an image that are used when Ren'Py scales an
image down. Using mipmaps prevents the image from becoming jagged when scaled
down, but generating mipmaps takes time and can cause the game to use more
memory.

Ren'Py now leaves the decision of if to create mipmaps to the developer, who
knows if the game will scale down an image. By default, Ren'Py will create
mipmaps for all images it loas. A new mode will only only create mipmaps when
the display is scaled down to less than 75% of the virtual window size. This is
suitable for games that do not scale down images, but for which the window size
may be smaller than the virtual window size.

To enable this new mode, set config.mipmap to "auto".

Mipmaps will automatically be created for images loaded for the purpose of
Live2D or GLTFModel, as these are likely to be scaled down. Mipmaps can be
created for specific images by providing True to the mipmap parameter of Image
().

Libs and Mods

Ren'Py now includes support for two more special directories, game/libs and
game/mods. These directories are intended to receive third-party libraries and
mods, respectively.

When the file game/libs/libs.txt exists, script files inside game/libs have the
first directory removed, if any, and are loaded in unicode order by the path
not including that directory. Similarly, when the file game/mods/mods.txt
exists, script files inside it are loaded in unicode order by the path, not
including that directory.

Note that load order is relatively unimportant in Ren'Py - it's mostly used
with Creator-Defined Statements. Init priorities levels have been changed to
recommend that games use init priorities of -99 to 99, and libraries and mods
use from -999 to -100 and 100 to 999.

When present, the libs and mods directories are showing in the launcher. The
libs directory is created automatically when the game is created. The mods
directory can be created manually if a creator wants to support mods.

The goal of this change is to make it easier to distribute third-party
libraries and mods. Instead of needing to be merged with the player's script, a
library can be placed under game/libs, and will provide full functionality
there.

.rpe and .rpe.py files are also searched in the libs directory.

Layered Images

The variant and prefix properties, which accepted any value but evaluated it
(as a string) only at init time, now accept an unquoted image name component
(digits, letters and underscores, no space or dash, may start with a digit).

In places where the syntax allowed the at keyword, it now allows an at
transform: block.

In places where a displayable is expected, it is now possible to use an image:
block, and to define an ATL image, like an anonymous Image Statement with ATL
Block.

The new when property introduces a more straightforward boolean condition
syntax, replacing the if_any, if_all and if_not properties which remain
supported for backwards compatibility. The new syntax removes the need for
lists and quoting. To convert to the new syntax, you can replace:

if_any ["a", "b"]
if_all ["c", "d"]
if_not ["e", "f"]

with the more concise:

when (a or b) and c and d and not (e or f).

The multiple groups may now be anonymous, and should from now on be defined
with the multiple keyword placed in lieu of the group name. This makes their
behavior more consistent and easier to understand. The behavior of named
multiple groups is unchanged, but they should not be used going forward.

The attribute statement now takes the variant property, unless it is inside a
group with a variant, or it is directly assigned a displayable. This allows
native support for cases which previously required a multiple group with a
variant, or an attribute_function manipulation.

Automatic Oversampling

Ren'Py will now automatically look for oversampled version of images, and use
those if the game is scaled up.

As an example, take loading "eileen happy.png". When the game is scaled to more
than 100% of it's virtual size, when loading "eileen happy.png", Ren'Py will
also look for "eileen happy@@2.png", and load that if it exists. When scaled to
more than 200%, it will look for "eileen happy@@4.png", "eileen happy@@3.png",
and "eileen happy@@2.png". If none of these exist, it will use "eileen
happy.png".

Ren'Py also supports oversampling and automatic oversampling for movies played
using Movie and renpy.movie_cutscene(). This works similarly to images, with
respect to filenames.

Accessibility

The shift+A accessibility menu has been redesigned. It's now smaller, so that
the bottom of the game (usually including dialogue) is visible, allowing the
effects of the menu to be seen more immediately. It also has been broken up
into multiple pages, to allow for new options to be added.

Ren'Py can now force audio to mono, allowing sounds contain information on only
the left or right channel to become audible on both. This can be enabled
through the shift+A accessibility menu, the "force mono" Preference(), or the
preferences.force_mono variable.

Ren'Py now includes a preference to allow the user to adjust font kerning. This
is exposed through the accessibility menu, the "font kerning" Preference(), and
the preferences.font_kerning variable.

Launcher

The launcher now supports games being placed into folders, which can be
collapsed and expanded. To put a game in a folder, create a directory
underneath the projects directory, and move the game into that directory.

The launcher's "Console output" option now works on the Macintosh platform.

Building an update will now produce a public_key.pem file, containing key
material that can be shared with the world. When building a downloader game,
this file should be copied to the base directory of the downloader game. This
is the public key that will be used to verify the download.

When creating a new game, Ren'Py will now include a .gitignore file that
contains a default set of files to ignore.

It's possible to customize the Ren'Py launcher to select the files and
directories that are available to click on.

Text

Ren'Py now supports OpenType font layout features, which can control things
like ligaturization and other settings. These features are controlled by the
font_features style property, and the features text tag.

A problem with mark positions on ligatures has been fixed. This mainly affected
Arabic, but applies to all text. Note that this fix is only available when
using the Harfbuzz shaper.

The reading_order style property has been added so that a preference for the
directionality of text may be expressed when config.rtl is True. Setting it to
"wrtl" (weak right-to-left) will cause directionally neutral lines to be
displayed right-to-left (previously they would always be displayed
left-to-right). This is mostly to support punctuation-only dialogue lines in
RTL language games and translations.

Finally, a regression in how bidirectional text embedding was handled when
using the Harfbuzz text shaper introduced in 8.3.7 has been fixed. Text
containing runs of both LTR and RTL characters will now render with the correct
directionality for the individual runs again.

Traceback Saves

If possible, Ren'Py now creates saves when an uncaught exception occurs,
containing both the game state and the traceback. These saves are stored in
slots with the name _tracesave-1 to _tracesave-10. and have the traceback
accessible through the json metadata.

The new renpy.get_save_data() function allows you to retrieve the data for a
particular save slot, without loading the save. This can be used with a
traceback save to retrieve the game data without loading into an error state.

Features

The nearest transform property now works as documented, allowing nearest
neighbor texture interpolation to be disabled when set to False.

The new HasSideImage() function returns the presence or absence of a side image
before the side image itself is determined, making it useable in the say screen
for layout.

The new config.web_unload_music variable controls whether music is unloaded
when downloaded as part of progressive downloading.

The new config.clear_history_on_language_change variable controls whether
history is cleared when the language is changed.

MixerValue() now suports the step and force_step parameters.

The lint report can be configured to expand character aliases to names by
setting config.lint_show_names to True.

config.voice_callbacks allows you to define callbacks that are called when
voice lines are played or stop.

Grids now support right_to_left and bottom_to_top properties, which control the
order in which the grid is filled.

Character's ctc_position argument now takes a new value screen-variable. This
places the click-to-continue indicator in a screen variable, which allows it to
be positioned inside the screen. This is intended for use with speech bubbles,
to allow the click-to-continue indicator to be positioned inside the speech
bubble.

The new renpy.lex_string() function makes it possible to create a Lexer for an
arbitrary string.

The SpriteManager and SnowBlossom() displayables now support the animation
parameter, which can be used to prevent resetting when the displayable is
reshown.

The SnowBlossom() displayable now supports the distribution parameter, which
controls the distribution of how the particles are created, allowing the
particles to be created in the center or sides of the screen.

The Gallery class now supports separate transitions when entering a sequence of
images, going between images, and exiting the sequence of images.

Screens now support python-style docstrings, which are used when a string is
included as the first line of the block. Ren'Py does not do anything directly
with dosctrings, but the raw string can be accessed using
renpy.get_screen_docstring().

The Confirm action and renpy.confirm() function now pass additional keyword
arguments (not beginning with _) to the confirm screen.

The screen language use statement now takes an as clause, which can be used to
capture a variable named main from the screen. This is intended to be used like
the as clause of screen language displayables, which captures the displayable
into a variable.

Custom screen language statement also support the as clause.

The reset transform now resets all properties of a Transform.

Transform now takes a reset property, which controls whether the transform is
reset when it is used, as opposed to being given properties by other transforms
that share a tag.

The new renpy.seen_translation(), renpy.mark_translation_seen(), and
renpy.mark_translation_unseen() functions make it possible to determine if a
translation has been seen.

Audio filesname can now include a volume clase, like "<volume 0.5>
sunflower-slow-drag.ogg". This sets the relative amplitude of the track,
similar to the volume clause of the play and queue statements.

The new config.keep_screenshot_entering_menu variable determines if a
screenshot taken with FileTakeScreenshot is kept when entering a menu context.

The thumb_offset style property now can take a tuple giving different offsets
for the two sides of a bar. The new thumb_align style property controls how a
thumb is aligned with the bar.

The input displayable now takes an arrowkeys property, which controls whether
the arrow keys can be used to move the cursor in the input, or are used to move
the focus between displayables.

The config.translate_additional_strings_callbacks callbacks make it possible
for a game to offer additional to be added to translation files. (For example,
strings from third-party libraries or data files.)

The ___() (triple underscore) function makes it possible translate a string,
and then apply text interpolation to the result. Interpolations occur in the
scope of that the function is called from. The triple underscore function also
marks the string contained inside for translation.

The config.persistent_callback callback makes it possible to update persistent
data when it is loaded. Starting from this release persistent._version will
also be set to the current version of the game in any newly created persistent
data. This can be used with the callback to migrate persistent save data.

Changes

The renpy.get_renderer_info() function now returns a dictionary containing
information about user's GPU and graphics driver, when available.

Lint now reports when the translation functions (_(), __(), ___(), and _p())
are called with the wrong number of arguments.

When Ren'Py loads a Python module from the game/ directory, __file__ is set to
the relative path of the module.

Ren'Py now support showing the same Live2D displayable on multiple layers, with
multiple tags, or both.

Transform now has an attribute, original_child, that gives the child of the
transform before the function was called.

The behavior of mesh_pad has been changed when left or top padding is present.
Previously, this would offset the child by the padding amount. Now, the child
remains in the same place, with the padding added to the left and top of the
child.

From the Python typing module, the names Callable, Any, Self, Literal, cast,
overload, final, and override are imported into namespaces. These become
reserved names in Ren'Py, and should not be used as names in newly-developed
projects.

A regression that kept "Add From to Calls" from working has been fixed.

On the web platform, Ren'Py will now preload automatic voice lines, ensuring
the files can play immediately, even if not fully cached on the player's
device.

Text inputs (renpy.input() and the input displayable) disable non-required text
ligatures, so that ligaturization doesn't change when the caret moves.

Ren'Py will disable the screensaver (and hence, the system going to sleep) when
auto-forward mode is active.

A creator-defined statement that defines a label will now call
config.label_callbacks when run.

The "Click to play the video." screen used on some web platforms is now
translatable.

CTC indicators inside retained speech bubbles will now be cleared when the
player clicks past the dialogue.

In some circumstances, Ren'Py will reuse tuples containing immutable values
(float, int, bool, complex, str, bytes, and other immutable tuples), which can
reduce memory usage and improve performance. This may lead to these immutable
tuples having the same object identity when previously they would not have.

By default, Ren'Py now only creates mipmaps for textures if the display is
scaled down to less than .75 of virtual window size. This is suitable for games
that do not scale down images. To enable mipmapping again, set config.mipmap to
True.

Ren'Py no longer triggers and autoreload when a file that had not existed comes
into existence. This behavior had been inconsistent, working in some places but
not others, required Ren'Py to spent time scanning for files that do not exist.

Ren'Py now considers a dialogue statement to have been seen if a statement with
the same translation identifier has been seen.

For size reasons, the lists of seen dialogue and translations now store a
64-bit integer hash of the statement name or translation id.

The show expression statement has changed so that show expression "bg
washington" is equivalent to show bg washington. Previously, the expression
would be used as a tag, which would rarely be correct. If a displayable is
given instead of a string, a tag will be generated.

One the web platform, renpy.emscripten is the emscripten module, making it
available without needing to import it. You should still check that
renpy.emscripten is true before using it.

When config.nearest_neighbor is true, image fonts are scaled using nearest
neighbor scaling, rather than the default bilinear scaling.

The "Image Attributes" screen also indicates if transforms are applied to a
layer, as it can be hard to determine otherwise.

Ren'Py now also searches for .rpe and .rpe.py files in the new libs directory.

renpy.get_renderer_info() now also include GPU vendor and device name as well
as driver version.
@
text
@$NetBSD: patch-module_tinyfiledialogs_tinyfiledialogs.c,v 1.1 2023/11/23 15:41:21 ryoon Exp $

* Do not segfault under NetBSD.

--- src/tinyfiledialogs/tinyfiledialogs.c.orig	2023-11-23 13:03:29.419445256 +0000
+++ src/tinyfiledialogs/tinyfiledialogs.c
@@@@ -56,7 +56,7 @@@@ Thanks for contributions, bug correction
 
 #if !defined(_WIN32) && ( defined(__GNUC__) || defined(__clang__) )
 #if !defined(_GNU_SOURCE)
- #define _GNU_SOURCE /* used only to resolve symbolic links. Can be commented out */
+// #define _GNU_SOURCE /* used only to resolve symbolic links. Can be commented out */
 #endif
 #endif
 
@