General: This is the home page of a channel. It is similar to someone's profile "wall" in a social network context. Posts created by the channel are displayed according to the observer's viewing permissions.
Create a Post: If you have permission to create posts on the channel page, then you will see the post editor at the top.

Fri, 19 Apr 2019 16:53:33 +0200

Presentations

Hello Godotters, my name is Fabio Alessandrelli, you may know me by my handle fales (faless on GitHub). Here are a few words about my Godot journey.

I first discovered Godot in 2015 while looking for a good game engine (that would also work on GNU/Linux) to develop a small game for a university project with a friend.

It was the early era of Godot 1.0, which was open sourced just few months before.

It was love at first sight, and since then, I slowly started contributing to its development, proposing small PRs whenever I found something that was missing or not working and I had the time to fix, learning a lot in the process.

Finally, I started specializing in the networking subsystem (again, because I needed it for my projects). I slowly became the “network guy”, so if your networking PR or issue is stalling, yes, it's my fault, I'll try to review them soon™.

On HTML5, WebSockets, WebRTC

One of the thing that struck me after some time playing with Godot, was how easily it enables developers to export for different platforms, and among those, HTML5/WebAssembly (thanks to the great effort of many developers, especially eska, the current HTML5 platform maintainer). Enabling developers to share their beautiful games running in browsers is a great feature for an engine!

Networking trough browsers used to be very limited and originally only HTTP requests were possible.

Websocket

Then, in December 2011, the WebSocket protocol was standardized, allowing browsers to create bidirectional channels to a WebSocket server. The protocol is pretty simple, it begins with an HTTP request from the browser with some protocol specific headers. From there, if the server accepts the connection (replying with similar headers), the connection is kept open, and data begins to flow bidirectionally using the quite simple protocol message format.

That though, wasn't enough. WebSockets still uses a TCP connection, which is good for reliability but not for latency, rendering it useless for real-time applications (e.g. VoIP, fast-paced real-time games).

WebRTC

For this reason, since 2010, Google started working on a new technology called WebRTC, which later on, in 2017, became a W3C candidate recommendation (i.e. it's considered quite stable but it's still being worked on). WebRTC is a much more complex set of specifications and API, and uses a lot of other technology underneath (ICE, DTLS, SDP), to provide fast, real-time, and secure communication between two peers.

The idea, is to find the fastest route between the two peers and establish whenever possible a direct communication (as in try to avoid a relaying server).

This comes at a price though, and the price is that some media information must be exchanged between the two peers before the communication can start (in the form of Session Description Protocol – SDP strings). This usually takes the form of a so-called WebRTC Signaling Server.

Image/photo

A signaling server (for example a WebSocket server) to which peers connects and send their media information. The server then relays those information to other peers, allowing them to establish the desired direct communication. Once this step is done, peers can disconnect from the signaling server and keep the direct P2P connection open.

Current work on supporting WebRTC in Godot

During the last month, I've spent most of my time (paid by the Software Freedom Conservancy thanks to a grant by Mozilla Foundation) working on a WebRTC implementation for Godot Engine. Part of the work, was already done by Brandon Makin during GSoC 2018.

I focused on getting the Javascript version ready, and porting the work of Brandon Makin to GDNative (to support WebRTC in native exports, without having to bundle the huge WebRTC Native Code reference library into Godot sources). So, while the WebAssembly export will have WebRTC support out of the box, native exports (e.g. GNU/Linux, Windows, macOS, Android, etc.) will need a GDNative library to work.

This is done by having a WebRTCGDNative class, which we then implement via GDNative, and will be released in a separate repository.

But how does this work?

Here are the Godot-exposed functions for the current state in my branch (yes, yes, I will document them, when the work is ready :) ):

Image/photo

NOTE: The API will slightly change to allow creating multiple data channels.

And here is a simple schema on how to use it:

Image/photo

Wait, that doesn't look simple! Well, that's true, WebRTC has a fairly complex setup phase, but it can be boiled down to 4 steps:

The peer that wants to establish a new connection calls create_offer().
- A new offer_created signal is emitted by that same WebRTC peer.
- The signal values need to be passed to set_local_description.
- The signal values need to also be passed to the remote peer, using any means desired (usually, the Signaling Server).
The remote peer will need to pass the received parameters (type and sdp) to its WebRTCPeer set_remote_description.
- This will generate an offer_created signal on that peer.
- The signal values need to be passed to set_local_description.
- The signal values need to also be passed to the peer that generated the offer in the first place.
The peer that originally generated the offer will pass the received parameters (i.e. the answer from the remote peer) to its own WebRTCPeer set_remote_description.
After calling set_remote_description on each peer, multiple new_ice_candidate events will be emitted.
- The values from those events needs to be sent to the other peer (again, via the signaling server).
- Each peer will then pass the candidates received from the signaling server to the add_ice_candidate function (i.e. each peer must pass to the function the candidate generated by the other peer).

After that, the connection will be established!

Reference work

You will need a recent build of Godot's master branch:https://github.com/godotengine/godot/tree/master

A compiled version of the WebRTC GDNative library is available at:

https://github.com/godotengine/webrtc-native/releases/tag/0.2

A small demo to test it can be found at:

https://github.com/Faless/webrtc-native-demo/releases/tag/0.2

The work on the reference WebRTC signaling server based on WebSocket is available at:

https://github.com/Faless/gd-webrtc-signalling

Additional resources

Websocket

RFC: https://tools.ietf.org/html/rfc6455

JS API: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API

WebRTC

W3C Recommendation: https://www.w3.org/TR/webrtc/

JS API: https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API

Engine

Atlas support returns to Godot 3.2

Godot Engine Official

Fri, 19 Apr 2019 02:00:00 +0200

Atlas support returns to Godot 3.2

With the import system rewrite in Godot 3.0, the ability to import atlases was lost. Using atlases is not as common nowadays, given the processing power of desktop and devices has increased a lot, but there are many use cases where this may be worth it. Godot 3.2 will bring back support for it.

What is an Atlas?

Importing images into an atlas is a process that will take all of the images, and pack them into a single larger image (called an "Atlas"). Then, when the original image needs to be drawn, it actually draws the piece of the larger atlas.

Image/photo

Character is (c) Square Enix.

This is also only useful for 2D (Godot does not support 3D atlases).

So, why would one use an atlas instead of individual images? In most cases, it doesn't make sense, but for some situations it may provide some improvement in memory usage or performance. Here are such cases:

Batching

In cases where a lot of objects need to be drawn, having them all share the same texture (or material) may reduce draw calls or state changes. When working on tile-sets, it's normal to have everything already drawn to a single texture but if the level uses a lot of separate images, then using an atlas may make sense to improve performance.

Optimizing Memory

When doing character animations, specially characters with hundreds of thousands of animation frames (like Cuphead), using an atlas will not give any increase in performance (as only one frame is drawn at the same time).

However, to ensure animation remains fluid and easy to integrate, animators will use a relatively large image size that remains constant, then animate a smaller character inside. This produces a lot of wasted memory, as these empty places in the animation frames take up a lot of video memory and make loading slow.

Image/photo

Using atlases ensures that, before placing all the animation frames in a single image, the frames are cropped (and the offset to the crop remembered). The packer will then, ensure everything is fit in the atlas image as compactly as possible. This makes it easy to optimize for memory, as only the places in the images that contain information are saved.

How to use atlases in Godot

Using atlases in Godot is extremely easy. Just select all the files that you want to pack together in the Filesystem Dock, then change the import type to "Texture Atlas".

When the new file type is selected, change the "atlas file" setting to the image you will want to create, then push the "Re-Import" button. All your assets will be re-imported and added to an atlas. (The editor will restart afterwards, as the images may be in use, to ensure everything is re-opened in a clean state).

Here is a visual explanation:

Image/photo

Packing is also deterministic, which means that the same image should always be generated (this ensures it works for generating normal map atlases separatedly, as an example).

Import modes

As you may have noticed, atlas files have an Import Mode, settings. There are two possible ones:

Region

