This changes the types of a big number of variables.
General rules:
- Using `uint64_t` in general. We also considered `int64_t` but eventually
settled on keeping it unsigned, which is also closer to what one would expect
with `size_t`/`off_t`.
- We only keep `int64_t` for `seek_end` (takes a negative offset from the end)
and for the `Variant` bindings, since `Variant::INT` is `int64_t`. This means
we only need to guard against passing negative values in `core_bind.cpp`.
- Using `uint32_t` integers for concepts not needing such a huge range, like
pages, blocks, etc.
In addition:
- Improve usage of integer types in some related places; namely, `DirAccess`,
core binds.
Note:
- On Windows, `_ftelli64` reports invalid values when using 32-bit MinGW with
version < 8.0. This was an upstream bug fixed in 8.0. It breaks support for
big files on 32-bit Windows builds made with that toolchain. We might add a
workaround.
Fixes#44363.
Fixesgodotengine/godot-proposals#400.
Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
- Based on C++11's `mutex`
- No more need to allocate-deallocate or check for null
- No pointer anymore, just a member variable
- Platform-specific implementations no longer needed
- Simpler for `NO_THREADS`
- `BinaryMutex` added for special cases as the non-recursive version
- `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`.
- `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same.
Happy new year to the wonderful Godot community!
2020 has been a tough year for most of us personally, but a good year for
Godot development nonetheless with a huge amount of work done towards Godot
4.0 and great improvements backported to the long-lived 3.2 branch.
We've had close to 400 contributors to engine code this year, authoring near
7,000 commit! (And that's only for the `master` branch and for the engine code,
there's a lot more when counting docs, demos and other first-party repos.)
Here's to a great year 2021 for all Godot users 🎆
(cherry picked from commit b5334d14f7)
See https://github.com/godotengine/godot/issues/22581#issuecomment-576836691.
Not using `or_greater` as there *is* a max size value that the current
implementation can accept. If using e.g. size 6000 with
FiraSans-Regular.ttf, errors are printed due to failing asserts on a
glyph size that should be within 4096x4096 px.
Happy new year to the wonderful Godot community!
We're starting a new decade with a well-established, non-profit, free
and open source game engine, and tons of further improvements in the
pipeline from hundreds of contributors.
Godot will keep getting better, and we're looking forward to all the
games that the community will keep developing and releasing with it.
The last remaining ERR_EXPLAIN call is in FreeType code and makes sense as is
(conditionally defines the error message).
There are a few ERR_EXPLAINC calls for C-strings where String is not included
which can stay as is to avoid adding additional _MSGC macros just for that.
Part of #31244.
Fix#24456
The character->rect.size is properly update at DynamicFontAtSize::_bitmap_to_character
so no need to multiply scale again.
It was changed with 5cd12f6649
- Editor font anti-aliasing can now be disabled in the Editor Settings.
- DynamicFonts used in projects can now have their anti-aliasing
disabled in their DynamicFontData child. Changes will be visible
upon reloading the scene in the editor.
Means the list is destroyed before the OS object, allowing it the
opportunity to print an error if there are still dynamic font objects
hanging around.
This allows more consistency in the manner we include core headers,
where previously there would be a mix of absolute, relative and
include path-dependent includes.
This commit makes operator[] on Vector const and adds a write proxy to it. From
now on writes to Vectors need to happen through the .write proxy. So for
instance:
Vector<int> vec;
vec.push_back(10);
std::cout << vec[0] << std::endl;
vec.write[0] = 20;
Failing to use the .write proxy will cause a compilation error.
In addition COWable datatypes can now embed a CowData pointer to their data.
This means that String, CharString, and VMap no longer use or derive from
Vector.
_ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug
builds. This is a lot faster for Vector in the editor and while running tests.
The reason why this difference used to exist is because force-inlined methods
used to give a bad debugging experience. After extensive testing with modern
compilers this is no longer the case.
Some classes use Font::get_char_size directly and not only for
autowrapping. RichTextLabel is one such example. So this commit
reverts aa8561d (PR #17504) and instead ceils character width within
Label. This makes sure Label autowraps correctly while not affecting
other Font clients.
Fixes#18835.
Fixes#15787.
The issue occurred when two (or more) separate DynamicFont instances
used the same DynamicFontAtSize instance due to having equal
properties. The first instance updated its data_at_size and emitted
"changed" signal, but the second did not because it considered the
data_at_size to be up to date, even though it has just been updated.
- Implement outlines based on FreeType Stroker API. This allows
artifact-free results, similar to what you will see in Web or any text
editing tools. Outline is a part of DynamicFont rather than Label,
because outlines have to be baked into the font's atlas. Font has a
default outline_color and a Label can specify font_outline_modulator
that will be multiplied with the Font's color to get the final result.
- draw_char now has to be called twice to fully render a text - first
with p_outline == true for each character and then with
p_outline == false for each character.
- Number of draw-calls is reduced from 5 to 2 per outlined character.
- Overall cleanup of DynamicFont code, extracted duplicated code pieces
into separate methods.
- The change is backward-compatible - Labels still have outline
properties that work exactly as they worked before.
Closes#16279.
Fixes#15459. When oversampling is enabled, glyphs may have fractional
size, but they are still rendered into integral pixels, which results in
them taking more space than was anticiped by autowrapping algorithm. The
solution here is to return ceiled width, which makes autowrapper
consider characters a bit larger than they are, but it doesn't hurt the
actual rendering and ensures there is enough space for the characters.
