Notable potentially breaking changes:
- PROPERTY_USAGE_NOEDITOR is now PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_NETWORK, without PROPERTY_USAGE_INTERNAL
- Some properties were renamed, and sometimes even shadowed by new ones
- New getter methods (some virtual) were added
Using `misc/scripts/fix_headers.py` on all Godot files.
Some missing header guards were added, and the header inclusion order
was fixed in the Bullet module.
Ignore all script constants in the global section of the breakpoint stack.
Check property size before send to avoid too large of data be sent.
Fix crash while clear the remote objects from the debugger.
When compiling with GCC it is now possible for an opcode followed by
itself to never leave the scope it is currently in. This leads to a
situation where the dtor of a scope local variable isn't called which in
turn can lead to a memory leak.
By moving the goto outside of the scope of each opcode we guarantee that
all dtors have been called before the next opcode gets dispatched.
this fixes#12401
- Make ScriptCreateDialog disable the built-in script checked button if the language does not support it.
- ScriptLanguage's get_template and make_template now receive the script path as class name if the the script language does not have named classes.
On compulers that define __GNUC__ use computed goto to directly dispatch
the next instruction rather than going through another switch statement.
This saves a jump and some comparisons.
In tight loops this is is roughly 10% faster than the switch() method.
This implement branch prediction macros likely() and unlikely() like in
Linux. When using these macros please ensure that when you use them the
condition in the branch really is very, very likely or unlikely. Think
90+% of the time. Primarily useful for error checking. (And I implement
these macros for all our error checking macros now)
See this article for more information:
https://kernelnewbies.org/FAQ/LikelyUnlikely
There are more places where these macros may make sense in renderer and
physics engine. Placing them will come in another commit down the line.
We now allow booleanization of all types. This means that empty versions
of all types now evaluate to false. So a Vector2(0,0), Dictionary(),
etc.
This allows you to write GDScript like:
if not Dictionary():
print("Empty dict")
Booleanization can now also no longer fail. There is no more valid flag,
this changes Variant and GDNative API.
As a preparation for other performance enhancements to GDScript:call()
start by removing more of the GDScript runtime checks on release.
This code has been tested with 2d/platformer, 3d/platformer,
3d/materials_test, and goltorus. No regressions were found.
In an effort to make GDScript a little faster replace the double
switch() with a computed goto on compilers that set __GNUC__. For
compilers that don't support computed goto it will fall back to regular
switch/case statements.
In addition disable using boolean values in a mathematical context. Now
boolean values can only be compared with other booleans. Booleans will
also no longer be coerced to integers.
This PR replaces #11308 and fixes#11291
- Makes vararg methods automatically use PROPERTY_USAGE_NIL_IS_VARIANT on return types
- Completely removes the ":type" suffix for method names. Virtual methods must use the MethodInfo constructors that takes Variant::Type or PropertyHint as the first parameter for the return type (with CLASS_INFO as a helper to get the PropertyInfo). Parameters must use PROPERTY_HINT_RESOURCE_TYPE and hint string.
- PROPERTY_USAGE_NIL_IS_VARIANT is no longer needed for parameters, because parameters cannot be void.
- Adds missing PROPERTY_USAGE_NIL_IS_VARIANT to virtual and built-in methods that return Variant.
Currently we rely on some undefined behavior when Object->cast_to() gets
called with a Null pointer. This used to work fine with GCC < 6 but
newer versions of GCC remove all codepaths in which the this pointer is
Null. However, the non-static cast_to() was supposed to be null safe.
This patch makes cast_to() Null safe and removes the now redundant Null
checks where they existed.
It is explained in this article: https://www.viva64.com/en/b/0226/
The initial version of the pattern matcher in GDScript does not
allow matching on nested identifiers, only one identifiers available
in the current scope.
With the introduction of enums to GDScript that's a huge missing
feature. This commit makes the parser accept indexed constants and
variables to properly support enums.
GDScript was restricted to parse only scripts beginning with __res://__ or __user://__ to avoid templates from being parsed. I've made that a bit less inclusive by allowing scripts with an empty path to be parsed too, which doesn't conflict and is needed for this to work.
Also I've removed the `this` variable of the generated script and made the relevant object to be the one the script instance refers to, so you can use `self` instead.
Now, with the shorter 3.0-style syntax, you can write things like: `self.position.x + 10`
Closes#9500.
This removes `not` from the variable safe list of
keywords.
Before that this was a valid expression:
self.!(some_arg)
The other fix is just a forgotten boolean negation.
Notice: GDScript tokenizer used the old PoolFloatArray name.
Renamed PoolFloatArray to PoolRealArray.
Moved "project_settings.h" down one line to comply with the clang-format rules.
Fixes#9638
Closed pull request #9714 because I messed up with commits, sorry!
Implements open_in_external_editor for subclasses of ScriptLanguage.
Add option 'Debug with external editor' to debug menu to control the behavoir of script opened by editor.
Templates will be loaded from .godot/script_templates
For now they're disabled for GDNative.
Ideas for further improvements:
- Add a "Save as Template" option to the script editor, as it can normally only save to res://
- Support more placeholders / custom placeholders
Replaces the `extends` keyword with `is` in the context of testing for type compatibility.
`extends` is still used for declaring class inheritance.
Example:
```gdscript
extends Node2D
func _input(ev):
if ev is InputEventKey:
print("yay, key event")
```
The very first Godot version (when it was open sourced) had "MultiScript" which lets you use multiple scripts on one object.
With the addition of mulitple new scripting languages (VisualScript, soon C# and GDNative) it can be of use to combine scripts rather than delegating (with huge maintainance cost) or creating child nodes
which could impact performance.
I used the code from 0b806ee as the base and made it work with the current master.
I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?
I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon
A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format
A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code
The other subfolders of tools/ had already been moved to either
editor/, misc/ or thirdparty/, so the hiding the editor code that
deep was no longer meaningful.
Juan Linietsky
Rémi Verschelde
Bojidar Marinov
Ignacio Etcheverry
Bernhard Liebl
Andreas Haas
George Marques
pablotato
sanikoyes
Robert Morse
Ferenc Arn
Geequlim
Leon Krause
Michael Alexsander Silva Dias
Goutte
Paulb23
Hein-Pieter van Braam
Unknown
Jerome67000
jagt
Chaosus
Ruslan Mustakov
Scayze
William Taylor
Poommetee Ketson
Wilson E. Alvarez
Karroffel
Marcelo Fernandez
Pedro J. Estébanez
Indah Sylvia
Andrii Doroshenko (Xrayez)
Mariano Suligoy
Andreas Haas
Ramesh Ravone
mbalint12
curtisxk38
Saggi Mizrahi