This packs the used part of the image in a square region in the atlas, then this is referenced in an AtlasTexture.Region takes up more space, but allows drawing only parts of the image, clipping it, etc. It also means that it can be batches. This mode is ideal for optimizing performance, as mentioned above.

Mesh2D

This cuts a polygon around the used part and packs it, resulting in considerably more efficient packing. The downside is that drawing it is less flexible (some operations such as showing a region of it are not possible). It is not possible to batch meshes either. This mode is ideal for optimizing memory in the mode mentioned before.

Future

I hope this is the last feature I will personally add to Godot 3.2, so I can soon move to work on Vulkan. As always, if you are not yet, please consider becoming our patron, help us hire an extra developer and ensure that Godot development remains free.

Engine

The new Cocos Website is here!

Announcements - Cocos2d-x Forums

Thu, 18 Apr 2019 12:40:17 +0200

The new Cocos Website is here!

@slackmoehrle wrote:

It has taken the team a lot of hard work and dedication, but the new Cocos Website is finally here. Please join me in thanking the entire team for bringing the Cocos brand into it’s next stage of life.

Just a few housekeeping items:
Cocos2d-x.org will start redirecting to the new Cocos Website
these forums will remain here and__NOT__ be changed.
We will be experimenting with some fonts to make our websites easier to read. Let us know what you think as we experiment.

Posts: 2

Participants: 1

Read full topic

Announcements Engine

What should Cocos2d-x v4 be?

Announcements - Cocos2d-x Forums

Wed, 17 Apr 2019 18:02:31 +0200

What should Cocos2d-x v4 be?

@slackmoehrle wrote:

@walzer if working on deciding what v4.0 will be. Let’s help him!

So far:
For sure metal support
Solid 3D renderer, new 3D features and a new 3D editor
What are your thoughts on these item?

Should we merge GitHub.com/cocos-creator/cocos2d-x-lite to cocos2d-x v4, and publish with the Cocos Creator editor support?

Could we focus JavaScript & TypeScript only, and abandon C++ & Lua API?

Should we promote the totally rewritten 3D framework in v4?

Posts: 2

Participants: 1

Read full topic

Announcements Engine

Announcing the Godot 2019 showreel

Godot Engine Official

Tue, 16 Apr 2019 02:00:00 +0200

Announcing the Godot 2019 showreel

Another year, another showreel. As every year, the amount of quality games being created by Godot has increased significantly (as did the amount of submissions).

Submissions

The idea of the reel is to include games both published and in development.

We got well over a hundred submissions this year, 3 or 4 more times than last year. Most of them are fantastic, but it became impossible to put all of them in the official reel, not even in the extended one.

After discussing, we decided to split into two, one for Mobile and one for Desktop/Console games, so have a seat, grab a drink and enjoy the 2019 showreels!

Desktop / Console showreel

Mobile showreel

Future

In some days we will also put up the extended showreel, including significantly more games.

As always, big thanks to Hubert Lamontagne for supplying music to the reel and to Hugo Locurcio for the editing.

Remember that, as always, Godot is open souce and community developed. The core contributors have decided to dedicate their lives to this project, rejecting very juicy offers by the biggest companies in the world. But this can only happen thanks to donations so, if you are not yet, please consider becoming our patron, and help Godot development remain free and open. Even a small donation is enormously helpful.

Engine

The State of Godot | GDC 2019, at GitHub HQ

Godot Engine Official

Mon, 15 Apr 2019 02:00:00 +0200

The State of Godot | GDC 2019, at GitHub HQ

This year, during GDC, GitHub again hosted a Godot Meetup at their offices and the amount of attendants was considerably bigger than last year. Thanks hugely to them for all their support!

We took the chance to do our GDC "keynote" presentation there, which we called "The State of Godot 2019". It was recorded and is now made available for everyone to see on GodotEngine's official youtube channel.

Engine

Godot Engine awarded $50,000 by Mozilla Open Source Support program

Godot Engine Official

Thu, 11 Apr 2019 15:05:11 +0200

Godot Engine awarded $50,000 by Mozilla Open Source Support program

We are delighted to announce that Godot Engine has been awarded USD 50,000 by Mozilla as part of the Mozilla Open Source Support (MOSS) Mission Partners program. This is the second time that Godot receives a MOSS award, after a first award of USD 20,000 in 2016.

This award will be used to fund the work of some of our core contributors on three different work packages, all linked with Mozilla's mission of furthering an open and accessible Web. For Godot, this means making sure that everyone can build and play networked and browser-based games with open source technology.

The work packages (WP) that we defined together with Mozilla are described hereafter. All the contributors working on those work packages are hired as contractors by our fiscal sponsor Software Freedom Conservancy, part-time and for a duration of 9 months. They will post progress reports on this blog.

WP1: Godot Engine's editor on the Web

Godot's editor is built with Godot itself, using the same runtime and UI toolkit as games developed with Godot. This means that it can run on any platform where Godot can run, including browsers via WebAssembly. While it's relatively easy to make the editor build and run for browsers, many of its features can't work out of the box and need specific development for HTML5, such as handling multi-threading or the lack thereof, running/debugging edited projects, filesystem management, cloud storage, etc.

Our contributor Leon Krause (eska), who is the maintainer of our HTML5/WebAssembly platform port, will work on providing a first-class integration of the Godot editor in browsers.

This might open many possibilities in the future such as sharing direct links to projects/scenes in bug reports of the Godot Q&A, being able to run and edit demo projects directly from the browser, collaborative edition features... Notably, this could also be an advantage for Godot's adoption in teaching environments, where getting software installed and configured on all computers of an institution can be a hassle (even for an engine with such a small footprint like Godot).

The WP also includes work to make the editor work on mobile browsers, such as touch screen gestures, responsive UI, etc. This should also make it possible for us to port the editor to Android and iOS natively to tweak your projects on the go.

Additionally, while working on make the editor run smoothly on all major browsers, Leon will have to fix issues which are also relevant for exported games, so all users of the HTML5 port should benefit from this work.

Leon will start the work on WP1 in coming days.

WP2: WebRTC and networking improvements

Fabio Alessandrelli (Fales) is the maintainer of both low-level and high-level networking APIs in Godot. In 2018, he mentored the student Brandon Makin as part of the Google Summer of Code, who did initial work on integrating the WebRTC technology in Godot. The project faced various hurdles with the WebRTC library and could not be completed during GSoC, so Fabio will complete this work. He will also write documentation and create demos and plugins showcasing the use of WebRTC and WebSocket.

WP2 will also cover better tools and debugging features for networked projects, including some changes which will be relevant for Leon's work in WP1, such as implementing an HTTPServer to serve HTML5 exported files, and use WebSocket instead of TCP to communicate between the editor and debugger in HTML5 exports.

Finally, Fabio will work on further networking improvements, including a refactor of the low level TCP/UDP abstractions, implementing DTLS over UDP using mbedTLS, and improving the error handling in the Multiplayer API.

Fabio already started working on WP2 in March, and will soon post his first progress report.

WP3: Artwork commission for high quality demos

Fernando Calabró, the artist who worked on the TPS demo, is going to make professional 3D assets for two more demos. These demos will be used to showcase and benchmark various features of the engine. Particular attention will be given to optimize them for Godot's HTML5 platform (in part thanks to work done in WP1). This will enable them to be used as benchmarking material for upstream WebAssembly developers, thus contributing back to improving this stack.

Fernando started working on WP3 in March, and will soon share his current progress and more details about the planned demos.

A big thank you to Mozilla for supporting our project again with such a substantial award!

As a non-profit entity, we rely on the generosity of the many users who support us on Patreon, as well as companies who sponsor us or grant us funding for specific work packages. Being able to add two part-time developers and one artist on the project's "payroll" will be a huge boost in productivity and development for the engine, and should greatly benefit the community as a whole.

Engine

Week recap — 10 April 2019

Libre Graphics World. Blog

Wed, 10 Apr 2019 18:51:53 +0200

Week recap — 10 April 2019

Double-week highlights: GIMP 2.10.10 release, better tablets support in Krita, a ton of changes in Blender and FreeCAD, the release of Spring animated movie.

