Also add explanation in `EditorContextMenuPlugin`'s doc for fixing path information passing
(Accept PR #106820 suggestion by: Tomasz Chabora <kobewi4e@gmail.com>)
to reflect that it returns physics steps that have been processed,
not frames rendered.
fixes#90539
Add reference to physics_frame signal.
Add reference to Engine.get_process_frames
Update doc/classes/SceneTree.xml
Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
As there are multiple menu containing creating new files, this commit add the popup menu item from the plugin to all those menu to keep consistency.
The fixing uses empty array to indicate different types of context menu.
Added to these menu:
* Right-click on empty space on the tree (`_tree_empty_click`).
* Right-click on empty space on the file panel (`_file_list_empty_clicked`)
Also add explanation in `EditorContextMenuPlugin::CONTEXT_SLOT_FILESYSTEM_CREATE`'s doc for previous fixing
(Accept PR #106811 code suggestion by: Tomasz Chabora <kobewi4e@gmail.com>)
This in the scope of a duplication triggered via any type in the `Variant` realm. that is, the following: `Variant` itself, `Array` and `Dictionary`. That includes invoking `duplicate()` from scripts.
A `duplicate_deep(deep_subresources_mode)` method is added to `Variant`, `Array` and `Dictionary` (for compatibility reasons, simply adding an extra parameter was not possible). The default value for it is `RESOURCE_DEEP_DUPLICATE_NONE`, which is like calling `duplicate(true)`.
Remarks:
- The results of copying resources via those `Variant` types are exactly the same as if the copy were initiated from the `Resource` type at C++.
- In order to keep some separation between `Variant` and the higher-level animal which is `Resource`, `Variant` still contains the original code for that, so it's self-sufficient unless there's a `Resource` involved. Once the deep copy finds a `Resource` that has to be copied according to the duplication parameters, the algorithm invokes the `Resource` duplication machinery. When the stack is unwind back to a nesting level `Variant` can handle, `Variant` duplication logic keeps functioning.
While that is good from a responsibility separation standpoint, that would have a caveat: `Variant` would not be aware of the mapping between original and duplicate subresources and so wouldn't be able to keep preventing multiple duplicates.
To avoid that, this commit also introduces a wormwhole, a sharing mechanism by which `Variant` and `Resource` can collaborate in managing the lifetime of the original-to-duplicates map. The user-visible benefit is that the overduplicate prevention works as broadly as the whole `Variant` entity being copied, including all nesting levels, regardless how disconnected the data members containing resources may be across al the nesting levels. In other words, despite the aforementioned division of duties between `Variant` and `Resource` duplication logic, the duplicates map is shared among them. It's created when first finding a `Resource` and, however how deep the copy was working at that point, the map kept alive unitl the stack is unwind to the root user call, until the first step of the recursion.
Thanks to that common map of duplicates, this commit is able to fix the issue that `Resource::duplicate_for_local_scene()` used to ignore overridden duplicate logic.
Thanks to a refactor, `Resource::duplicate_for_local_scene()` and `Resource::duplicate()` are now both users of the same, parametrized, implementation.
`Resource::duplicate()` now honors deepness in a more consistent and predictable fashion. `Resource::duplicate_deep()` is added (instead of just adding a parameter to the former, for compatibility needs).
The behavior after this change is as follows:
- Deep (`deep=true`, formerly `subresources=true`):
- Previously, only resources found as direct property values of the one to copy would be, recursively, duplicated.
- Now, in addition, arrays and dictionaries are walked so the copy is truly deep, and only local subresources found across are copied.
- Previously, subresources would be duplicated as many times as being referenced throughout the main resource.
- Now, each subresource is only duplicated once and from that point, a referenced to that single copy is used. That's the enhanced behavior that `duplicate_for_local_scene()` already featured.
- The behavior with respect to packed arrays is still duplication.
- Formerly, arrays and dictionaries were recursive duplicated, with resources ignored.
- Now, arrays and dictionaries are recursive duplicated, with resources duplicated.
- When doing it through `duplicate_deep()`, there's a` deep_subresources_mode` parameter, with various possibilites to control if no resources are duplicated (so arrays, etc. are, but keeping referencing the originals), if only the internal ones are (resources with no non-local path, the default), or if all of them are. The default is to copy every subresource, just like `duplicate(true)`.
- Not deep (`deep=false`, formerly `subresources=false`): <a name="resource-shallow"></a>
- Previously, the first level of resources found as direct property values would be duplicated unconditionally. Packed arrays, arrays and dictionaries were non-recursively duplicated.
- Now, no subresource found at any level in any form will be duplicated, but the original reference kept instead. Packed arrays, arrays and dictionaries are referenced, not duplicated at all.
- Now, resources found as values of always-duplicate properties are duplicated, recursively or not matching what was requested for the root call.
This commit also changes what's the virtual method to override to customize the duplication (now it's the protected `_duplicate()` instead of the public `duplicate()`).
Add intensity slider to all color modes. Replace raw mode by linear mode, which uses linear color space.
When color is overbright, automatically switch hex text to script text. Allow executing expression in script text field to set color. Add the "script" icon to the default theme.
- Implement `set_stream_position` and `get_stream_length`.
- Don't show blank frame when stopping the video (smooth loops).
- Fix audio for videos with up to 8 channels.
- Improve internal audio handling.
Add new shader built in Z_CLIP_SCALE to easily adjust clipping distance to avoid clipping walls etc.
Add fov_override to StandardMaterial3D to easily have a custom FOV for FPS objects
Add IN_SHADOW_PASS built-in to shaders for tweaking materials without impacting shadow maps
This was added together with `ppc64le` in #54490, but seemingly only for the
purpose of getting it to compile on a Linux distro that aims at maximizing
support for all CPU architectures.
I don't think anyone has ever _run_ Godot on a `ppc32` system (do those even
support OpenGL ES 3.0?) and so I don't think we should aim to support it.
Debian dropped support for its PowerPC (`ppc32`) arch in Debian 9, released
in 2017.
- Describe the class's interactivity in more detail.
- Clarify behavior of `apply()`.
- Mention that expressions can be evaluated.
- Mention caveat with `update_on_text_changed` regarding expressions.
Thaddeus Crews
Hugo Locurcio
kobewi
bruvzg
Anish Mishra
KOGA Mitsuhiro
Michael Alexsander
LuoZhihao
Yobbolita
Haoyu Qiu
Mikael Hermansson
syzygy
Max Hilbrunner
tomsterBG
Ozelot Vanilla
Silc Lizard (Tokage) Renew
Aioshiro
Capry
daniel080400
Fredia Huya-Kouadio
Danil Alexeev
KaiN
2750558108
Rindbee
Lorenzo Zimmmerer
Fabio Alessandrelli
Pedro J. Estébanez
lawnjelly
PiCode
Aaron Franke
Bernat Arlandis
Logan Detrick
Raymond DiDonato
clayjohn
Rémi Verschelde
Ricardo Sanchez-Saez
DeeJayLSP
Adam Scott
Elzewyr
Omar Qurashi
chocola-mint
Rémi Verschelde
dugramen
GlitchedCode
Danni
RedMser
landervr
LiveTrower