Release notes

What’s new #

Content Development #

Disable accessing invalid game objects exposed by reference

Changes in Binding and Data Binding #

Starting with this release, Gameface comes with better binding and databinding safety by improving the way properties of C++ models and objects exposed by reference are accessed in JavaScript.

Until now accessing in JavaScript a property of exposed by-ref object or a data binding model was essentially exposing that property by-ref too. That means that when the pointer to that C++ object is no longer valid, the C++ code is responsible to call additional methods like View::DestroyExposedObject(). This makes it very easy to create use-after-free bugs in the game, while understanding the reason for the crash is not trivial (i.e. where JavaScript is using an object whose game counterpart has been destroyed or relocated).

Now when caching into a variable a property of a model or exposed by-ref object, instead of storing the pointer to the underlying property, we store the path to reach that property. Every time the property is used, it will be queried from the top level object or model, instead of using a cached pointer that may not be valid any more. You still need to make sure that the top level object or model is valid and call respectively View::DestroyExposedObject() or View::UnregisterModel() when it is destroyed.

Behavioral changes #

Exposed properties to JavaScript will no longer be cached by address, but by property/index and parent object. That means that caching the nth element of an array for example will always point to the nth element, even if the array was reordered and the nth element is now a different element, while someone may expect that the object that has been kept will be the original one.

Get unsafe reference to a model property in JavaScript #

If you still need to have an unsafe reference to a property in JavaScript, you can use engine.pinUnsafeReference(model.property1.property2).

There is also a method to disable safe data binding, but we discourage using it: engine.enableSafeDataBinding(false)

Integration #

Custom Properties #

If you have custom classes that inherit from Property, you need to make sure that ToArray() method works correctly if your Property has such semantics, including with C-style arrays.

Custom array types #

Binder::TryBindArrayByRef() has additional parameter typedef void* (*ArrayElementGetter)(void*, size_t) which returns a pointer to the nth element of the array. You need to provide such argument to TryBindArrayByRef if your engine has custom array types. You can check Array.h and Vector.h headers for example.

Custom map and pair types #

Every type that uses Binder::MapBegin() and Binder::MapEnd() in the bind function, such as maps, pairs, etc, should wrap the call to CoherentBind with CoherentBindKeyValueProperty(). You can check Map.h, UnorderedMap.h and Pair.h for example.

Rendering #

Emoji glyphs support

Gameface now supports certain kinds of emoji fonts.

Gameface can load and display emoji from COLRV0 emoji fonts. Those are flat shaded emoji glyphs comprising of several path objects.

Gameface renders the emojis on the GPU and caches them on glyph atlases. This makes the emojis rendering smooth and with no performance bottlenecks.

For more details, see the documentation for the emojis support

Migration guide #

Migrating to 1.61

Support for BGRA8 textures #

The graphics library has a new pixel format – PF_B8G8R8A8. All provided backends now support the new texture format and can create textures from it.

New shader types #

With this version, Gameface comes with 2 new shader types: ST_CircleTextureRepeat, ST_EllipseTextureRepeat. Their corresponding pixel shader types are PST_CircleTextureRepeat (matching the already existing PST_RoundedRectTextureRepeat) and PST_EllipseTextureRepeat.

Changelog #

Version 1.61.0 #