Graphics

GIMP developers finally released version 2.10.10 featuring line art colorization, on-canvas layer selection, initial DDS support, and more improvements and new features.

Image/photo

    As usual, the team is attending Libre Graphics Meeting which, this time, is taking place in Saarbrucken, Germany, on May 29 — June 2. If you are around, stop by to say hello (more teams like Inkscape and Krita will be there).

    As for Krita, Boudewijn Rempt and Dmitry Kazakov continued fighting against bugs in the WinInk implementation in Qt on Windows and ended up patching Qt 5.12. Further plan is to implement switching between Wintab and WinInk implementations in Qt. In addition, Scott Petrovic introduced small usability improvements.

    Alexey Kutepov has been working on a selection mode/tool in MyPaint the past few weeks in his own repository. This is early work but it will certainly benefit users in the end.

3D

There's been a ton of changes in Blender over the past few weeks, including these:

Pressing F2 in the 3D viewport now allows easily renaming selected objects.
Any data block in the outliner can now be copy/pasted between .blend files
Grease pencil got an improved soft eraser tool
Report messages look better in the status bar now

    That, and over 200 bugs fixed, as well as dozens more improvements. For a long-ish update from April 1, see the official video:



    Lubos Lenco implemented per-layer masking, blending, opacity and channel control in ArmorPaint.

On top of that, Patrick Moran released LiquidFX for Blender and Armory3D to feature a flipbook animator node, a runtime node (mins, secs, millisecs), a Math.floor node, and a waterfall example (with particles).

CAD

The FreeCAD team is now in an interesting situation all too familiar to GIMP users. Version 0.18 was cut a few weeks ago, the macOS build isn't ready yet, hence the website still says that v0.17 is the latest and greatest version. Meanwhile, developers already tagged version 0.18.1 with bugfixes.

Anyway, there has been a lot of activity in the main development branch that will eventually become v0.19. Yorik van Havre published his March report that mentions, among other things:

A bunch of new educational videos in the Barcelona pavilion series.
Ongoing work on decoupling the geometry construction tools from their BIM semantics: e.g. make a linear extrusion, then call it a wall or a window by setting its type property/
Better IFC compliance thanks to refactoring done by Dion Moult: FreeCAD now updates the complete set of properties based on what object type you chose.
The BIM Diff tool is now available in the BIM workbench.
A new icon theme is being worked on by 1D_Inc to give FreeCAD a more professional, consistent look.

Video

    Matt did pretty much just bug fixing for Olive last few weeks. The one new feature he added is support for a local effects folder, which makes a perfect sense once you find out that Fahad Hasan Pathik is now making extra effects for Olive (you might know him from contributing plug-ins to Natron), or in case you want writing your own GLSL code.

    Matt is also nuking frei0r support from Olive (there was no release made with this feature) for a variety of purely technical reasons. See his post for details.

    The Kdenlive team shot a video from their last coding sprint where team members introduced themselves. Code-wise, they did a lot of clean-up, including full reimplementation of clips transcoding in the project bin.



    The Cinelerra GG team released the March 2019 update featuring optional clip alignment based on audio waveform matching and published a new user manual (PDF).

Tutorials

    Davies Media Design published a new GIMP tutorial on creating an isometric 3D map.



    A new Krita tutorial from David Revoy covers the topic of shading.



    Another tutorial from David, this time in text, explains setting up Wacom Cintiq tablets on Linux.

    GDquest team shot a video on using Krita's Colorize mask for game design, building it on top of an earlier video by David Revoy (published two weeks ago).



    And Dina Norlund posted a tutorial on creating a comic page with Krita from scratch:



    Tux Designer started making quick tutorials on Olive. This one explains how to freeze/hold a frame:

Art and showcases

    The biggest news here is the much-anticipated release of Spring, a new animated short film by Blender Institute. The all-star team was comprised of Andy Goralczyk, Francesco Siddi, David Revoy, Hjalti Hjalmarsson, Pablo Vazquez, and other talented people, including the team of developers — Brecht van Lommel, Jeroen Bakker, Sergey Sharybin, Sybren Stüvel, and others, all led by Ton Roosendaal.



    Juan Hernández published a cute render made with Blender/Cycles (not too cute if you are of a snail persuasion):

_Snail Souprise is by the moment my newest illustration. All the models and texturing were done in Blender and the scene was rendered in Cycles at 2000 samples. This is also my first scene done in Blender 2.8, even when being still in beta, lots of it's features came really in handy._

Clinton Villanueva is giving Krita some good testing:

News Editorial art

Godot 3.2 adds support for convex decomposition

Godot Engine Official

Wed, 10 Apr 2019 02:00:00 +0200

Godot 3.2 adds support for convex decomposition

Another long awaited feature makes it for Godot 3.2. This makes the workflow for 3D games considerably easier, by allowing conversion of concave meshes of any form into a set of convex shapes.

The convex problem

To explain as simple as possible, this feature does not add anything new, but improves the existing workflow.

Triangle mesh shapes (ConcavePolygonShape) work very well as static colliders, but they are useless for rigid bodies or areas, as they have no internal volume. To work around this limitation, convex shapes must be used.

The obvious problem with them is that they only really work well for convex geometry. When geometry is not convex, the usual workflow is to create more than one shape to cover the desired concave area. Doing this is tedious and the results are often not great (specially for complex geometry).

Here is an example of adding collision shapes to Suzanne by using standard shapes (two capsules, a sphere and a box):

Image/photo

It works and it will collide more or less OK, but it's tedious to build and far from perfect.

Convex Decomposition

So, what if this process could be automatic? Imagine that, with the press of a button, any mesh is divided into N number of convex shapes that cover the surface of the geometry as best as possible.

This is pretty much what convex decomposition is. It's now available via the MeshInstance menu:

Image/photo

Using this option makes the most sense when the edited MeshInstance is child of a RigidBody, KinematicBody or Area (as we mentioned before, for static bodies, triangle mesh works fine and is the recommended workflow). For anything dynamic, based on actual geometry, convex decomposition is the way to go.

This option existed before, but it only generated a single convex shape based on QuickHull. This was imprecise and inefficient. The new version uses de VHACD algorithm, and generates very precise (and simplified) convex geometry:

Image/photo

Thanks to this, it's possible to effortlessly add collision to any concave shape and increase the physics realism of games:

Generating convex shapes on import

When importing data from 3D content creation tools such as Blender or Maya, Godot already supports generating collision objects or rigid bodies from the scene via the special hints added to the names of objects.

From now on, existing hints (such as -convcol,-convcolonly and -rigid) will generate convex shapes via decomposition (instead of the old QuickHull-based approach). This will finally allow creating rigid bodies directly in the 3D scene.

Future

Please give us feedback and test well, to ensure this feature works as best as possible in upcoming Godot 3.2!

And as always, if you are not yet, consider becoming our patron. This ensures that Godot development remains free from the control of any company and we can keep working like now, with the freedom to listen to everyone equally.

Engine

Godot 3.2 will get new audio features

Godot Engine Official

Wed, 10 Apr 2019 02:00:00 +0200

Godot 3.2 will get new audio features

I left these out of 3.0 and never managed to work on it again, yet users requested them a lot this past year. Finally, they will be available for Godot 3.2.

Audio Generators

This is a new type of AudioStream that can be put in the regular stream players (normal, 2D and 3D): AudioStreamGenerator. Just put it anywhere and then get the Playback object, in this case AudioStreamGeneratorPlayback.
var playback = $StreamPlayer.get_stream_playback()
Once this object is obtained, push stereo audio frames to it. You can do this by supplying Vector2 objects via buffers or individual audio frames. From GDScript, it's simpler to push individual frames (though less efficient). GDNative and C# allow pushing buffers.

Here is some example code on how to fill the buffer with a sine wave:
func _fill_buffer():
var increment = (1.0 / (hz / pulse_hz))

