pkgsrc-Changes archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
CVS commit: pkgsrc/games/py-renpy
Module Name: pkgsrc
Committed By: ryoon
Date: Sun May 11 14:08:34 UTC 2025
Modified Files:
pkgsrc/games/py-renpy: Makefile PLIST distinfo
pkgsrc/games/py-renpy/patches: patch-module_setup.py
Added Files:
pkgsrc/games/py-renpy/patches: patch-renpy_gl_glenviron__shader.pyx
Removed Files:
pkgsrc/games/py-renpy/patches: patch-renpy_audio_renpysound.pyx
patch-renpy_text_ftfont.pyx
Log Message:
games/py-renpy: Update to 8.3.7
Changelog:
8.3.7 / 7.8.7
Live2D
Fixed an issue where Expressions with a fadeout time of 0 would not hide properly.
Fixed an issue where Ren'Py would incorrectly size Live2D clipping masks. As this problem only affected layers that used clipping, this would often manifest as eyes being missing.
Live2D fading now uses cosine easing, as the Cubism Native SDK does.
Arabic Text Shaping
(As these changes require the Harfbuzz text shaper, the changes are only available in Ren'Py 8.)
When :var:`config.rtl` is set to True and Harfbuzz is enabled, Ren'Py will unmap Arabic presentation forms and allow harfbuzz to fully shape Arabic text. This allows Ren'Py to work with fonts that do
not contain Arabic presentation forms directly, but instead use ligaturization.
An issue with Harbuzz's adjustments of vertical positions has been fixed. This improves the positioning of text where ligatures control the vertical positioning of the text. While this affects some
Arabic fonts, it also may improve the location of marks in other fonts.
Changes
Vertex and fragment functions created with :func:`renpy.register_shader` are now placed after the variables defined by the shaders, making it possible to use uniforms in the functions.
Displayables embedded in slow text (most notably, nestled click-to-continue indicators) are now timed from when the displayable is revealed, rather than when the text block itself is show. This means
that the first frame of CTC animations will always be seen.
Fixes
Ren'Py will no longer change the position of newly-created maximized windows.
Problems caused by registering an audio channel more than once have been fixed.
Multiple say statements can now contain image attributes, like other say statements. Temporary image attributes are only supported in the last say statement in a multiple group.
Games made with Ren'Py 8.0 and 8.1 will have Python compiled with from __future__ import annotations, matching how Python in those versions was originally compiled.
:class:`SpriteManager` will no longer merge instances of a displayable that maintains internal state, like transforms. This is more correct, but slightly less efficient.
The language is now set when the game starts or is loaded, ensuring that translate python blocs are always run in the game context.
Text shaders now respect :propref:`slow_cps_multiplier`.
8.3.6 / 7.8.6
Fixes
Revert a change that prevented certain saves from loading.
8.3.5 / 7.8.5
Changes
Cyrillic characters are no longer used by the OpenDyslexic font in accessibility mode, as some of the characters are wrong in the version of OpenDyslexic that Ren'Py uses.
When laying out text, nestled CTC (click-to-continue) indicators that are not at the end of the text are considered to be of 0 size. This prevents the text from jumping around.
When laying out text with nestled CTC indicators, extend is taken into account.
A modal screen stops being modal as it begins hiding.
Ren'Py will now create pseudo-glyphs for the all textshaders, not just textshaders applied to text with outlines.
Ren'Py will now consider multiple dialogue when displaying empty windows.
Gles2 is now the default renderer on arm-linux, even if OpenGL is available.
When a file no_launcher_links.txt exist in the Ren'Py base directory, the launcher will disable all links to renpy.org, for environments where direct links to external sites are not suitable.
Displayables given to imagemaps are offered a full screen's worth of space when being rendered. Previously, the amount of space given to these displayables was undefined.
The itch butler tool is now downloaded from itch's new CDN.
Fixes
Non-moving children of a MoveTransform are now wrapped to ensure the child's timeline remains consistent.
A crash during reload when the speech bubble editor is displayed has been fixed.
Ren'Py now displays all outline offsets when using textshaders.
A crash caused by changing audio filters on the web platform has been fixed.
A font in a translation directory can now override a font in the game directory.
A crash during video playback on the web platform has been fixed.
Mouse coordinates passed to displayables embedded in text are now correct.
8.3.4 / 7.8.4
Fixes
Python Builtins (like len) are now always available during string interpolation.
Animated presplash images now take precedence over static presplash images, matching the documentation.
There have been a number of fixes related to dragging of viewports and drag displayables.
Movies are stopped when returning to a channel from a context.
An issue where autosave could hurt performance by causing interaction restarts has been fixed.
Ren'Py now uses the previous window type when running the nvl hide statement.
A displayable that does not support keyboard focus will now be ignored during keyboard focus computations.
An issue that could cause :ref:`sl-input` to not be masked properly when the contents of the input was a space was fixed.
An issue preventing Android and iOS keyboards from being shown when the window was empty has been fixed.
An issue that could cause the image cache to be managed incorrectly has been fixed.
An incorrect build prevented the web version of Ren'Py from working properly, on Ren'Py 7.8.3. This has been fixed.
Other Changes
Displayables rendered for imagemaps are offered (:var:`config.screen_width`, :var:`r images, but makes non-image displayables behave more consistently.
The ATL "update" event, which was issued in rare circumstances, has been removed.
The new :func:`renpy.get_statement_name` function returns the name of the currently executing Ren'Py st each time the movie is shown.
The :var:`config.nvl_adv_transition` no longer forces the dialogue window to be hidden.
Screens that are used by another screen are now updated properly if the interaction restarts before the screen is first rendered.
Thass:`Model` now creates meshes as described in the documentation when no textures are supplied.
The image attributes screen now quotes image and displayable names.
An issue with rollback not restarting music has been fixed.
Underlines and strikethroughaping.
Ren'Py now ensures that IMEs are activated on the primary window when the game starts, rather than on a presplash window.
Bars no longer lose the selected_hover prefix when adjusted using keyboard or game controller.
Rounding errors during pixel perfect text positioning have been fixed. These errors could cause text to jump 1 pixel during dissolves.
The rarely-used gl_anisotropic transform property now works.
The :propref:`keyboard_focus_insets` property now works as documented.
A rounding issue that could cause :propref:`bar_invert` to stop working has been fixed.
Ren'Py will render a displayable a second time if :propref:`box_wrap` is True, to ensure that the displayable is offered the correct amount of space when wrapped to a second line. In rare cases, this
could change layout.
Controller events can now cause Ren'Py to focus a displayable with default_focus set. Previously, these events weren't considered inputs by the focus system.
There have been a number of fixes to the way Ren'Py handles dragging a viewport filled with buttons.
A drag may now contain a draggable viewport, allowing a window to be more directly emulated.
Other Changes
Android bundles now use install-time assets packs, rather than fast-follow packs, to ensure that all assets are available when the game is run.
An :class:`AlphaMask` will now cause mask transformations to restart each time it is shown.
Displayables zoomed down to 0 pixels big will no longer get focus.
The "always" option to _renpysteam.keyboard_mode is no longer supported. If given, the "once" mode is used, requiring the player to explicitly request the Steam Deck keyboard when required.
The number of frames that Ren'Py passes through the rendering pipeline before switching to powersave mode has been increased to 12, to ensure that frames make it through compositors in a timely
manner.
Ren'Py locks the image cache less, which should prevent some frame drops when loading images.
Synchronized start of audio/video no longer occurs on movie channels unless explicitly requested.
When rolling back to a point where a looping :class:`Movie` was showing, the looping movie will be played again if it had been stopped.
A :class:`Movie` will only stop movies that it has played, rather than any movie on the associated channel.
When :func:`renpy.set_audio_filter` is called with immediate false, the filter will be applied when the queued file is played, rather than at some indeterminate time in the future.
The :class:`Frame` displayable is no longer adjusted to be pixel perfect, preventing visual glitches.
When using text shaders to display text with outlines, Ren'Py will create pseudo-glyphs. These pseudo-glyphs cover the start and end of each line, and are used to ensure the outlines will be shown.
8.3.2 / 7.8.2
Fixes
Fixed a build issue with 8.3.1 and 7.8.1 that prevented the Android version of Ren'Py from starting properly, making games unplayable.
8.3.1 / 7.8.1
Fixes
Image keywords (zorder, behind, at, onlayer, and transform) may not occur in an expression, like a list after at.
Using local shader variables by name in {shader} tags now works.
Textshaders now work with very large sizes and numbers of characters.
Lint avoids checking non-files as files.
The show_done character callback is now called and documented.
The web version of Ren'Py now saves persistent data when the screen is idle for .33 seconds.
The path to game.zip in a web build can now be configured by editing the generated index.html.
The web version of Ren'Py now defers calls to FS.syncfs, preventing errors that could be caused by files being rapidly renamed.
By default, synchronized start of audio now only occurs on looping channels, like music channels. The default can be changed on a channel-by-channel basis by supplying synchro_start to
:func:`renpy.music.register_channel`.
Other Changes
The new :func:`renpy.stop_skipping` cancels slow and fast skip.
Fast-skipping when slow-skipping (or vice versa) now cancels skipping.
On PC, Ren'Py will disable fullscreen when opening a URL.
Ren'Py now correctly clips displayables that are positioned at negative offsets to the parent, provided the displayable does not exit the clip rectangle.
:class:`AudioData` now explicitly supports video, and supports properties inside angles (like <from 1.0 to 6.0>).
:var:`config.font_transforms` is now documented. This allows you to define new font transforms for accessibility purposes.
The multiple argument to Character is now supplied to :doc:`character_callbacks`.
8.3.0 / 7.8.0
Audio Filters
This release adds an :doc:`audio filter system <audio_filters>` to Ren'Py, providing a way of processing the sound coming out of audio channels. The audio filter system is based on webaudio, and
includes the following filters:
Biquad, a way of implementing Lowpass, Highpass, Notch, Peaking, Lowshelf, Highshelf, and Allpass filters.
Comb, a delay line with filtering and feedback.
Delay, a delay line without the feedback.
Mix, a way of mixing two audio streams.
Sequence, a way of applying more than one filter to audio.
WetDry, a way of filtering a stream with a wet and dry control.
Reverb, a way of applying artificial reverb to the audio.
Text Shaders
This release adds support for :doc:`text shaders <textshaders>`, which are OpenGL shaders that are applied to text, using information that is provided by the rendering system. The big advantage of
this is it now becomes possible to change the way Ren'Py shows slow text to something else. For example, the dissolve text shader causes characters to dissolve in from left to right, rather than
showing all at once.
Text shaders are able to process the color of the text, including the alpha channel. Text shaders can also adjust the position of the text - for example, the jitter shader causes text to bounce
around.
Text shaders can be introduced using the {shader} text tag, using the :propref:`textshader` style, or using the :var:`config.default_textshader` variable. A text block should either use text shaders
or not - mixing is not supported.
Custom text shaders are supported using the :func:`renpy.register_text_shader` function. These have access to new uniforms and attributes that are appropriate to text display.
Other Shader Changes
Shaders part can now access :ref:`shader part local variables <shader-local-variables>` to prevent conflicts between variables used by different shader parts. While used mostly with text shaders,
shader part local variables are available for all shaders to use.
The new :var:`config.shader_part_filter` variable can be used to filter the shader parts that are used. This makes it possible to implement preferences that turn on and off shader parts as required.
Two new :ref:`model uniforms <model-uniforms>` have been added, u_drawable_size and u_virtual_size, making it easier to project gl_Positions in shaders to coordinates that are used elsewhere in
Ren'Py.
Visual Studio Code
The Ren'Py Language Visual Studio Code extension is now maintained by the Ren'Py project. As part of this, if you have a Visual Studio Code installed, the launcher will prompt you to install the new
extension.
Launcher Changes
Under Navigate Script, the TODOs button now has a count of TODOs next to it.
Under Navigate Script, the files view now has a checkbox that allows a creator to filter out translation files.
Window Statement Changes
There have been changes to the window statement:
window show and window hide no longer disable the automatic window management that Ren'Py does. Instead, these statements will immediately show or hide the window, without changing automatic
window management.
The new window auto False statement will disable automatic window management, and the new window auto True statement will re-enable it. (The existing window auto statement will also work, but
window auto True is preferred.)
The intent behind this is to make window hide more useful, as it can be used to hide the window for effects without disabling automatic window management.
When a window show occurs after window hide, Ren'Py will look forward to the next say statement to determine the type of the window to show. Previously, it looked back to the last say statement.
Screenshots and Paper Dolls
Taking a screenshot now hides the notify screen, so multiple screenshots do not leak the path to the previous one. This controlled by :var:`config.pre_screenshot_actions`.
The new :func:`renpy.render_to_file` and :func:`renpy.render_to_surface` functions make it possible to capture displayables (including trees of displayables, like layered images) and save that to a
file or a pygame_sdl2 Surface.
Steam
Ren'Py's Steam support has been updated to use the latest version of the Steam DLL.
There is now support for the Steam Timeline, part of the Steam Game Recording system. This support is controlled by the :var:`config.automatic_steam_timeline` variable. When true, the default,
:var:`save_name` is mirrored to the steam Timeline, as is the menu/laying state. It's possible to add additional events to the timeline using :var:`achievement.steamapi.add_timeline_event`. (Remember
to check that achievement.steam is not None before calling this function.)
Wrapped methods of the Steamworks API are documented on the :doc:`achievement` page.
Android
Ren'Py now targets Android 15 (API level 35), though versions down to Android 5 may still work.
Features
The new anymod keysym prefix makes it possible to bind to a key while ignoring the meta, alt, and ctrl key modifiers.
The translation identifier screen (accessed through shift+D) is now the translation info screen, and now includes information about the line being executed. If a language is selected, the screen will
also show the line being translated, and the text of the say statement being translated.
:doc:`cds` can now take an ATL block, which is supplied to the execute function as a keyword argument giving an ATL transform. It's also possible to define a creator-defined statement that optionally
takes an ATL block, or a block of script statements.
It is now possible to supply :ref:`menu arguments <menu-arguments>` to :func:`renpy.display_menu`, and the new :class:`renpy.Choice` class makes it possible to supply arguments to each item in the
menu.
The layer that bubbles appear on is now controlled by :var:`bubble.layer` and :var:`bubble.retained_layer`.
Retained speech bubbles are now automatically cleared away when other say, menu, or call screen statements are invoked. This is controlled by the :var:`bubble.clear_retain_statements` variable.
The :func:`renpy.get_ongoing_transition` function has been added. This returns the transition that is currently being applied to the top level or a layer.
The :var:`config.translate_ignore_who` variable makes it possible to ignore certain characters for the purpose of translations.
The :class:`Hide` action and :func:`renpy.hide_screen` actions now take an immediately keyword argument, which prevents 'on hide' handlers in the screens from running.
:doc:`character_callbacks` are now given information about the line of dialogue and the segment of the line that is being shown.
The :func:`renpy.call_in_new_context` and :func:`renpy.invoke_in_new_context` functions take an option _clear_layers keyword argument. When given, this controls which layers will be cleared when
changing to the new context.
The default volumes of mixers are now set by using the default statement with preferences.volume.<mixer>. For example, the default volume of the music mixer can be set with default
preferences.volume.music = 0.5. This also supports creator-defined mixers. Please see :ref:`mixer-defaults` for more information.
The :class:`ui.adjustment` class now takes a new raw_changed property, which takes the adjustment and the new value, before it's clamped. This can be used to perform actions when the adjustment
scrolls out of range.
The :class:`SplineMatrix` class has been added, which makes it possible to transform matrices in a non-linear way.
The Input displayable now takes an action property, which is an action that runs when the user presses enter with the text input active.
:ref:`Ruby/Furigana text <ruby-text>` can now inherit its color from the parent text, by setting :propref:`color` to None.
Transform now supports the :tpref:`fps` property, which quantizes time inside the transform to a particular number of frames per second.
Where appropriate, Bar Values now take min and max parameters, which can be used to define a range that is not zero-based.
Other Changes
The notification screen is now hidden before a screenshot is taken.
The :tpref:`crop` transform property now always takes the size of the crop box, even if bigger than what is being cropped.
The hspace and vspace text tags now respect window scaling.
Lint will now report obsolete image manipulators.
The :func:`renpy.open_file` function now returns an io.BufferedReader object when encoding is None, allowing the .peek method to be used.
Ren'Py will load .rpe.py files from :var:`config.renpy_base` directory and the project's game directory, and execute the file before the game starts.
Ren'Py will now load .rpe files from the :var:`config.renpy_base` directory as well as the project's game directory.
Files ending with .rpe or .rpe.py are excluded from the build process.
Images can now be oversampled at the directory level.
ATL polar coordinates now support the radius being a negative number.
The displayable inspector (Shift+Alt+I) now shows a displayable's id if it has one.
Displayables now have an id field, that contains the id given in screen language. The :var:`config.clear_log` variable has been added, which controls whether the dialogue log (:var:`config.log`) is
cleared each time Ren'Py starts.
Munging of names beginning with __ now takes place inside strings, to allow munged names to be used inside substitutions. This should be fairly transparent, but for a discussion of the implications
see :ref:`incompatible changes <munge-8.3.0>`
The :func:`renpy.fetch` function can now take user-specified headers that are supplied as part of the HTTP/HTTPS request.
Bar Values that set values (like :class:`DictValue`, :class:`FieldValue`, :class:`VariableValue`, :class:`ScreenVariableValue`, and :class:`LocalVariableValue`) now take a min and max parameters,
which can be used to directly set the bar's endpoints.
The :propref:`keyboard_focus_insets` style property makes it possible to have keyboard focus work with overlapping buttons, by artificially reducing the size of the buttons to remove the overlap,
when determining keyboard focus.
The synchro_start option (documented as part of :func:`renpy.music.play`) is now True by default in that function, and in the play statement. The implementation of :ref:`synchro start
<synchro-start>` has changed to make understanding it easier, while retaining the same behavior in most cases.
The web version of Ren'Py now supports loading video from origins other than the origin of the game, if the video origin allows for it.
8.2.3 / 7.7.3
This release fixes an issue that prevented 8.2.2 and 7.7.2 from being built properly.
8.2.2 / 7.7.2
Accessibility
The accessibility menu can be accessed on touch screens by making a large ⋀ gesture. That is, press, move a large distance up and right, move a large distance down and right, and then release.
There is a limited amount of self-voicing support for Android and iOS, largely limited by the nature of touch-screen focus. Dialogue will be read out, as will interface elements that become focused,
but right now it's hard to focus an element without activating it.
NVL-Mode and Window
The interaction of window auto and nvl mode, especially :var:`config.nvl_adv_transition` and :var:`config.adl_nvl_transition`, has been improved. The major change is that the latter transitions will
now only occur if the window has not been shown or hidden, preventing double interactions from occurring.
The (rarely used) nvl hide and nvl show statements now set the flag used by window auto, preventing the window from being shown wince in a row by these statements.
Fixes
Two issues that could cause the Android version of Ren'Py to lock up if the window lost focus have been fixed.
The force parameter to :func:`renpy.alt` now works as documented.
The :propref:`xfill` and :propref:`yfill` properties can no longer cause a window to shrink.
An issue where fonts with an incorrect line height would not work with the harfbuzz text shaper has been fixed.
List slicing is now allowed inside string interpolation. For example, The first ten are: [long_list[:10]] will now work.
Ren'Py will now generate translations for strings in _ren.py files.
Ren'Py now checks that achievement names are strings.
An issue with weakref pickling on Ren'Py 7 has been fixed.
The rpy statement is now considered to be always reachable.
The launcher no longer plays a stream of silence while it is running.
When building a small games as an Android App Bundle, fast-forward packages were incorrectly included. This has been fixed.
Other
The Traditional and Simplified Chinese translations have been updated.
Hovered handlers now run when a displayable is assigned thew default focus.
The attribute_filter callback of :class:`Live2D` is now always run.
The sound channel now fades out audio over the course of 16ms, just like the music channel does.
It is possible to have two :class:`Live2D` displayables using the same model but different default_fade times.
The new :var:`config.log_events` variable controls whether Ren'Py logs pygame-style events, for debugging.
The new :var:`config.python_exit_callbacks` lets you specify a list of callbacks that can be used to de-initialize Python modules just before Ren'Py shuts down.
The :var:`config.raise_image_exceptions` variable has been documented. It controls if Ren'Py will raise an exception when an image name is unknown, or display a warning instead.
The :var:`config.raise_image_load_exceptions` variable controls whether Ren'Py raises an exception when an image fails to load, or displays a warning instead.
The :var:`config.raise_image_load_exceptions` and :var:`config.raise_image_exceptions` variables are set to False when the player ignores an error.
When :var:`config.log_event` is true or RENPY_LOG_EVENTS is in the environment, Ren'Py will log most pygame-level events that happen.
When filtering text tags (with :func:`renpy.filter_text_tags` or places that call it), the axis tag is now handled correctly.
The statement callback system (:var:`config.statement_callbacks`) has been documented.
The modes system (renpy.mode, config.mode_callbacks, etc) have become undocumented. This was likely not used by any game, and has been replaced by :var:`config.statement_callbacks`. Mode callbacks
still work, but shouldn't be used by new games.
8.2.1 / 7.7.1
Text
The Harfbuzz text shaper now reads more information using Harfbuzz. This will generally yield the same results, with small exceptions, such as the underline being in a slightly different place.
Vertical text handling under the harfbuzz text shaper has been fixed to properly place the text. Porting those changes to the freetype shaper is not possible, so the freetype shaper no longer
supports vertical text.
See :propref:`vertical` for more information.
Updater
An issue with the updater that caused it to fail to sign updates when run on a Windows system has been fixed.
The updater now forces the webserver to use the identity encoding, which improves compatibility with some web servers. The updater also times out if the server does not respond to a request within 10
seconds.
Live2D
Ren'Py will now automatically guess the size of the live2d textures, and adjust the maximum texture size the live2d library uses to match it.
Ren'Py will avoid many render-to-texture operations when showing Live2D.
Fetch
The :func:`renpy.fetch` function now works during the image phase and during an interaction, as well as outside an interaction.
The :func:`renpy.fetch` function now takes a params argument, which specifies parameters that will be added to the URL.
Other Changes
When a textbox is replaced (using {w}), a replaced event is generated, rather than hide.
Adding a new displayable with default_focus set will cause the displayable to be focused, if the keyboard or gamepad is used, even if the interaction does not restart.
It's now possible to build an iOS app from the command line without installing rapt (Android support).
The renamed and newly-documented :var:`config.max_texture_size` variable make it possible to set the maximum texture size used by Ren'Py. This isn't useful for 2D textures, but may make sense for
textures used by :class:`Model`.
:doc:`template_projects` are no longer required to have the same files as a standard Ren'Py project.
Other Fixes
An issue that could cause an Android device to reach a black screen when resuming from pause has been fixed.
Ren'Py will now run from a directory with : in the name, on Linux and other platforms where that's legal.
The use of :var:`config.layer_transforms` will no longer reset the timelines of transforms set with camera or show layer at.
Lint no longer crashes when the a LayeredImage use a variable that isn't set.
A crash when :tpref:`blur` was less than 0 has been prevented, by clamping the blur value.
An issue that caused drags to block saving has been fixed.
8.2.0 / 7.7.0
Harfbuzz Integration
Ren'Py now uses the Harfbuzz library to perform text shaping. On all versions of Ren'Py, Harfbuzz is used to supply additional information to the freetype authinter.
On Ren'Py 8, Harfbuzz is also used to shape text, reordering and selecting glyphs based on the context they're in and the language of the text provided. This is required to support scripts that
require complex text shaping, such as Brahmic/Indic scripts. (You'll need to provide a font that supports the appropriate language.)
The new :propref:`shaper` style property controls the shaper used to text, for compatibility with older versions of Ren'Py.
Emoji-Related Text Improvements
Next, Ren'Py has gained the ability to render fonts that use the COLRv0 standard to provide color glyphs. Ren'Py ships with a font that contains the Twiemoji images, which covers a majority of the
Emoji in use (but not all of them).
Ren'Py will automatically switch to the Emoji font when it encounters Emoji characters in text. The supported characters are those in the Emoji 15.1 standard.
Ren'Py 8 with Harfbuzz shaping is required to render joining sequences of Emoji, including things like gender and skin-tone modifiers, so you'll need Ren'Py 8 to have those work. This switching
occurs when a font tag is not being used.
The new :propref:`emoji_font` and :propref:`prefer_emoji` style properties control Emoji font selection.
Fundamentally, you can include Emoji into your game by typing it into your script as character dialogue. For example:
e "I'm feeling 😃 today."
Variable Fonts
Ren'Py now supports OpenType variable fonts. These are fonts that use one or more axes of variability to change how the font is rendered. For example, a font may have the "weight" axis, which
controls how bold the font is, and the "width" axis, which controls how wide the font is.
Variable font support required Ren'Py 8 and the harfbuzz shaper to work.
To support variable fonts, Ren'Py has added the :propref:`instance` and :propref:`axis` style properties, and the :tt:`instance` and :tt:`axis` text tags, as well as the
:func:`renpy.variable_font_info` function.
See the :ref:`variable fonts documentation <variable-fonts>` for more information.
Font Hinting
There is a new :propref:`hinting` mode "auto-light", that performs autohinting in the vertical but not horizontal direction.
The new :var:`config.font_hinting` variable makes it possible to enable font hinting on a per-font basis, while the style system can be used to control hinting per-use. For example:
define config.font_hinting["MyFont.tff"] = "bytecode"
enables bytecode hinting for MyFont.ttf.
Text Interpolation Improvements
Interpolations in strings are now treated as Python expressions, rather than simple fields. While not identical, this concept will feel familiar to those that have worked with Python f-strings. This
allows for some logic to be incorporated directly:
default exp = 1000
label start:
e "I am level [exp // 225]!" # Will show "I am level 4!"
When a variable is interpolated into a string, and the interpolation namespace exists, that namespace will be searched for the values to interpolate. For example,
define t = "Not shown."
define interpolate.t = "Shown."
label start:
e "[t]" # Will show "Shown."
Speech Bubble Improvements
The speech bubble feature that was added in Ren'Py 8.1 now has a new way to retain speech bubbles, so that the bubbles pop up one at a time, and remain displayed on the screen until explicitly
cleared, similar to dialogue in motion comics. See the :ref:`speech bubble documentation <retained-bubbles>` for more information.
The new :var:`bubble.properties_callback` variable can be given a function that filter the list of bubble property names based on the image tag that's speaking. This makes it possible to have bubbles
that are specific to some but not all characters.
Several changes work together to make it possible to apply a transform that animates speech bubble show and hide. An example of this is included in the :ref:`bubble-screen` documentation.
Position types and ATL interpolation
ATL interpolations, which are statements such as linear 1. xpos .6 (and have nothing to do with text interpolation), now accept interpolation between positions of different types. This allows the
following, which was previously documented against and didn't work:
transform mixed:
xycenter (520, 300)
easein 3. align (.0, .0)
label muxed:
show a at Transform(pos=(.5, .6))
"..."
show a at Transform(pos=(520, 150))
As part of the implementation of this new feature, there is a new :term:`position` type, called :class:`position`, which enables you to provide both a absolute and a relative component to place or
size a displayable. For example, you can now tell something to be xsize position(-10, .5), and the displayable will make the displayable take half of the horizontal space offered to it, minus 10
pixels.
Developer Tools
There is a new "Skip splashscreen" option in Options section of the launcher preferences. When checked, this will cause games launched to skip the splashscreen label when starting.
A new 'Show Filename and Line' option is available from the shift+D developer menu. When enabled, this will cause the filename and line number of the current statement to be displayed. Clicking on
the filename and line will open the file in the default text editor, at the given line, if possible.
Data Actions
The :ref:`data-actions` are now presented and explained in a more condensed manner. These actions have been reimplemented using a data manager that describes what to do with the data (Set-, Toggle-,
Cycle-, Increment-) and a data accessor that describes the kind of data to change (-Variable, -ScreenVariable, -LocalVariable, -Field, -Dict).
There are two new managers:
The Cycle- actions (CycleVariable, CycleLocalVariable, CycleField...) take a list of values and each time the action is run (i.e each time the button is clicked), the target value is set to be
the next element in the list.
The Increment- actions (IncrementVariable, IncrementDict, IncrementField...) add a certain value (by default, 1) to the target value. These can also be used to decrement the field.
The :class:`LocalVariableValue` bar value and :class:`LocalVariableInputValue` input values have been added, for completeness.
HTTPS/HTTP Fetch
Ren'Py now has better support for :doc:`fetch`, using the new renpy.fetch function. While the Requests library still remains supported on Desktop and Mobile, (it's used internally by Ren'Py), the new
fetch function:
Support GET, POST, and PUT requests for HTTPS and HTTP URLs.
Supports fetching from the web platform, subject to the rules of the web platform.
Will not block the game while downloading.
Can take data as either bytes or objects that be encoded to JSON.
Can return data as bytes, as string, or objects decoded from JSON.
Accessibility
The new :scpref:`group_alt` property available on screen language displayables allows the creator to specify text that is spoken the first time one of a group of related displayables is spoken.
The new :scpref:`extra_alt` property available on screen language displayables allows the creator to specify text that is spoken when the '?' key is pressed, to provide additional information about
the displayable.
Both of these properties are inherited by the children of the displayable, unless they are overridden by a more specific value in the child.
The new :func:`renpy.alt` function can be used to speak text using the self-voicing system.
__future__ in python
Ren'Py now allows creators to pass __future__ compiler directives for Python code run in Ren'Py. This is done using the rpy python xxx statement at the top of the .rpy file(s) on which you want them
to apply, where xxx is the name of the future feature. For example:
rpy python annotations
Translation Improvements
For most dialogue, Ren'Py will now create one third the number of objects to support translations. This helps reduce startup time and reduce memory usage.
In addition, Ren'Py can now defer loading translations until a translation is needed. This can improve startup time when the game is large and many languages are present.
Deferred translation loading is disabled by default. The documentation on :ref:`deferred-translations` explains how to enable it and caveats that apply.
Scene, Show, and Hide Transition
The new scene, show, and hide transitions makes it possible to automatically perform a transition after sequences of scene, show, and hide statements that are not followed by a with statement, or a
window show transition.
This is controlled by the new :var:`_scene_show_hide_transition` variable, and documented at :ref:`scene-show-hide-transition`.
Android
The Android build system has been updated to use recent versions of Gradle and the Android Gradle Plugin. This means that Ren'Py now supports and requires Java 21, the most recent long-term support
version of Java.
A series of changes have been made to Ren'Py to allow games larger than 2GB to be be downloaded to a Android or iOS device. How to do this is documented at :doc:`downloader`. It fundamentally
involves creating two games - a very short one that is downloaded to the device, and a larger game that is downloaded to the device when the short game is run.
The user-visible version on android is now taken from :var:`build.version`, which defaults to :var:`config.version`.
Assets you place in the :file:`rapt/prototype` project will be placed into the built project.
The files produced by the Android build process will include the version number in their name, making it easier to distinguish between builds.
Web
The way Ren'Py goes fullscreen on the web platform has been changed, to improve compatibility with both desktop and mobile web browsers.
Ren'Py now covers the game with a transparent div at start, to help the browser detect a click and allow audio to be played. It will proxy the click to the game and hide the div once this detection
is finished.
The :doc:`fetch` function is now supported on the web platform, allowing web pages to make HTTPS and HTTP requests, subject to the same rules (CORS) as other web pages.
Updater
The :doc:`Ren'Py Updater <updater>` has been rewritten to use a new format, and is implemented entirely in Ren'Py. That makes it compatible with more web hosts, and for the first time it support
https.
The updater will create a signing key when it is first run, and will sign generated updates with that key. When the updater is run, it will check that the updates are run with that key. This means it
is no longer extra work to produce a secure update.
Translations
There is a new Danish translation of the launcher and The Question.
Many other translations have been updated.
Features
The new :var:`config.layer_transforms` variable allows you to supply a list of transforms that will be applied to each layer, or to the combination of all layers in :var:`config.layers`.
The new :class:`Continue` action will load the last save (by default, including autosaves and quick saves). This is intended for use from the main menu to continue the game, especially a linear
visual novel.
The new :propref:`ruby_line_leading` style property controls additional line leading on lines that contain ruby text (furigana). This will generally use less space than the existing
:propref:`line_leading` property.
It is now possible to reset the preferences to their default values by calling :func:`Preference` with "reset" as the argument.
The new :class:`defaultdict` class, which exists in the default Ren'Py namespaces, is similar to Python's collections.defaultdict, while participating in rollback.
The new :class:`MultiRevertable` class makes it possible to define a class that is both a revertable object and a revertable data structure (like list, set, or dict.)
The new :var:`config.pass_controller_events` and newly-documented :var:`config.pass_joystick_events` variables allow the game to access controller and joystick events directly.
The new :var:`renpy.get_screen_variable` and :var:`renpy.set_screen_variable` functions make it possible to access screen variables, especially in :class:`Action` subclasses.
The new :var:`build.time` variable is set to the time the game was built.
The new :var:`build.info` variable lets you store information at build time, and read it back in the distributed game.
When the top left pixels of :ref:`presplash <presplash>` image is transparent, the presplash will be displayed in a window that uses 1-bit transparency.
The new :func:`EditFile` action attempts to open a file and line in a text editor.
The virtual dpi of an SVG file can be set with the new dpi parameter to :func:`Image`.
The new :func:`CopyToClipboard` action copies text to the clipboard.
The new :func:`renpy.confirm` function provides a way of using the confirmation screen from within Python.
The new :func:`renpy.reset_all_contexts` function removes all contexts from the stack, and creates a new context that continues at the next statement. It can be used to fully reset the game upon load
or when an error happens.
The new :func:`renpy.last_say` function returns information about the last say statement to run.
The new :func:`iap.request_review` function allows the game to request that the player review the game on Google Play and the Apple App Store.
The new :var:`gui.history_spacing` variable controls the spacing between history entries in newly created games.
The :tt:`nw` text tag can now take a value, which is a number of seconds to wait before the line containing the tag is automatically dismissed. The common construct "{w=2}{nw}" can now be written as
"{nw=2}".
:class:`Movie` now takes a keep_last_frame parameter. When true, this causes a non-looping movie to display its last frame after the movie ends.
The jump expression statement can now take a local label name of the form ".local_name". Previously, only "global_name" or "global_name.local_name" were allowed.
:ref:`creator-defined-sl` can now copy all properties from other screen language statements.
The new :func:`renpy.invoke_in_main_thread` function can be used by a Python thread to invoke a function in the main Ren'Py thread. (Most Ren'Py functions can only be called from the main thread.)
Launcher Changes
The launcher now supports :doc:`template_projects`. These are indended for use by projects that replace the default GUI. If a template project is selected when creating a new project, Ren'Py will
copy the template project and update the name and translations, but will not make other changes to script files and images.
The launcher has been slightly redesigned to reduce the amount of whitespace, allowing more options to appear on some screens while still providing room for translations.
A :doc:`cli` has been documented, making it possible to build Ren'Py projects from the command line.
Other Changes
Hide and replace transform events that are applied to screens are now always allowed to run to completion, even if the same screen is shown again. This makes it possible to use transform events with
screens that may be shown again immediately, like the say or bubble screens.
Containers (including fixed, hbox, vbox, side, grid, viewport, and vpgrid) now pass some transform events (hover, idle, insensitive, selected_hover, and selected_idle) to their children, meaning that
children of a button can have their own transforms to respond to those events.
:func:`persistent._clear` will re-run default statements that update persistent variables, making it possible to avoid persistent becoming entirely de-initialized.
The pixel transparency test used by :propref:`focus_mask` will now only involve the GPU if inside the bounding box of non-transparent pixels, improving performance in some cases.
Ren'Py now uses the GL2 renderer by default on all platforms, and ignores the config.gl2 variable. This is because of issues with the old GL renderer that are not present in the GL2 renderer. On
ancient hardware, it's still possible to use the GL renderer by pressing shift+G and enabling it directly.
On PC platforms (Windows, Mac, and Linux), when the game window moves, its position is stored. The window's position will be restored when the game is run again, if:
The layout of the player's monitors hasn't changed.
The window is fully contained on the player's monitors.
Otherwise, the window will be centered on the primary monitor.
On controllers (including the Steam Deck), the function of the B button has changed to show and hide the game menu. The previous behavior of the B button, selecting a button's alternate function, has
been moved to X.
The non-default hardware video playback path has been removed from android and ios. This path hadn't been the defaults since 2020, as it supported a subset of the video formats Ren'Py supports.
Ren'Py now enforces that the angles given to the :tpref:`angle` and :tpref:`anchorangle` properties are in the range 0 to 360 degrees, inclusive of 0 but not of 360. Previously, angles outside this
range gave undefined behavior, now the angles will be clamped to this range. A 360 degree change will no longer cause motion, but will instead be treated as a 0 degree change.
When animating :tpref:`angle` and :tpref:`anchorangle` with ATL, if a direction is not supplied, the shortest arc will be used, even if it passes through 0.
Ren'Py will now produce an error when an ATL block is present, but the block is empty. (For example, show eileen happy: with no indented lines following it.)
To make it more useful for making interfaces compatible with right-to-left languages, the :propref:`box_reverse` style property has changed its behavior in two ways:
Space is offered to displayables in the order the displayables are presented in the screen, where previously the space was offered in reverse order when :propref:`box_reverse` was enabled. This
can change the sizes of some displayables.
A hbox that has :propref:`box_wrap` set will wrap from top to bottom, rather than bottom to top. A vbox with :propref:`box_wrap` set will wrap from left to right, rather than right to left.
When a file causes an autoreload, Ren'Py will check the directory containing the file and all parent directories for git lock files. The autoreload will be deferred until the lock files are removed
when the git operation completes.
AV1 movies that contained an previously-unsupported colorspace conversion could cause Ren'Py to crash, and now will play properly.
The websockets package is now included in Ren'Py 8. This can be used to connect to websockets-based APIs from the desktop and mobile (but not web) ports of Ren'Py. As the package depends on Python 3,
it's not included in Ren'Py 7.
To generate a diff of this commit:
cvs rdiff -u -r1.39 -r1.40 pkgsrc/games/py-renpy/Makefile
cvs rdiff -u -r1.8 -r1.9 pkgsrc/games/py-renpy/PLIST \
pkgsrc/games/py-renpy/distinfo
cvs rdiff -u -r1.4 -r1.5 pkgsrc/games/py-renpy/patches/patch-module_setup.py
cvs rdiff -u -r1.1 -r0 \
pkgsrc/games/py-renpy/patches/patch-renpy_audio_renpysound.pyx \
pkgsrc/games/py-renpy/patches/patch-renpy_text_ftfont.pyx
cvs rdiff -u -r0 -r1.1 \
pkgsrc/games/py-renpy/patches/patch-renpy_gl_glenviron__shader.pyx
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: pkgsrc/games/py-renpy/Makefile
diff -u pkgsrc/games/py-renpy/Makefile:1.39 pkgsrc/games/py-renpy/Makefile:1.40
--- pkgsrc/games/py-renpy/Makefile:1.39 Sat Apr 12 06:54:17 2025
+++ pkgsrc/games/py-renpy/Makefile Sun May 11 14:08:33 2025
@@ -1,8 +1,7 @@
-# $NetBSD: Makefile,v 1.39 2025/04/12 06:54:17 wiz Exp $
+# $NetBSD: Makefile,v 1.40 2025/05/11 14:08:33 ryoon Exp $
-DISTNAME= renpy-8.1.3-source
+DISTNAME= renpy-8.3.7-source
PKGNAME= ${PYPKGPREFIX}-${DISTNAME:S/-source//}
-PKGREVISION= 5
CATEGORIES= games
MASTER_SITES= https://www.renpy.org/dl/${PKGVERSION_NOREV}/
EXTRACT_SUFX= .tar.bz2
@@ -12,17 +11,22 @@ HOMEPAGE= https://www.renpy.org/
COMMENT= Visual Novel Engine written in Python
LICENSE= mit
-PYTHON_VERSIONS_INCOMPATIBLE= 27 312 313
+PYTHON_VERSIONS_INCOMPATIBLE= 27
USE_LANGUAGES+= gnu99
-DEPENDS+= ${PYPKGPREFIX}-future-[0-9]*:../../devel/py-future
+DEPENDS+= ${PYPKGPREFIX}-future>=1.0.0:../../devel/py-future
DEPENDS+= ${PYPKGPREFIX}-six-[0-9]*:../../lang/py-six
DEPENDS+= ${PYPKGPREFIX}-pefile-[0-9]*:../../sysutils/py-pefile
DEPENDS+= ${PYPKGPREFIX}-requests-[0-9]*:../../devel/py-requests
DEPENDS+= ${PYPKGPREFIX}-ecdsa-[0-9]*:../../security/py-ecdsa
DEPENDS+= ${PYPKGPREFIX}-rsa-[0-9]*:../../security/py-rsa
+.include "../../lang/python/pyversion.mk"
+.if ${PYTHON_VERSION} > 312
+DEPENDS+= ${PYPKGPREFIX}-legacy-cgi-[0-9]*:../../www/py-legacy-cgi
+.endif
+
USE_TOOLS+= pax
PYSETUPSUBDIR= module
EGG_NAME= Ren_Py-${PKGVERSION_NOREV}.23091805
Index: pkgsrc/games/py-renpy/PLIST
diff -u pkgsrc/games/py-renpy/PLIST:1.8 pkgsrc/games/py-renpy/PLIST:1.9
--- pkgsrc/games/py-renpy/PLIST:1.8 Mon Apr 29 14:37:31 2024
+++ pkgsrc/games/py-renpy/PLIST Sun May 11 14:08:33 2025
@@ -1,13 +1,14 @@
-@comment $NetBSD: PLIST,v 1.8 2024/04/29 14:37:31 nia Exp $
+@comment $NetBSD: PLIST,v 1.9 2025/05/11 14:08:33 ryoon Exp $
bin/renpy
-${PYSITELIB}/${EGG_INFODIR}/PKG-INFO
-${PYSITELIB}/${EGG_INFODIR}/SOURCES.txt
-${PYSITELIB}/${EGG_INFODIR}/dependency_links.txt
-${PYSITELIB}/${EGG_INFODIR}/not-zip-safe
-${PYSITELIB}/${EGG_INFODIR}/top_level.txt
+${PYSITELIB}/Ren_Py-${PKGVERSION}.25031702-py${PYVERSSUFFIX}.egg-info/PKG-INFO
+${PYSITELIB}/Ren_Py-${PKGVERSION}.25031702-py${PYVERSSUFFIX}.egg-info/SOURCES.txt
+${PYSITELIB}/Ren_Py-${PKGVERSION}.25031702-py${PYVERSSUFFIX}.egg-info/dependency_links.txt
+${PYSITELIB}/Ren_Py-${PKGVERSION}.25031702-py${PYVERSSUFFIX}.egg-info/not-zip-safe
+${PYSITELIB}/Ren_Py-${PKGVERSION}.25031702-py${PYVERSSUFFIX}.egg-info/top_level.txt
${PYSITELIB}/_renpy.so
${PYSITELIB}/_renpybidi.so
${PYSITELIB}/_renpytfd.so
+${PYSITELIB}/renpy/audio/filter.so
${PYSITELIB}/renpy/audio/renpysound.so
${PYSITELIB}/renpy/display/accelerator.so
${PYSITELIB}/renpy/display/matrix.so
@@ -43,6 +44,7 @@ ${PYSITELIB}/renpy/styledata/style_selec
${PYSITELIB}/renpy/styledata/styleclass.so
${PYSITELIB}/renpy/styledata/stylesets.so
${PYSITELIB}/renpy/text/ftfont.so
+${PYSITELIB}/renpy/text/hbfont.so
${PYSITELIB}/renpy/text/textsupport.so
${PYSITELIB}/renpy/text/texwrap.so
${PYSITELIB}/renpy/uguu/gl.so
@@ -226,6 +228,7 @@ share/renpy/doc/android-packaging.html
share/renpy/doc/android.html
share/renpy/doc/atl.html
share/renpy/doc/audio.html
+share/renpy/doc/audio_filters.html
share/renpy/doc/bubble.html
share/renpy/doc/build.html
share/renpy/doc/cdd.html
@@ -234,6 +237,7 @@ share/renpy/doc/changelog.html
share/renpy/doc/changelog6.html
share/renpy/doc/character_callbacks.html
share/renpy/doc/chromeos.html
+share/renpy/doc/cli.html
share/renpy/doc/color_class.html
share/renpy/doc/conditional.html
share/renpy/doc/config.html
@@ -246,9 +250,11 @@ share/renpy/doc/display_problems.html
share/renpy/doc/displayables.html
share/renpy/doc/displaying_images.html
share/renpy/doc/distributor.html
+share/renpy/doc/downloader.html
share/renpy/doc/drag_drop.html
share/renpy/doc/editor.html
share/renpy/doc/environment_variables.html
+share/renpy/doc/fetch.html
share/renpy/doc/file_python.html
share/renpy/doc/genindex.html
share/renpy/doc/gesture.html
@@ -277,6 +283,7 @@ share/renpy/doc/modes.html
share/renpy/doc/mouse.html
share/renpy/doc/movie.html
share/renpy/doc/multiple.html
+share/renpy/doc/namespaces.html
share/renpy/doc/nvl_mode.html
share/renpy/doc/objects.inv
share/renpy/doc/other.html
@@ -297,10 +304,12 @@ share/renpy/doc/screen_optimization.html
share/renpy/doc/screen_python.html
share/renpy/doc/screen_special.html
share/renpy/doc/screens.html
+share/renpy/doc/screenshot.html
share/renpy/doc/search.html
share/renpy/doc/searchindex.js
share/renpy/doc/security.html
share/renpy/doc/self_voicing.html
+share/renpy/doc/shader_parts.html
share/renpy/doc/side_image.html
share/renpy/doc/skins.html
share/renpy/doc/splashscreen_presplash.html
@@ -313,10 +322,13 @@ share/renpy/doc/std-var-index.html
share/renpy/doc/store_variables.html
share/renpy/doc/style.html
share/renpy/doc/style_properties.html
+share/renpy/doc/template_projects.html
share/renpy/doc/text.html
+share/renpy/doc/textshaders.html
share/renpy/doc/thequestion.html
share/renpy/doc/thequestion_nvl.html
share/renpy/doc/trans_trans_python.html
+share/renpy/doc/transform_properties.html
share/renpy/doc/transforms.html
share/renpy/doc/transitions.html
share/renpy/doc/translating_renpy.html
@@ -351,7 +363,7 @@ share/renpy/launcher/game/androidstrings
share/renpy/launcher/game/androidstrings.rpyc
share/renpy/launcher/game/archiver.rpy
share/renpy/launcher/game/archiver.rpyc
-share/renpy/launcher/game/cache/bytecode-${PYTHON_VERSION}.rpyb
+share/renpy/launcher/game/cache/bytecode-313.rpyb
share/renpy/launcher/game/cache/py3analysis.rpyb
share/renpy/launcher/game/cache/screens.rpyb
share/renpy/launcher/game/change_icon.py
@@ -387,6 +399,8 @@ share/renpy/launcher/game/images/backgro
share/renpy/launcher/game/images/logo.png
share/renpy/launcher/game/images/logo32.png
share/renpy/launcher/game/images/pattern.png
+share/renpy/launcher/game/images/window-icon-mac.png
+share/renpy/launcher/game/images/window-icon.png
share/renpy/launcher/game/images/window.png
share/renpy/launcher/game/install.rpy
share/renpy/launcher/game/install.rpyc
@@ -445,6 +459,23 @@ share/renpy/launcher/game/tl/arabic/scre
share/renpy/launcher/game/tl/arabic/script.rpym
share/renpy/launcher/game/tl/arabic/style.rpy
share/renpy/launcher/game/tl/arabic/style.rpyc
+share/renpy/launcher/game/tl/danish/common.rpy
+share/renpy/launcher/game/tl/danish/common.rpyc
+share/renpy/launcher/game/tl/danish/developer.rpy
+share/renpy/launcher/game/tl/danish/developer.rpyc
+share/renpy/launcher/game/tl/danish/error.rpy
+share/renpy/launcher/game/tl/danish/error.rpyc
+share/renpy/launcher/game/tl/danish/gui.rpy
+share/renpy/launcher/game/tl/danish/gui.rpyc
+share/renpy/launcher/game/tl/danish/launcher.rpy
+share/renpy/launcher/game/tl/danish/launcher.rpyc
+share/renpy/launcher/game/tl/danish/obsolete.rpy
+share/renpy/launcher/game/tl/danish/obsolete.rpyc
+share/renpy/launcher/game/tl/danish/options.rpy
+share/renpy/launcher/game/tl/danish/options.rpyc
+share/renpy/launcher/game/tl/danish/screens.rpy
+share/renpy/launcher/game/tl/danish/screens.rpyc
+share/renpy/launcher/game/tl/danish/script.rpym
share/renpy/launcher/game/tl/finnish/common.rpy
share/renpy/launcher/game/tl/finnish/common.rpyc
share/renpy/launcher/game/tl/finnish/developer.rpy
@@ -830,12 +861,10 @@ share/renpy/renpy/atl.py
share/renpy/renpy/atl.pyc
share/renpy/renpy/audio/__init__.py
share/renpy/renpy/audio/__init__.pyc
-share/renpy/renpy/audio/androidhw.py
-share/renpy/renpy/audio/androidhw.pyc
share/renpy/renpy/audio/audio.py
share/renpy/renpy/audio/audio.pyc
-share/renpy/renpy/audio/ioshw.py
-share/renpy/renpy/audio/ioshw.pyc
+share/renpy/renpy/audio/filter.pxd
+share/renpy/renpy/audio/filter.pyx
share/renpy/renpy/audio/music.py
share/renpy/renpy/audio/music.pyc
share/renpy/renpy/audio/renpysound.pyx
@@ -946,6 +975,8 @@ share/renpy/renpy/common/00speechbubble.
share/renpy/renpy/common/00speechbubble.rpyc
share/renpy/renpy/common/00splines.rpy
share/renpy/renpy/common/00splines.rpyc
+share/renpy/renpy/common/00sshtransition.rpyc
+share/renpy/renpy/common/00sshtransition_ren.py
share/renpy/renpy/common/00start.rpy
share/renpy/renpy/common/00start.rpyc
share/renpy/renpy/common/00steam.rpy
@@ -956,10 +987,14 @@ share/renpy/renpy/common/00stylepreferen
share/renpy/renpy/common/00stylepreferences.rpyc
share/renpy/renpy/common/00sync.rpy
share/renpy/renpy/common/00sync.rpyc
+share/renpy/renpy/common/00textshader.rpyc
+share/renpy/renpy/common/00textshader_ren.py
share/renpy/renpy/common/00themes.rpy
share/renpy/renpy/common/00themes.rpyc
share/renpy/renpy/common/00touchkeyboard.rpy
share/renpy/renpy/common/00touchkeyboard.rpyc
+share/renpy/renpy/common/00translation.rpy
+share/renpy/renpy/common/00translation.rpyc
share/renpy/renpy/common/00updater.rpy
share/renpy/renpy/common/00updater.rpyc
share/renpy/renpy/common/00voice.rpy
@@ -967,9 +1002,12 @@ share/renpy/renpy/common/00voice.rpyc
share/renpy/renpy/common/DejaVuSans-Bold.ttf
share/renpy/renpy/common/DejaVuSans.ttf
share/renpy/renpy/common/DejaVuSans.txt
+share/renpy/renpy/common/TwemojiCOLRv0.ttf
+share/renpy/renpy/common/TwemojiCOLRv0.txt
share/renpy/renpy/common/_OpenDyslexic3-Regular.ttf
share/renpy/renpy/common/_OpenDyslexic3-Regular.txt
share/renpy/renpy/common/_audio.js
+share/renpy/renpy/common/_audio_filter.js
share/renpy/renpy/common/_compat/gamemenu.rpym
share/renpy/renpy/common/_compat/library.rpym
share/renpy/renpy/common/_compat/mainmenu.rpym
@@ -1216,6 +1254,8 @@ share/renpy/renpy/display/controller.py
share/renpy/renpy/display/controller.pyc
share/renpy/renpy/display/core.py
share/renpy/renpy/display/core.pyc
+share/renpy/renpy/display/displayable.py
+share/renpy/renpy/display/displayable.pyc
share/renpy/renpy/display/dragdrop.py
share/renpy/renpy/display/dragdrop.pyc
share/renpy/renpy/display/emulator.py
@@ -1264,6 +1304,8 @@ share/renpy/renpy/display/render.pxd
share/renpy/renpy/display/render.pyx
share/renpy/renpy/display/scale.py
share/renpy/renpy/display/scale.pyc
+share/renpy/renpy/display/scenelists.py
+share/renpy/renpy/display/scenelists.pyc
share/renpy/renpy/display/screen.py
share/renpy/renpy/display/screen.pyc
share/renpy/renpy/display/swdraw.py
@@ -1289,8 +1331,44 @@ share/renpy/renpy/error.py
share/renpy/renpy/error.pyc
share/renpy/renpy/execution.py
share/renpy/renpy/execution.pyc
-share/renpy/renpy/exports.py
-share/renpy/renpy/exports.pyc
+share/renpy/renpy/exports/__init__.py
+share/renpy/renpy/exports/__init__.pyc
+share/renpy/renpy/exports/actionexports.py
+share/renpy/renpy/exports/actionexports.pyc
+share/renpy/renpy/exports/commonexports.py
+share/renpy/renpy/exports/commonexports.pyc
+share/renpy/renpy/exports/contextexports.py
+share/renpy/renpy/exports/contextexports.pyc
+share/renpy/renpy/exports/debugexports.py
+share/renpy/renpy/exports/debugexports.pyc
+share/renpy/renpy/exports/displayexports.py
+share/renpy/renpy/exports/displayexports.pyc
+share/renpy/renpy/exports/fetchexports.py
+share/renpy/renpy/exports/fetchexports.pyc
+share/renpy/renpy/exports/inputexports.py
+share/renpy/renpy/exports/inputexports.pyc
+share/renpy/renpy/exports/loaderexports.py
+share/renpy/renpy/exports/loaderexports.pyc
+share/renpy/renpy/exports/mediaexports.py
+share/renpy/renpy/exports/mediaexports.pyc
+share/renpy/renpy/exports/menuexports.py
+share/renpy/renpy/exports/menuexports.pyc
+share/renpy/renpy/exports/persistentexports.py
+share/renpy/renpy/exports/persistentexports.pyc
+share/renpy/renpy/exports/platformexports.py
+share/renpy/renpy/exports/platformexports.pyc
+share/renpy/renpy/exports/predictexports.py
+share/renpy/renpy/exports/predictexports.pyc
+share/renpy/renpy/exports/restartexports.py
+share/renpy/renpy/exports/restartexports.pyc
+share/renpy/renpy/exports/rollbackexports.py
+share/renpy/renpy/exports/rollbackexports.pyc
+share/renpy/renpy/exports/sayexports.py
+share/renpy/renpy/exports/sayexports.pyc
+share/renpy/renpy/exports/scriptexports.py
+share/renpy/renpy/exports/scriptexports.pyc
+share/renpy/renpy/exports/statementexports.py
+share/renpy/renpy/exports/statementexports.pyc
share/renpy/renpy/game.py
share/renpy/renpy/game.pyc
share/renpy/renpy/gl/__init__.py
@@ -1351,6 +1429,8 @@ share/renpy/renpy/minstore.py
share/renpy/renpy/minstore.pyc
share/renpy/renpy/object.py
share/renpy/renpy/object.pyc
+share/renpy/renpy/parameter.py
+share/renpy/renpy/parameter.pyc
share/renpy/renpy/parser.py
share/renpy/renpy/parser.pyc
share/renpy/renpy/performance.py
@@ -1419,12 +1499,17 @@ share/renpy/renpy/test/testparser.py
share/renpy/renpy/test/testparser.pyc
share/renpy/renpy/text/__init__.py
share/renpy/renpy/text/__init__.pyc
+share/renpy/renpy/text/emoji_trie.py
+share/renpy/renpy/text/emoji_trie.pyc
share/renpy/renpy/text/extras.py
share/renpy/renpy/text/extras.pyc
share/renpy/renpy/text/font.py
share/renpy/renpy/text/font.pyc
share/renpy/renpy/text/ftfont.pyx
+share/renpy/renpy/text/hbfont.pyx
share/renpy/renpy/text/linebreak.pxi
+share/renpy/renpy/text/shader.py
+share/renpy/renpy/text/shader.pyc
share/renpy/renpy/text/text.py
share/renpy/renpy/text/text.pyc
share/renpy/renpy/text/textsupport.pxd
@@ -1449,6 +1534,11 @@ share/renpy/renpy/uguu/gl.pyx
share/renpy/renpy/uguu/uguu.pyx
share/renpy/renpy/ui.py
share/renpy/renpy/ui.pyc
+share/renpy/renpy/update/__init__.py
+share/renpy/renpy/update/common.py
+share/renpy/renpy/update/download.py
+share/renpy/renpy/update/generate.py
+share/renpy/renpy/update/update.py
share/renpy/renpy/util.py
share/renpy/renpy/util.pyc
share/renpy/renpy/vc_version.py
@@ -1463,9 +1553,7 @@ share/renpy/sdk-fonts/SourceHanSansLite.
share/renpy/the_question/android-icon_background.png
share/renpy/the_question/android-icon_foreground.png
share/renpy/the_question/android.json
-share/renpy/the_question/android.keystore
-share/renpy/the_question/bundle.keystore
-share/renpy/the_question/game/cache/bytecode-${PYTHON_VERSION}.rpyb
+share/renpy/the_question/game/cache/bytecode-313.rpyb
share/renpy/the_question/game/cache/py3analysis.rpyb
share/renpy/the_question/game/cache/screens.rpyb
share/renpy/the_question/game/gui.rpy
@@ -1540,6 +1628,22 @@ share/renpy/the_question/game/script.rpy
share/renpy/the_question/game/script.rpyc
share/renpy/the_question/game/tl/None/common.rpym
share/renpy/the_question/game/tl/None/common.rpymc
+share/renpy/the_question/game/tl/czech/common.rpy
+share/renpy/the_question/game/tl/czech/common.rpyc
+share/renpy/the_question/game/tl/czech/options.rpy
+share/renpy/the_question/game/tl/czech/options.rpyc
+share/renpy/the_question/game/tl/czech/screens.rpy
+share/renpy/the_question/game/tl/czech/screens.rpyc
+share/renpy/the_question/game/tl/czech/script.rpy
+share/renpy/the_question/game/tl/czech/script.rpyc
+share/renpy/the_question/game/tl/danish/common.rpy
+share/renpy/the_question/game/tl/danish/common.rpyc
+share/renpy/the_question/game/tl/danish/options.rpy
+share/renpy/the_question/game/tl/danish/options.rpyc
+share/renpy/the_question/game/tl/danish/screens.rpy
+share/renpy/the_question/game/tl/danish/screens.rpyc
+share/renpy/the_question/game/tl/danish/script.rpy
+share/renpy/the_question/game/tl/danish/script.rpyc
share/renpy/the_question/game/tl/french/common.rpy
share/renpy/the_question/game/tl/french/common.rpyc
share/renpy/the_question/game/tl/french/options.rpy
@@ -1548,6 +1652,14 @@ share/renpy/the_question/game/tl/french/
share/renpy/the_question/game/tl/french/screens.rpyc
share/renpy/the_question/game/tl/french/script.rpy
share/renpy/the_question/game/tl/french/script.rpyc
+share/renpy/the_question/game/tl/italian/common.rpy
+share/renpy/the_question/game/tl/italian/common.rpyc
+share/renpy/the_question/game/tl/italian/options.rpy
+share/renpy/the_question/game/tl/italian/options.rpyc
+share/renpy/the_question/game/tl/italian/screens.rpy
+share/renpy/the_question/game/tl/italian/screens.rpyc
+share/renpy/the_question/game/tl/italian/script.rpy
+share/renpy/the_question/game/tl/italian/script.rpyc
share/renpy/the_question/game/tl/japanese/common.rpy
share/renpy/the_question/game/tl/japanese/common.rpyc
share/renpy/the_question/game/tl/japanese/options.rpy
@@ -1621,7 +1733,7 @@ share/renpy/tutorial/game/01director_sup
share/renpy/tutorial/game/01director_support.rpyc
share/renpy/tutorial/game/01example.rpy
share/renpy/tutorial/game/01example.rpyc
-share/renpy/tutorial/game/cache/bytecode-${PYTHON_VERSION}.rpyb
+share/renpy/tutorial/game/cache/bytecode-313.rpyb
share/renpy/tutorial/game/cache/py3analysis.rpyb
share/renpy/tutorial/game/cache/screens.rpyb
share/renpy/tutorial/game/examples.rpy
Index: pkgsrc/games/py-renpy/distinfo
diff -u pkgsrc/games/py-renpy/distinfo:1.8 pkgsrc/games/py-renpy/distinfo:1.9
--- pkgsrc/games/py-renpy/distinfo:1.8 Thu Nov 23 15:41:21 2023
+++ pkgsrc/games/py-renpy/distinfo Sun May 11 14:08:33 2025
@@ -1,13 +1,12 @@
-$NetBSD: distinfo,v 1.8 2023/11/23 15:41:21 ryoon Exp $
+$NetBSD: distinfo,v 1.9 2025/05/11 14:08:33 ryoon Exp $
-BLAKE2s (renpy-8.1.3-source.tar.bz2) = b9155b726cdd4ddb9fd739f2829542ddc7cf2b5a2f71c9297936f2e358ced545
-SHA512 (renpy-8.1.3-source.tar.bz2) = 22304cf8e7328c50ff897761ec0a504e8618d53484491f4196ad93015656dd08c2197c11adea83069682912a5b8d05d3223e3ad34fa68881abdad5f73e51884b
-Size (renpy-8.1.3-source.tar.bz2) = 69220231 bytes
+BLAKE2s (renpy-8.3.7-source.tar.bz2) = 109b06aa2cee51cf0aaf2b2b380e2bd73552c8c4c13a3f34c2c349a0b29ce665
+SHA512 (renpy-8.3.7-source.tar.bz2) = 204005e3caaf1e75f6b2d5a509a87980e8c9fc3b7b2bafba36535c2faaa6b527ee97ed09d4731cdd2bf1e084a013bfdff16aeccdaf11d8da8c6df723aa779bec
+Size (renpy-8.3.7-source.tar.bz2) = 71575076 bytes
SHA1 (patch-launcher_game_gui7_code.py) = da58df02611db214e8aebf53f6929fad5cbc4207
SHA1 (patch-launcher_game_translations.rpy) = 4ac93764ddfed2eccc64a10f127cace2117d0208
SHA1 (patch-module_renpybidicore.c) = 1aceeb4388c8386721e6ee9422952167c5a35add
-SHA1 (patch-module_setup.py) = 51112a4a6829b002c261068ae662e7eee7736809
+SHA1 (patch-module_setup.py) = 86bd582d20ee6d96a596e4efdc124cd87ea088c3
SHA1 (patch-module_tinyfiledialogs_tinyfiledialogs.c) = c1e5f0507c5145028337e608775937309667c688
SHA1 (patch-renpy_____init____.py) = 52aa676ac6eb82d8367151422415557ec4ba08f8
-SHA1 (patch-renpy_audio_renpysound.pyx) = 37ced3a36097b01c3e84a1ab3e7a04b93f414c7a
-SHA1 (patch-renpy_text_ftfont.pyx) = dc7634ae6322136c55800e67f13405c8aaa882da
+SHA1 (patch-renpy_gl_glenviron__shader.pyx) = 40374d2ff3c5f941d968295a4c7b9938aa456d1a
Index: pkgsrc/games/py-renpy/patches/patch-module_setup.py
diff -u pkgsrc/games/py-renpy/patches/patch-module_setup.py:1.4 pkgsrc/games/py-renpy/patches/patch-module_setup.py:1.5
--- pkgsrc/games/py-renpy/patches/patch-module_setup.py:1.4 Thu Nov 23 15:41:21 2023
+++ pkgsrc/games/py-renpy/patches/patch-module_setup.py Sun May 11 14:08:33 2025
@@ -1,11 +1,11 @@
-$NetBSD: patch-module_setup.py,v 1.4 2023/11/23 15:41:21 ryoon Exp $
+$NetBSD: patch-module_setup.py,v 1.5 2025/05/11 14:08:33 ryoon Exp $
* png from pkgsrc is libpng16.so
---- module/setup.py.orig 2022-09-08 03:49:02.959533000 +0000
+--- module/setup.py.orig 2025-02-23 12:22:19.115359800 +0000
+++ module/setup.py
-@@ -88,7 +88,7 @@ include("GL/glew.h")
- include("pygame_sdl2/pygame_sdl2.h", directory="python{}.{}".format(sys.version_info.major, sys.version_info.minor))
+@@ -89,7 +89,7 @@ include("pygame_sdl2/pygame_sdl2.h", dir
+ include("hb.h", directory="harfbuzz")
library("SDL2")
-library("png")
Added files:
Index: pkgsrc/games/py-renpy/patches/patch-renpy_gl_glenviron__shader.pyx
diff -u /dev/null pkgsrc/games/py-renpy/patches/patch-renpy_gl_glenviron__shader.pyx:1.1
--- /dev/null Sun May 11 14:08:34 2025
+++ pkgsrc/games/py-renpy/patches/patch-renpy_gl_glenviron__shader.pyx Sun May 11 14:08:33 2025
@@ -0,0 +1,15 @@
+$NetBSD: patch-renpy_gl_glenviron__shader.pyx,v 1.1 2025/05/11 14:08:33 ryoon Exp $
+
+--- renpy/gl/glenviron_shader.pyx.orig 2025-03-17 02:58:30.292934400 +0000
++++ renpy/gl/glenviron_shader.pyx
+@@ -278,7 +278,9 @@ def check_status(shader, handle, type):
+ else:
+ glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &log_length)
+
+- log = ' ' * log_length
++ pylog = ' ' * log_length
++ pyulog = pylog.encode('UTF-8')
++ cdef char*log = pyulog
+
+ if shader:
+ glGetShaderInfoLog(handle, log_length, &log_length, <char *> log)
Home |
Main Index |
Thread Index |
Old Index