var to_fill = playback.get_frames_available()
while (to_fill > 0):
playback.push_frame( Vector2(1.0,1.0) * sin(phase * (PI * 2.0))
phase = fmod((phase + increment), 1.0)
to_fill-=1;

Just call this function before AudioStreamPlayer.play() (to ensure buffer is full before playback begins), and then call it from _process(), to ensure it remains full.

Spectrum Analyzer

There is also a new effect named AudioEffectSpectrumAnalyzer. It can be set as an audio bus insert. Once there, just obtain the AudioEffectSpectrumAnalyzerInstance instance via API:
# This gets the first effect in the Master bus (0)
spectrum = AudioServer.get_bus_effect_instance(0,0)

This instance synchronizes with the audio playback, so the magnitudes of the frequency ranges should be exactly what is playing right now (or as close as possible). This uses Fast Fourier Transform, so you can change the buffer size to a smaller one for more accurate timing (but less accurate frequency information).

To get the magnitude of a frequency range, use the following function:
var f = spectrum.get_magnitude_for_frequency_range(from_hz,to_hz)
This returns a normalized value in linear scale (DC at 0, saturation at 1). Use the linear2db() helper to convert to Decibels if needed.

Here is a simple example for drawing a spectrum, using linear frequencies:
var w = WIDTH / VU_COUNT
var prev_hz = 0
for i in range(1,VU_COUNT+1):
var hz = i * FREQ_MAX / VU_COUNT;
var f = spectrum.get_magnitude_for_frequency_range(prev_hz,hz)
var energy = clamp((MIN_DB + linear2db(f.length()))/MIN_DB,0,1)
var height = energy * HEIGHT
draw_rect(Rect2(w*i,HEIGHT-height,w,height),Color(1,1,1))
prev_hz = hz

And a video of this code in action:

Examples

Example code for both projects can be found in the demo repository.

Future

I wanted to add a BPM detector for rhythm games, but all the open source code I found is GPL (incompatible with Godot MIT), so we will probably need to roll our own. I am too busy for this at the time, but if you want to help contribute to one, let me know (I can lend a hand explaining how it's done).

As mentioned before, this month I will be working in adding missing features for Godot 3.2. Next month I will start the Vulkan port. If you are not yet, please consider becoming our patron. It's easy, and you help the project enormously, even if just a small donation.

Engine

Godot 3.2 will allow disabling editor features

Godot Engine Official

Mon, 08 Apr 2019 02:00:00 +0200

Godot 3.2 will allow disabling editor features

It sounds like an odd feature to have (and never crossed our minds at the beginning). Yet, more and more users requested it, and their context it made a lot of sense. In the end, we now believe this functionality is of vital importance to strengthen Godot adoption in the future.

Disabling / Enabling features

So, what is this exactly? To make it short, It allows enabling or disabling editor features. Using it, the editor can be reduced to a much simpler version of itself.

Short tutorial

This feature can be found in the Editor menu:

Image/photo

Selecting this option brings a new dialog. This dialog lets you enable or disable many areas of the editor:

Image/photo

As you can appreciate on the image above, there are many things that can be enabled or disabled:

General features, such as the 3D editor, script editing, or asset library
Some docks, such as Import, Node or Filesystem.
Scene Tree editing. It can be blocked to avoid the modification of scenes.
Nodes can be disabled, and they won't appear in the Create dialog. Existing ones in scenes will remain visible, but their editors and properties will not appear.
Resources can also be disabled. They won't appear in the Create dialog of the Inspector. Additionally, files of that type will be absent in the Filesystem dock.
Properties for any enabled class can be hidden (disabled ones they will be gone by default).
Finally, it's also possible to disable only editors for any enabled class.

Additionally, these profiles can be easily changed, imported or exported.

What's the main use case for this?

There are two main use cases for this feature:

Education

Besides being proposed by tutorial makers, this feature was suggested several times by professionals in education, who teach Godot at schools and universities.

It allows students to use a simplified version of the editor which helps reduce confusion by focusing only on what needs to be taught.

The profile system for this feature can be used to set the progress of the course, by gradually enabling more functions as they are learned.

Companies

Godot has very powerful tools for lighting, animating, level design, etc. This means that specialized professionals (which are not necessarily programmers) can efficiently use it to create content.

For real-life use cases in medium to large companies, we got requests for restricting what non-programmers can do to only what is needed for their job. This helps avoiding accidental mistakes, specially when they are undergoing training or they work in a very contained area of the project.

Indies and general purpose

We got requests from single developers working on 2D games that they would like to disable the 3D editor and nodes from the Create dialog. The reasoning is that, if not in use, they just add clutter.

With this feature, they can be simply disabled, adding a small usability boost.

Future

A comprehensive set of options is provided for this first version, but I'm sure that more (or more fine-grained) toggles will be requested at some point in time. The plan is to make this feature as useful as possible for the use cases mentioned above.

For the rest of this month, my personal focus will be to add simple (yet very requested) features for Godot 3.2. At the beginning of May, my full focus will switch to Vulkan support. As always, if you are not, please consider becoming our patron to help speed up Godot development. Even a small amount helps us enormously :)

Engine

Godot 3.2 will get pseudo 3D support in 2D engine

Godot Engine Official

Fri, 05 Apr 2019 02:00:00 +0200

Godot 3.2 will get pseudo 3D support in 2D engine

Pseudo 3D support

Godot support for 2D is already mature and most of our users enjoy working with it. There is, however a growing trend of adding 3D layers to 2D games, which can be seen in successful titles such as Hollow Knight or Rayman Origins.

This is possible because the engines in which such games are made are actual 3D engines using 2D planes. In the end, doing this is possible but it requires understanding and being familiar with how 3D engines work.

Same technique in Godot

This is also possible in Godot using the 3D engine, via nodes such as Sprite3D, but truth is that this technique requires user to do more work and understand more about how 3D space functions.

Parallax (via ParralaxBackground) works to some extent, but it's more aimed to be used as a far away background rather than adding depth to the game play area.

Because of this, a new way to implement pseudo 3D was added to the 2D engine, so the same results can be obtained with pure 2D programming, making it much easier to develop this type of games while using all the existing 2D tools (and assets) Godot provides.

Canvas layers

Godot 2D engine already has a node named CanvasLayer. Everything that is a child or grandchild of it will render on this layer. The layer index can be specified as a number (and it´s also tree-ordered) to control depth placement, so no real Z positioning is required.

Using this node is a common practice to make user interfaces, because they won´t scroll together with the rest of the Viewport, as layers can move independently.

Yet, moving together with the viewport may actually be desired, so a new option was added: "Follow Viewport". Toggling it on will ensure that this layer will move together with the actual viewport when using a Camera2D.

Adding depth

Together with Follow Viewport, there is a new "Scale" property. This value allows scaling the canvas while following the viewport. It's a simple setting but it can be used to do "Pseudo 3D" with ease:

In practice, just create your level using several CanvasLayer nodes. Edit them together as if you were using an Orthogonal view in 3D:

Image/photo

In the above screenshots, a few CanvasLayer nodes were created. Aftwerwards, the TileMap from the 2D Platformer demo was brute-duplicated and put in every single of them.

Finally, the "Follow Viewport" option was enabled together with a a scale value. This enables the pseudo 3D effect in each layer.

Previewing without running the game

Previewing the effect in the editor is very easy, just use the new "Preview Canvas Scale" option in the 2D view menu:

Limitations

The main limitation of this technique is that it's not possible to move a single object in multiple layers, as they will definitely need to be separate ones (none of the games mentioned above use this, though). This can still be worked around with a RemoteTransform2D node, though requires a bit more work.

Future

This is an experimental feature, so don't forget to give feedback! Also, if you are not one, please consider becoming our patron, to help accelerate Godot development.

Engine

Ogre 1.11 User Survey Results

OGRE – Open Source 3D Graphics Engine

Tue, 02 Apr 2019 17:17:57 +0200 last edited: Thu, 04 Apr 2019 14:52:48 +0200

During the period of Feb 27. – March 27. we received 60 replies. At the same time the ogre 1.11.5 Windows SDK alone was downloaded 644 times. So while the results are significant, they are probably not representative. As statistics are lies, better take a look at the actual numbers yourself. Specific replies Following the […]

View article

News

Godot Engine to go public in 2019

Godot Engine Official

Mon, 01 Apr 2019 02:00:00 +0200

Godot Engine to go public in 2019

We hear you and we understand your concerns. You feel like Godot, in the end, is not "public" enough. Even though there are over 800 contributors pushing code (surpassing any other engine, open or closed, on GitHub), Godot still doesn't feel corporate enough. You miss the excitement of trading company shares, that can only happen when a company goes public.

Worry no longer! Today we announce that Godot will go public this year. Starting today, we are launching an IPO!

IPO

We will be launching our IPO (Initial Pullrequest Offering). This will allow you to own a piece of Godot.

I'm sure that you are confused at this point, but there is nothing strange about this, you actually can own it!

Ownership

Godot is licensed under the MIT license and, like in any open source project, any contribution that is merged (via pull-request) is owned by it's author under the same license. This way, the more you contribute, the more you actually own it. Still, the license ensures that your work will be shared, so your contributions are actual shares.

Image/photo

So, what benefits are there in owning a piece of Godot?

Shareholder meetings

Sharing a piece of Godot allows you to prove yourself as a capable contributor, and this makes it possible for you to be better prepared to discuss the direction of the project when me meet online (or IRL at GodotCons!). The more you share, the more you will help shape the future of Godot!

High frequency sharing

The more exciting part of trading for shares is the speculation part. Love watching at graphs every day? GitHub insights are the right tool for you!

Image/photo

Want to be part of this? Do your Initial Pullrequest Offering today and start contributing! You can start by checking out the engine development documentation and also taking a look to our junior job issues.

Investing

Oh, but we understand, and realize that many reading this were thinking of investing real money in Godot (who wouldn't?). Well don't worry, as there is still a way to do it! If you are not yet, please consider becoming our patron and help shape the future of the project!

Engine

Engine news (6.5 release snapshots, improvements to editor, TCastleWindowBase, joysticks and more)

Castle Game Engine

Sun, 31 Mar 2019 04:23:28 +0200

You can now download Castle Game Engine 6.5 “snapshot” (build from the latest GitHub code) from here. Until I release a stable Castle Game Engine 6.6, this is the easiest way to test the very latest CGE features (including new GUI editor). I’m working now on making this snapshot fully-automatically updated by Jenkins, and I’ll …

Continue reading ➤

View article

Engine news (6.5 release snapshots, improvements to editor, TCastleWindowBase, joysticks and more)

You can now download Castle Game Engine 6.5 “snapshot” (build from the latest GitHub code) from here.

Until I release a stable Castle Game Engine 6.6, this is the easiest way to test the very latest CGE features (including new GUI editor). I’m working now on making this snapshot fully-automatically updated by Jenkins, and I’ll probably make it linked from our main page soon.
Many editor improvements:
- Images of TCastleButton are now configurable in the editor.
- Properties are split into tabs Basic, Layout, Other, All. Note that the Layout tab contains both properties list and anchors UI.
- Properties TCastleImageControl.Clip, ClipLine, Rotation, RotationCenter are now published and configurable in the editor.
- You can edit colors in hexadecimal notation, like AABBCC. This allows to easily copy colors between CGE editor and GIMP/Photoshop etc.
- You can configure TCastleScene animation in the editor (use AutoAnimation, AutoAnimationLoop properties).
TCastleWindowCustom / TCastleControlCustom are renamed to TCastleWindowBase / TCastleControlBase and are simpler to use now, as they by default have a defined background. Control it using the new Container.BackgroundColor and Container.BackgroundEnable properties.

For new applications, I actually advise using TCastleWindowBase / TCastleControlBase instead of their counterparts TCastleWindow / TCastleControl.

The downside of using TCastleWindowBase / TCastleControlBase is that you need to add a scene manager instance to them yourself (or using CGE editor). But that’s usually trivial: From code, just do SceneManager := TCastleSceneManager.Create(SomeOwner); Window.Controls.InsertFront(SceneManager);. Or just use CGE editor to add TCastleSceneManager to the appropriate xxx.castle-user-interface design.

The upside is that you control the moment of creation of the TCastleSceneManager. You don’t have to create it right at the beginning of the application, you don’t have to keep it created until the end of the application. E.g. you can show a main menu, and only create TCastleSceneManager once user presses “Play”. You can even use our TUIState to nicely separate your application into states for this (1 state for “showing the main menu”, 1 state for “playing the game”), and our UI controls play nicely with this (whether you create them in code, or design in CGE editor).
FindFiles is now reliable and cross-platform. Can search recursively in game data (using castle-data:/ protocol) always, even e.g. in Android assets or Nintendo Switch game data.
TGLImage and TGLImageCore are finally merged into one class, TDrawableImage . This makes them simpler.
New class TCastleImagePersistent allows to load images (TDrawableImage) with caching, and can be used to configure image in the editor comfortably. It is used by TCastleImageControl and TCastleButton already.
Joysticks:
- Refactored (moved a lot of code into platform-specific “backend” classes in separate, internal units).
- Various API improvements. E.g. you can now just use Joysticks.Count, Joysticks[0].Axis (TVector2).
- Joysticks work also on Nintendo Switch now.
Introduced static properties TRenderingAttributes.DefaultMinificationFilter, DefaultMagnificationFilter.

This allows to e.g. easily disable mipmaps in all scenes on some cases, by TRenderingAttributes.DefaultMinificationFilter := minLinear;

Uncategorized Engine

FreeGameDev.net AR/VR feed

Fri, 29 Mar 2019 13:20:59 +0100

Godot Engine Official wrote the following post Fri, 29 Mar 2019 08:57:24 +0100

Update on Godot AR and VR
Update on Godot AR and VR

It may have seemed a little quiet on the Godot AR and VR front but a lot has been happening behind the scenes. With Godot 3.1 released and new plugins being uploaded to the asset library, an update on the state of things is long overdue.

Godot 3.1 has various optimisations added to speed up the stereoscopic rendering. There is more work to be done here, some of which we wish to tackle once the Vulkan port is on the way and will have to wait for the 4.0 release, but we are planning improvements for 3.2. A breaking change did have to be introduced for 3.1 which means that new plugins are required, you can't use the Godot 3.0 VR plugins in 3.1.

That Godot has AR and VR support isn't widely known but there is a slowly growing userbase out there and even a few commercial products.

GDC 2019

GDC proved very interesting for us, see Juan's status report.

Collabora showed off their Monado OpenXR platform with a demo using an early OpenXR plugin for Godot made by the people behind OpenHMD.

We also talked to Oculus about the support we've added to Godot for the Rift headset and were met with great enthusiasm.

ARKit

But let's start with talking about AR first. An ARKit interface has been available unofficially for well over a year. One of the more interesting projects to come out of this is Torch, an AR prototyping tool worth checking out. In the beginning of this year we made great strides with this interface implementing some of the ARKit 2.0 features Apple added in. There are now 3 companies we are aware of that are building products for ARKit using Godot.

You can follow the development of this interface here: http://github.com/godotengine/godot/pull/24227

ARCore

Work on Google's ARCore is progressing with basic tracking logic now functional. Google has taken an interest and is helping us out so we expect things to progress pretty quickly in the coming months.

You can follow the development of this interface here: http://github.com/godotengine/godot/pull/26221

Cardboard and Daydream

While the native mobile VR interface that comes build into Godot is inspired by Cardboard, there is no official Cardboard or Daydream support yet. However the work we are currently doing with ARCore is resulting in a number of improvements to the Android platform that should make Cardboard and Daydream support a reality in the not-too-distant future. Watch this space!

Microsoft Windows MR

Unfortunately direct support for the WMR platform is still missing from Godot. We've made a few false starts here. You can develop for WMR through OpenVR but we are looking into native support. The main issue revolves around OpenGL having limited support on UWP and things just not playing nice with Microsoft's Holographic API. Vulkan may prove interesting here.

That said, Microsoft has put its full weight behind OpenXR it seems, with the mixed reality headsets being the first with feature complete OpenXR drivers. This may end up being the best way for Godot to work with this ecosystem.

We do not yet know what this means for Hololens 2 and possible Hololens support being added to Godot.

Oculus

The Oculus Rift driver has been available for some time and works great. We haven't had a chance to play with the Rift S yet but we have every reason to believe this will work with the drivers we already created.

You can follow development of the Oculus interface here: http://github.com/GodotVR/godot_oculus

You can download the official plugin from the asset library here: Godot Oculus plugin

Gear VR, Oculus Go and Oculus Quest however use a different set of libraries running on top of Android. Last year we made a push as part of the Google Summer of Code but unfortunately this work got stuck due to problems with the GLES3 drivers on these devices and GLES2 becoming available too late. We're hoping to pick up where we have left off soon.

OpenHMD

OpenHMD as a project has been growing steadily over the last year adding many interesting headsets to the list of devices they support, while many are still in development. Godot has had an interface for OpenHMD for some time now which works well but needs a compositor, something we hope to tackle in the near future. You can follow development of the OpenHMD interface here: http://github.com/GodotVR/godot_openhmd

OpenVR

OpenVR has been working well and has several teams working on various projects using this driver. We have yet to look at some of the new additions and support for the new knuckles controllers.

The problem with HDR remains, Godot renders to high detail buffers for its HDR support and OpenVR does not like these. There is a PR in the official godot_openvr repository that contains a fix, but for the official release of the plugin, HDR still needs to be turned off or the GLES2 renderer needs to be used.

You can download the official plugin from the asset library here: Godot OpenVR plugin

OpenXR

We've already talked about OpenXR, this is a specification that has been worked on for a couple of years now, but this year's GDC finally reached a milestone where example source code has become available. The specification was also released in version 0.9.

The interface that was used during the Monado demonstration is based on the OpenHMD drivers. You can follow its development here: https://gitlab.freedesktop.org/monado/godot_openxr

GLES2

The addition of the OpenGL ES 2.0 render pipeline is one that is very interesting to VR. Stereoscopic rendering at high resolutions and frame rates puts a large tax on your GPU. For the new HP Reverb headset the output may be 2160x2160 pixels per eye, this means that we're rendering at a resolution of 4320x4320 twice per frame at 90fps. That requires some serious grunt if you've turned up all the new features of the GLES3 renderer. The move to Vulkan will mitigate some of that but still, being able to fall back on a render pipeline that is simpler and therefore faster means that you can use a high resolution headset even if you're running on the mid-end hardware that many gamers will actually own.

Update on Godot AR and VR

Godot Engine Official

Fri, 29 Mar 2019 08:57:24 +0100

Update on Godot AR and VR

It may have seemed a little quiet on the Godot AR and VR front but a lot has been happening behind the scenes. With Godot 3.1 released and new plugins being uploaded to the asset library, an update on the state of things is long overdue.

Godot 3.1 has various optimisations added to speed up the stereoscopic rendering. There is more work to be done here, some of which we wish to tackle once the Vulkan port is on the way and will have to wait for the 4.0 release, but we are planning improvements for 3.2. A breaking change did have to be introduced for 3.1 which means that new plugins are required, you can't use the Godot 3.0 VR plugins in 3.1.

That Godot has AR and VR support isn't widely known but there is a slowly growing userbase out there and even a few commercial products.

GDC 2019

ARKit

ARCore

Cardboard and Daydream

Microsoft Windows MR

Oculus

OpenHMD

OpenVR

OpenXR

GLES2

Engine

The OGA Spring Game Jam 2019 - Announcement

Blog

Thu, 28 Mar 2019 20:20:27 +0100

The OGA Spring Game Jam 2019 - Announcement

Spring is in the air and it's time to create something new, something fun, something exciting, something for the OpenGameArt.org Spring 2019 Game Jam!

This year's theme is 'I enjoy my life' and enjoy your life you will if you participate in this thrilling game jam!

Assets

OpenMW 0.45.0 Released!

OpenMW

Thu, 28 Mar 2019 13:31:14 +0100

The OpenMW team is proud to announce the release of version 0.45.0! Grab it from our Downloads Page for all operating systems. This release brings yet another horde of bug fixes and several new features, including support for per-group KF animation replacers, 360° screenshots, and the ability to brew a whole stack of a potion […]

View article

OpenMW 0.45.0 Released!

The OpenMW team is proud to announce the release of version 0.45.0! Grab it from our Downloads Page for all operating systems. This release brings yet another horde of bug fixes and several new features, including support for per-group KF animation replacers, 360° screenshots, and the ability to brew a whole stack of a potion at once.

If you haven’t tried OpenMW out already, now is the big chance! Bethesda’s free giveaway of Morrowind got extended, so you are still able to get Morrowind for free until March 31st!

Check out the release video and the OpenMW-CS release video by the illustrious Atahualpa, and see below for the full list of changes.

Known Issues:

Shadows are not yet re-implemented
There’s currently no way to redirect the logging output to the command prompt on Windows Release builds — this will be resolved in version 0.46.0
To use generic Linux binaries, Qt4 and libpng12 must be installed on your system
On macOS, launching OpenMW from OpenMW-CS requires OpenMW.app and OpenMW-CS.app to be siblings

New Features:

Non-actor objects display visual effects during spellcasting (#1645)
Creatures without any collision box use auto-generated ones (#2787)
Launcher: File paths of selected content files can be copied via context menu (#2847)
Actors play casting animations during scripted spellcasting (#3083)
As an option, barter deals permanently modify merchant disposition (#3103)
Ranged weapons deal critical hits to unaware opponents (#3703)
360° screenshots of various kinds can be made (#4222)
‘ToggleBorders’ debug instruction (“tb”) available in console (#4256)
Sound generator keys in activator animations are supported (#4285)
On macOS, function key shortcuts can be used (#4324)
Some of the debug settings previously available as command line arguments can be set up in the launcher (#4345)
Support for per-group KF animation replacers has been added (#4444)
Shader water is rougher during bad weather (#4488)
The number of enchanted items in a stack is shown in the Spells window (#4509)
The actual chance of hitting the target is used for AI weapon rating instead of just the skill (#4548)
The real potential damage of a weapon is used for its rating (#4549, #4697)
A bonus is applied to the rating of ranged weapons if the attacker is far enough from the target (#4550)
As an option, the Strength attribute affects Fatigue and Health damage in hand-to-hand combat (#4579)
The logging system has been heavily reworked (#4581)
AI no longer uses magic effects that affect hit chance if the enemy has not taken the appropriate stance (#4624)
AI uses the root mean square of melee-weapon damage for more precise weapon rating (#4625)
AI accounts for weapon speed when rating a weapon (#4626)
Various vanilla GMSTs regarding combat action rating are utilised (#4632)
‘sTo’ GMST (“to”) replaces hyphen in the Spellmaking menu (#4636)
New count field in the Alchemy window allows you to brew multiple potions at the same time (#4642)
To improve performance, actors outside of the AI processing range are no longer rendered but faded out (#4647)
AI processing range can be configured via an in-game slider and a configuration option (#4647)
If the animated creature model lacks a collision box, the non-animated model’s collision box is used as a fallback (#4682)
Tooltips of thrown weapons show the actual in-game damage (twice the base-record damage) the projectiles have (#4697)

New Editor Features:

All top-bar dropdown menu options and most context menu options have icons (#912, #4506)
Actors are rendered in Scene view (#1221)
Verifier functionality covers Enchantment records (#1617)
Added a check box to execute a case-sensitive global search (#2606)
Shift + C is default shortcut for viewing cells (#2845)
Shift + V is default shortcut for previewing records (#2845)
Global search has a status bar (#3276)
Frame rate in Preview window can be limited (#3641)
Log files are created in case of a crash (#4012)
Previously sorted-by-ID lists, such as magic-effect lists, are now alphabetically sorted (#4404)
As an option, base records are ignored in verifier runs (#4466)
Already existing marker models for light sources and creature levelled lists are now used (#4512)

Bug Fixes:

All actors (not only those in active cells) restore Health and Magicka during player character rest (#1875)
Precise times of sunrise and sunset are now recovered from the imported Morrowind INI file (#1990)
Actors now properly aim during scripted spellcasting (#2131)
Skills and attributes that affect trading no longer cause low selling prices if they’re too high (#2222)
Landing sound behaviour for NPCs and the player character has been reworked (#2256)
Scripted movement of an object now adjusts the position of actors standing on top of that object (#2274)
The last equipped item of a certain type is automatically re-equipped once a bound-item spell of the same type expires (#2326)
Restore effects can restore drained stats (#2446)
Attacks from unarmed, non-bipedal creatures no longer degrade armour (#2455)
For the time being, actors are no longer allowed to activate teleport doors so that their abrupt cell change doesn’t cause a crash (#2562)
Using ‘Resurrect’ instruction on a dead player character fully resumes the game (#2626)
References to non-existent classes or factions no longer crash the game (#2772)
Weapons are visually unequipped before the start of a spellcasting stance transition (#2835, #4327)
The player character now gets a bounty when a player follower commits a murder (#2852)
To prevent issues on macOS, SDL is only initialised for the Graphics tab of the launcher when Qt5 is used (#2862, #3911)
Explicit reference calls no longer break [Tab] autocompletion in the console (#2872)
Naked expressions starting with a member operator are no longer allowed outside of the console (#2971)
The handling of Drain and Fortify effects for health, magicka, and fatigue has been reworked to match vanilla behaviour (#3049, #4231)
Enemies are no longer immune to ranged attacks at very close range (#3059)
Adding an item with a self-equipment script to an actor no longer causes a freeze (#3072)
Actors who are placed above the ground are now snapped down at a significantly larger distance when a cell is loaded, preventing them from falling to their death (#3219)
TrueType fonts are now properly rescaled (#3288)
Targets are now much easier to hit with on-touch spells (#3374)
The handling of scripted and death animations has been reworked to significantly improve mod compatibility (#3486, #4286, #4291, #4307)
‘GetSpellEffects’ scripting function can now detect zero-duration effects (#3533)
Enemies are much easier to hit with low-reach weapons, since the intended start position of the attack raycast is now replicated (#3591)
Scripted sleeping interruptions no longer prevent the spawning of random sleep encounters (#3629)
Calling ‘AddSoulGem’ and ‘RemoveSpell’ scripting instructions with an extra argument no longer breaks script compilation (#3762)
‘GetPCInJail’ scripting function has been reworked to more closely match vanilla behaviour (#3788)
Previous placeholder implementation of ‘GetPCTraveling’ scripting function has been replaced with a proper solution (#3788)
Message boxes can now have newline characters in the text argument (#3836)
Alignment of terrain texture painting has been corrected to match the vanilla look (#3876)
Attenuation of magic light sources is now properly calculated (#3890)
‘Goodbye’ scripting function in dialogue results now makes any additional choices act like ‘Goodbye’ (#3897)
‘RemoveSpellEffects’ scripting instruction now also removes permanent effects (#3920)
Movement prediction for spell aiming now uses the correct GMST to calculate the magic projectile’s speed (#3948)
Animated collision shapes are no longer erroneously optimised (#3950)
The terrain texture blending map is now upscaled to more closely match the vanilla look (#3993)
Issues with actors not returning to their initial position in various situations have been fixed (#3997, #4251, #4393)
AI packages with a non-unique target no longer choose a random target with the same ID (#4036)
On macOS, version numbers are now properly displayed in the application properties (#4047)
Text after the last end-of-line tag is no longer shown in books to match vanilla behaviour (#4215)
‘FixMe’ script instruction has been reworked to more closely match vanilla behaviour (#4217)
Jumping on slopes is now less restrictive, preventing the player character from getting stuck in V-shaped terrain (#4221)
Pathgrid nodes which lie between an actor and that actor’s destination are now ignored (#4230)
Actors with an AiTravel package now stop near their target position if that position is blocked by another actor (#4230)
[Activate] key can no longer be held down to spam Persuasion and other kinds of repeatable actions (#4260)
Turning animations no longer reset idle animations (#4271)
Death animations from pre-0.43.0 savegames are now forward-compatible (#4274)
‘CenterOnCell’ script instruction (“coc”) now teleports the player character to the accurate door marker or exterior position for interior and exterior cells respectively (#4292)
Faction members are now aware of faction ownership during barter (#4293)
AiWander packages which are placed before an AiFollow package in the AI package list no longer override vital functionality of that AiFollow package (#4304)
Key focus in containers is now automatically (re)set to the [Close] button to prevent players from accidentally stealing items (#4333)
Spellcasting stance transitions no longer interrupt movement animations (#4358)
OK button in the Settings window has key focus by default (#4368)
It’s no longer possible to cast an Absorb spell on oneself (#4378)
Non-audio files no longer crash the game when the engine tries to play them (#4416)
When there is a ‘NiStringExtraData’ node with MRK value in a NIF model node, only ‘NiTriShape’ meshes starting with “Tri EditorMarker” are ignored instead of the whole node (#4419)
‘RotateWorld’ scripting instruction now rotates objects around the correct axis, while keeping the objects’ initial rotation (#4426)
Some issues with building OpenMW on Windows and macOS were fixed (#4429, #4613)
Applying the console command “Lock 0” to a door or a container now creates an unbreakable lock, like in vanilla Morrowind (#4431)
Actors without any AI packages now properly return to their initial position after combat or pursuit (#4432)
Guards with AiAlarm = 0 no longer attempt to arrest the player character when they observe a crime but no one reports it (#4433)
‘Begin’ and ‘End’ script keywords can now be followed by a comma (#4451)
The default terrain texture no longer shines through terrain texture blending transitions (#4452)
Broken items are now ignored when trying to equip an item via quick key (#4453)
Actors now open doors more quickly (#4454)
Light sources which cannot be carried no longer prevent the AI from auto-equipping shields (#4457)
The handling of idle chances in AiWander packages has been reworked to more closely match vanilla behaviour (#4458)
‘NotCell’ dialogue condition now supports partial name matches (#4459)
Scripted equipment now bypasses most standard equipping restrictions, e.g., those for beast races (#4460)
When a non-player object casts an Open spell, a player crime event is triggered if the player character is detected to ensure vanilla compatibility (#4461)
General-number formatting (“%g”) now works like in vanilla Morrowind and properly handles the fractional part (#4463)
Cancelled AI packages are now removed from the package cache (#4464)
Non-ASCII strings are now properly handled in the content selector and in the ESM reader (#4467, #4653)
Silt striders in abot’s “Silt Striders” mod are no longer rotated by 90 degrees (#4469)
The behaviour of weapon-using non-bipedal creatures has been reworked to make them less helpless in certain situations (#4470)
Actors who are vampires now display their regular record head when no vampire head is found (#4474)
Scripted animations no longer move actors away from their initial position (#4475)
Potential crashes in the quick-keys menu when an item is no longer available in the inventory no longer occur (#4480)
‘Goodbye’ dialogue scripting instruction now disables hyperlinks in dialogue topics (#4489)
‘PositionCell’ scripting instruction no longer tries to add local scripts to scripted items in the teleported player character’s inventory twice (#4490)
Training cap is now limited by the trainer’s modified skill instead of their base skill (#4494)
Crossbow reloading animations now only apply to the upper body (#4495)
Crossbows now use animations for one-handed weapons as a fallback (#4495)
Animations for turning in spellcasting stance are now used (#4496)
Animated meshes without slashes in their full path are now properly classified as animations (#4497)
Scripted spellcasting no longer increases the Alteration skill (#4503)
A potential zero division in the Fatigue calculation has been removed (#4510)
A knocked-down player character can no longer move or be moved in first-person view (#4519)
Some issues with sun specularity in the water shader have been fixed (#4527)
Movement animations without idle-animation fallback no longer trigger idle animations (#4531)
The game now switches between distorted (underwater) and undistorted sound effects based on the camera position instead of the player character’s head position (#4532)
The inventory paper doll is now affected by GUI scaling (#4539)
Items with an ‘OnActivate’ command present in their script (such as “cursed” items) no longer visually disappear when they are picked up in menu mode (#4543)
Creatures no longer incorrectly flee from werewolves (#4545)
Minimum and maximum sound ranges with zero value are now separately reset to their default ranges (#4551)
Non-actor objects can no longer have a dialogue window opened via script (#4553)
Dialogue topics with reserved names, e.g., “Barter” or “Repair”, now behave the same as in vanilla Morrowind (#4557)
Optimiser search for reserved node names is now case-insensitive (#4558)
Pinned windows are now properly updated (#4560)
Fast-travel logic now always depends on the type of the service NPC’s cell instead of the destination cell type (#4563)
The underwater viewing distance limit is no longer broken (#4565)
The player character no longer uses headtracking in first-person view (#4573, temporary workaround for another issue)
The handling of player character turning animations has been improved (#4574)
Several weapon animation inconsistencies during movement in first-person view have been fixed (#4575)
Idle animations are no longer reset in certain situations where they should be continuous (#4576)
If an innocent actor dies from the continuing effects of a player attack, the murder is now also reported if the player has already paid their fine (#4582)
Attack strength is now 0 if the player spams the [Attack] button (#4591)
The incorrect inequality operator “<>” is now interpreted as less-than operator “<” to ensure compatibility with certain mods (#4597)
Picking a stack of gold up in menu mode now grabs the whole item stack (#4604)
Scaling for animated collision shapes is no longer erroneously applied twice (#4607)
Fall damage is no longer erroneously applied twice (#4608)
The pseudo duration of instant magic effects has been adjusted in the spellmaking menu to match vanilla spell cost calculations (#4611)
A zero division occurring in ‘NiFlipController’ nodes without textures has been removed (#4614)
The flickering frequency of light sources and some light-related calculations have been fixed (#4615)
The sneaking offset in first-person view is now also applied when switching to sneak mode in midair (#4617)
Sneaking is no longer possible while flying (#4618)
Recharging enchanted items now always increases the Enchant skill regardless of success or failure, like in vanilla Morrowind (#4622)
NPC record entries Reputation, Disposition and Faction Rank are now loaded as unsigned variables (#4628)
Sneaking stance no longer affects speed if the actor is not actually sneaking (#4633)
‘GetPCJumping’ scripting function has been reworked to match vanilla behaviour (#4641)
“%Name” string replacer can now be used in creature dialogue (#4644)
Force-equipping a weapon now resets ongoing attack animations (#4646)
HUD no longer displays an “item condition” for throwing weapons (#4648)
Levelling up no longer fully restores health but rather applies the gained health points (#4649)
Actors no longer fall from cliffs or run into obstacles when backing down from attackers (#4656)
Enabling collision with ‘ToggleCollision’ scripting instruction (“tcl”) now snaps the player character down to the ground (#4669)
The number of known ingredient and potion effects is now determined by the modified rather than the base Alchemy skill (#4671)
Pitch factor handling for crossbow animations has been streamlined to more closely match vanilla behaviour (#4672)
Journal can no longer be opened while the Settings window is open (#4674)
NPC fast-travel destination records without any data no longer crash the game upon loading (#4677)
Declared but empty script variable lists no longer crash the game upon loading (#4678)
The chance of a successful spell absorption is now multiplicative rather than additive, which is how the magic effect is designed in vanilla Morrowind (#4684)
Calling ‘Say’ scripting instruction with non-existent sound as argument no longer breaks script compilation (#4685)
Creatures that lack unique sounds now make use of fallback sound generator records (#4689)
Loading bars no longer obscure message boxes but are instead moved to the centre of the screen (#4691)

Editor Bug Fixes:

‘Revert’ action now properly updates subviews (#3249)
A native colour picker is now used on all operating systems, fixing major issues on macOS (#3681)
‘Undo’ and ‘Redo’ actions now keep assigned shortcuts (#4110)
Lock status of newly opened subviews is now correctly initialised (#4520)
Instance dragging, which was broken in 0.44.0, has been fixed (#4593)
Skeletons of animated objects are now properly initialised (#4654)
The Colour entry in Light Source records is now displayed as a coloured box instead of an integer number (#4668)

Other:

Windows builds in ‘Release’ mode no longer automatically open a command prompt window (#2490)
Race condition in terrain code has been fixed (#4584)
Skinning and AI optimisations (#4605, #4621)
Support for Rapture3D OpenAL driver has been added (#4606)
Record verifying functionality in OpenMW-CS has been revised (#4643)

Want to leave a comment?

Uncategorized Reimplementation Engine

Status of Godot at GDC 2019

Godot Engine Official

Tue, 26 Mar 2019 01:00:00 +0100

Status of Godot at GDC 2019

Rémi Verschelde, Hein Pieter Van Braam and I went to GDC 2019 in representation of Godot. Until last year, I would go mostly alone. So, how did it go compared to last year?

Game Developers Conference

Before anything, I'm sure that many reading this article don't really know what GDC is.

GDC stands for "Game Developers Conference", and it's the biggest industry wide event for game developers. Almost 100k developers (companies and indies) meet in San Francisco every year in March to showcase their work, make business meetings, socialize, have fun, etc. This event is not mainly about showcasing games, like E3 or Gamescom, but entirely for developers themselves.

There are also talks about technology, production or any other aspect one can think about related to game development.

It's a very big event and you get overwhelmed easily by so much going on at the same time.

Godot at GDC 2019

This is the second year I go to GDC exclusively as Godot representative (before I went as business consultant and, before then, I went representing my own company which no longer exists). This time, Rémi Verschelde (Akien) and Hein Pieter Van Braam (tmm2k) also came, with Ernest Lee (iFire) and Ariel Manzur (punto) occasionally tagging along.

Unlike last year, we decided to focus on meetings more relevant to the project goals and reduced the meetings with companies using or interested in Godot to a minimum. Most of our meetings were with hardware manufacturers, service providers, potential sponsors and education institutions. We also got the chance to meet with key industry people like Nicolas Cannasse, Terry Cavanagh, Ryan Gordon , Alon Zakai, and many others.

So far, we can feel there is a growing excitement about Godot in the industry as more and more developers and companies learn about it and try it, with many games in development and about to be published on Ddsktop, mobile and consoles. Godot is growing at a lightening rate, more than duplicating it's user base every year.

Many companies we met also expressed high interest in dumping their current engine and going for Godot, due to the freedom that open source conveys and the high quality and usability of the engine (their words, not mine :P).

Recognition

But what I'm sure most reading are willing to know is how much recognition did Godot get at the event.

Let me recapitulate my comments from previous years:

2016

The sad truth is that, even after two years of being open source... NO ONE KNOWS ABOUT GODOT

2017

Compared to last year, some more people had heard of Godot, but it's still very largely unknown. We seriously need to consider ways to improve on this

2018

I would probably say most of the industry still has not heard about it, but there is a very significant chunk that did, though.

2019 (This GDC)

From everyone we talked to, it seems at this point a majority of the industry has heard of Godot. Most of those we casually talked to definitely had heard of it and many expressed interest in developing games with it in the future.

From the indie side, most Indies did hear about it, but for company executives Godot remains largely unknown. This, however, seems to be changing because the amount of Godot users within big companies is growing significantly and pushing for it from the inside.

Thanks to this, we surprisingly got a lot of endorsement from developers in large companies, which also is helping us become a more visible and believable option.

As an interesting anecdote, we printed around 800 beautiful metallic pins and distributed them at booths of companies or developers who use or sponsor Godot. At the second day, they had all ran out. They told us people passing by loved them and asked if they had anything to do with it.

Future

I'm excited about how next year will be for Godot. Growth seems fast and steady, so this makes up happy to know we can continue focusing on doing what we do best, improving Godot.

That said, please understand that Godot core development happens thanks to the generosity of our patrons. If you are not yet, please consider becoming one and supporting the project. It takes minutes to set up a recurring donation and any amount is vitally welcome, as it allows more of our most dedicated core contributors to focus solely on Godot. The more donations, the safer the project is and the faster it can mature and grow.

Engine