KDevelop started life as a Linux based IDE created by the KDE group.  In the last year however it has expanded to have beta support for Windows while a Mac OS version is also under development.  They just released KDE 5.1.0 bringing tons of new features to the IDE including LLDB support, cppcheck, OpenCL language support, improved Python language support, in-IDE theme selection, Perforce integration and more.

Details from the release announcement:

LLDB support

We had a great student for GSoC 2016 implementing LLDB support in KDevelop. The end result is that we now have a debugger framework which can be used both for the GDB & LLDB MI communcation. The LLDB plugin teaches KDevelop to talk to the standalone LLDB MI Driver (lldb-mi); so now it's possible to use LLDB as an alternative debugger backend for KDevelop. One interesting thing with LLDB that it's also potentially useful on OS X & Windows for us, especially when the Windows port of LLDB is getting more and more stable.

Analyzer run mode

With 5.1, KDevelop got a new menu entry Analyzer which features a set of actions to work with analyzer-like plugins. During the last months, we merged analyzer plugins into kdevelop.git which are now shipped to you out of the box:

Cppcheck

Cppcheck is a well-known static analysis tool for C/C++ code. Cppcheck is useful for taking a closer look at your source code checking for common programming faults such as out of bounds accesses, memory leaks, null pointer dereferences, uninitialized variables, etc. pp. With the Cppcheck integration in KDevelop running the cppcheck executable is just one click away. KDevelop will pass the correct parameters to cppcheck including potential include paths and other options.

Other analyzers in the pipeline: Valgrind, clang-tidy, krazy2

While the Cppcheck plugin is shipped out of the box, other analyzers are not considered 100% stable yet and still reside in their own repositories. The clang-tidy plugin looks super promising (another static analysis & refactoring tool for C/C++) as it really easy to use from the command-line and thus easy to integrate into our IDE. We plan to import more of those analyzers into kdevelop.git so they'll be part of the kdevelop tarball and are thus available to you without having to install yet another package.

Initial OpenCL language support, CUDA support upcoming

Since 5.1 KDevelop is able to parse code written in the Open Computing Language (OpenCL). The OpenCL language support inside KDevelop is backed by our Clang-based language support backend and thus just required minimal changes in KDevelop to start supporting it. Support for handling NVidia's CUDA files will be part of 5.2 instead. Stay tuned.

Note that for KDevelop to detect .cl files as OpenCL files, an up-to-date shared-mime-info package which contains this patch is required. Alternatively, you can add the mime type yourself by creating the file /usr/share/mime/text/x-opencl-src.xml with appropriate contents and re-running update-mime-database yourself.

Improved Python language support

Python language support now supports Python 3.6 syntax and semantics. In addition, thanks to the work of Francis Herne, various long-standing issues in the semantic analysis engine have been fixed:

• Loops and comprehensions infer types correctly in many more cases, including on user-defined types with __iter__ and __next__ methods.
• Type guessing works for arguments named by keywords (not only **kwargs), and works better for class/staticmethods.
• Property accesses get the return type of the decorated method.
• Types are inferred correctly from PEP-448 syntax in container literals.
• Unsure types are handled in subscripts and tuple unpacking.
• Uses are found for __call__() and __get/setitem__().

These improvements were accompanied by cleaning up dusty code, making future changes simpler as well.Furthermore, our style checker integration has been rewritten, making it much faster and easier to configure.

Perforce integration

Thanks to Morten Danielsen Volden we now have Perforce integration in kdevplatform.git, which can be used freely starting with KDevelop 5.1. Perforce is a commercial, proprietary revision control system. The Perforce integration in KDevelop simply works by running a local version of the p4 executable (needs to be installed independently of KDevelop) with appropriate parameters. This is similar to how KDevelop integrates with other VCS, such as Git & Bazaar.

Color scheme selection inside KDevelop

It is now possible to select the current color scheme from within KDevelop, a feature which has been requested several times in the past. This is especially useful for when KDevelop is run under a different desktop environment than KDE Plasma, where the color scheme settings may not be easily accessible.

Ongoing support for other platforms

We're continuously improving the Windows version of KDevelop and we're planning to release a first KDevelop version for OS X soon (yep, we're repeating us here, please stay tuned!). For the Windows version, we upgraded the KF5 version to 5.32 and the LLVM/Clang version to 3.9.1.

KDevelop is completely free and available for download here.

One thing many programmers struggle with is finding art for their game.  There is a new site, The Open Pixel Project that aims to make life somewhat easier for people.  It’s essentially a community for publishing, requesting and downloading pixel art graphics.  It just went live and there are already hundreds of tiles and sprites available, all under the Creative Commons Zero license, which is about as liberal as they come.

I did a quick hands-on video on the Open Pixel Project available below.

The only immediate recommendation I have, beyond fixing the png links, is that they publish to a much higher resolution.  It’s easy to go down in resolution, but not so easy going up!  It will be interesting to see how this project turns out.

Another Unity patch has arrived, this one version 5.5.2p4, once again entirely composed of bug fixes. 

New fixes in this patch:

• (851523) - Android: Fixed incorrect dangerous permissions dialog behavior when the app was suspended while the dialog was on screen.
• (888274) - Android: Fixed an issue where ApplicationId was missing from AndroidManifest.xml in Gradle builds.
• (887998) - Animation: Fixed Assert Thread::CurrentThreadIsMainThread() from Animator::IsHuman() when run in a job thread.
• (884643) - Animation: Fixed a crash when re-enabling GameObject that was running a Playable.
• (884472) - Asset Pipeline: Fixed a crash that occurred when loading the same asset both synchronously and asynchronously simultaneously.
• (864237) - Graphics: Fixed an issue with Assert "Texture aux property (unity_SpecCube0_HDR) should never be a built-in name!".
• (851265) - Graphics: Fixed a crash when switching from DX12 to DX11 graphics API in the Editor.
• (887912) - IOS: Added support in order to enable auto-rotation while broadcasting using ReplayKit.
• (788515) - iOS: Fixed Airplay mirroring mode when using Open GLES.
• (876169) - Particles: Fixed a NullReferenceException, when Inherit Velocity was set to less or more than 0 and Rigidbody2D was set to Dynamic.
• (890937) - Physics 2D: CapsuleCollider2D now correctly calculates its mass when using auto-mass.
• (888302) - Scripting: Fixed a coroutine crash in Coroutine::CompareCoroutineEnumerator.
• (881103) - Shaders: Fixed an internal error on a GLSL/Metal shader compiling corner case.
• (886841) - VR: Fixed a subtle timing bug on Rift that could cause very minor view stuttering in certain situations.

The patch is available for download here.

Phaser 2.7.4 CE was just released.  Phaser is a HTML5 based 2D game engine.  If you are interested in learning more, we have a complete Phaser with TypeScript tutorial series available here on GameFromScratch.  You may be wondering about the CE tag, this simply refers to community edition.  The primary developer Photon Storm turned over development of Phaser 2.x to the community, while they focused on the next release.

Details from the release announcement:

The new features include:

• New method Phaser.Math.hypot() calculates the length of the hypotenuse spanning two given lengths
• Added copyBitmapData function to Phaser.Bitmap
• Added noPause logic to src/input/Pointer.js
• Added timeStep parameter pass to state.pauseUpdate call at src/core/Game.js
• Added tileOffset (Phaser.Point) property to Phaser.TilemapLayer. This allows offsetting layer positions in a way that plays well with the camera and Arcade physics. Also, the offsetx and offsety properties are now read from the layer properties of Tiled maps.

And updates include fixes to FireFox image caching, a new yarn lock file, a travis build script, lots of TypeScript defs updates, new Text fixes, JSHint fixes and loads more.

Phaser is available for download on Github.

The seminal role playing game engine, RPG Maker has just been released on Linux.  With the MV release, RPG Maker both runs on and can target the Linux platform.

From the announcement:

First, RPG Maker MV is now for Linux!

This means you can both use it on our Linux computer to make games, and deploy to Linux for other people to play from PC, Mac, or Linux editions of RPG Maker MV.

This update brings a bigger audience, both for RPG Maker MV, AND for its users. Your games can now be played by more people than ever.

Along with the Linux announcement, they also announced the release of RPG Maker MV Tools, add-ons available as DLC that extend the functionality of RPG Maker.  From the same announcement:

But we didn’t even stop there. We are also introducing RPG Maker MV Tools, DLC that adds new toolsets to the RPG Maker MV editor. We added the MV Tools menu into the latest update, and the first MV Tool, SAKAN -Tileset Builder-, is launching this week.

SAKAN -Tileset Editor- is exactly what it says on the tin. This tool will let you quickly cut together tilesets using pieces of existing tilesets, a whole bunch of extra pieces added in SAKAN, or even possibly make your own.

While it won’t include all the power something like Photoshop does for making tiles, it will make organizing a tileset and making small edits faster than ever before, and right from RPG Maker MV itself, making your workflow simpler and easier.

RPG Maker MV is currently on sale on Steam.

Unity have released another patch, this one bringing the engine to version 5.4.5p1.  Composed of several fixes including:

Improvements

• (815861) - UI: CanvasRenderer::OnTransformChanged will not be called when object is inactive.

Fixes

• (837483) - Android: Acquire context on focus before notifying player.
• (743739, 887242) - Android: Fixed a crash in WebStreamDecomp after a long sequence of reading asset bundles.
• (870185) - Animation: Fixed root rotation when importing a humanoid animation that used the "Copy From Other Avatar" feature.
• (879675) - Core: Fixed job system ending up with high CPU usage in certain circumstances eg. using UnityWebRequest.Send() in Editor after exiting Play mode.
• (none) - Editor - Other: Editor internal resources can now be rebuilt in 5.4.
• (728324) - Graphics: D3D9 - Make sure that internal resolves don't result in a drawn pixel – i.e single white pixel when using deferred mode.
• (890915) - Graphics: Fixed a crash in GetBuildUsageTagFromAssets that was triggered by pro0ject that had ShaderVariants.
• (864237) - Graphics: Fixed an issue with Assert "Texture aux property (unity_SpecCube0_HDR) should never be a built-in name!".
• (863954) - Graphics: Fixed forward-only objects being rendered into Depth/DepthNormals textures multiple times when they had multiple submeshes and deferred shading was used.
• (849424) - Graphics: On DirectX, avoid presenting a fresh-black frame whilst performing screen resizing.
• (863625) - Graphics: Set the ambient probe for the deferred reflections pass to fix a difference between graphics jobs and non-graphics jobs rendering.
• (870973) - IL2CPP: Fixed a race condition on iOS during method initialization.
• (861046) - iOS: Added support in order to enable auto-rotation while broadcasting using ReplayKit.
• (875180) - iOS: Removed extra notification sent on application launch.
• (none) - Metal: Fixed an issue with setting DontCare load flag when running multithreaded.
• (883312) - Physics: Fixed a crash caused by changing the value of the configuredInWorldSpace flag on a Joint attached to an inactive GameObject.
• (888302) - Scripting: Fixed a coroutine crash in Coroutine::CompareCoroutineEnumerator.
• (881103) - Shaders: Fixed an internal error on a GLSL shader compiling corner case.
• (750307) - Shaders: Fixed advanced blend operations by requiring the shaders to be decorated with UNITY_REQUIRE_ADVANCED_BLEND(mode) declaration.
• (863256) - Sprites: Fixed an issue where OverrideGeometry on instantiated sprites produced differing results in the Editor and Standalone.
• (none) - Tizen: Resolved a crash that occurred when an app tried to exit.
• (873678) - UI: Fixed an occasional masking issue when using deferred rendering path on Linux.
• (856734) - UI: Fixed a curve preview crash not updating when points changed but bounds did not.
• (856381) - UI: Fixed scrollrect performance being slow when it had a lot of content.
• (880565) - UnityWebRequest: Fixed Editor freeze when exiting play mode with active UnityWebRequest with custom download handler script.
• (876027) - UnityWebRequest: Fixed high CPU when WebRequest with custom download handler script was aborted.
• (879749) - UnityWebRequest: Fixed redirect in editor when not in play mode.
• (850239) - VCS: Fix for editor not checking out scene file before first write in freshly loaded project.
• (886841) - VR: Fixed a subtle timing bug on Rift that could cause a minor view stuttering in certain situations.

As always, the patch is available for download here.

Construct is a 2D game engine that provides a visual programming interface and compiles down to HTML5.  Details of the upcoming release were announced back in February, today a beta is available to try.  With the move to Construct 3 it has moved entirely to be browser based, requiring the Chrome browser.

Details of the beta:

What the beta includes

Our aim is to get lots of testing done and receive general feedback. Construct 3 is also not on sale yet. So for the public beta we are making the Free Edition of Construct 3 available. This has limits and several features are unavailable. However we will be making the fully-licensed version available for one week during the Newgrounds Gamejam from May 15th-21st! We aim to have subscriptions on sale when that week ends, by which time we should have found and fixed any last issues relating to subscriber-only features.

How to use the beta

Construct 3 requires Chrome 57+. This recently became the lastest stable version. If your system hasn't updated yet, you can usually manually update by opening the Chrome menu and selecting Help → About Google Chrome. On mobile, check for updates in the Google Play Store. If you still can't update, try installing Chrome Beta.

You can log in to Construct 3 (and the construct.net website) with the same username and password you use here on Scirra.com.

We'd like to point out one especially useful feature of Chrome that makes it easier to use Construct 3: in the Chrome menu, try selecting More tools → Add to desktop (or Add to shelf on Chrome OS, or Add to homescreen on mobile). Be sure to tick Open as window if the option is there. This creates an icon for Construct 3 on your desktop or home screen that lets you use Construct 3 like any other app. It also removes the browser address bar and UI, which saves space on your screen for more of Construct 3! And don't forget Construct 3 works offline too, so the icon will continue to work wherever you go or whatever happens to your Internet connection.

Let me at it!

Ready to go? We're launching a whole new website over at Construct.net. It's still a work in progress, but we'll be updating it regularly throughout the beta. If you want to jump directly to Construct 3, just click the link below.

editor.construct.net

Massive lighting improvements
5.6 includes the Progressive Lightmapper preview, which provides immediate feedback when trying out different lighting scenarios, and much faster iteration, compared to the current Enlighten solution. 5.6 also offers Light Modes, which allow for various ways of mixing real time and baked lighting for static and dynamic objects.

Improved graphics performance
GPU Instancing which enables new kinds of effects where many similar objects are needed at a very low performance cost, has been improved with support for Procedural Instancing. And, with the addition of Compute Shaders for Metal, you can now add more details to your games by tapping into the raw power of the chipsets on Apple iOS and macOS.

Vulkan support
Vulkan support brings increased speed while reducing driver overhead and CPU workload; this leaves the CPU free to do additional computation or rendering and saves on battery life for mobile platforms.

Massive update to Particle System
5.6 greatly extends the range of particle effects to give more options and control to the user. This update also significantly improves Particle System performance.

New Video player
A new multi-platform video player enables playback of 4k video allowing you to build 360 degrees videos VR experiences.

Navigation system improvements
Improved AI and Pathfinding tools–also referred to as the NavMesh system–expand the possibilities to manipulate multiple nav meshes and agents. And, new tools for procedurally generated or dynamically loaded content enable a whole new set of use cases and gameplay options for character navigation.

New 2D tools and improvements
Unity 5.6 adds a whole set of 2D features that give you more control and make it easier to create complex 2D objects. New features for 2D physics enable new kinds of gameplay and effects, including fully featured particle effects interacting with 2D objects.

TextMesh Pro
One of the top performing tools on the Unity Asset Store is now available for free to users of 5.3+ and will be soon be natively integrated into Unity. TextMesh Pro features advanced text rendering with dynamic visual text styling, along with greatly improved control over text formatting and layout.

Performance Reporting and debugging improvements
In addition to exception reports, Performance Reporting now collects native crashes for iOS. Physics debug visualization and profiler improvements make it easier to find the source of performance issues in the game.

New platforms
Seamlessly publish to Facebook Gameroom, as well as Google Daydream and Cardboard for Android and iOS. Nintendo Switch support is also available now.

Unity Collaborate (Beta)
We added new options when publishing changes for finer control of your Collaborate projects.

Experimental support for WebAssembly
In 5.6 we bring experimental support for WebAssembly, a new cross-browser technology designed to help improve the Unity WebGL experience.

There is a new release of the Defold game engine, release 1.2.101.  Defold is a free, cross platform 2D game engine.  If you are interested in learning more about the Defold engine, we have a complete tutorial series available here.

Details of the new release:

Engine

• DEF-2574 - Added: Efficient WebP compression for PVRTC and ETC1
• DEF-2582 - Added: screen_x/screen_y and screen_dx/screen_dy fields for multi touch input.
• DEF-2595 - Fixed: Profile counters Lua.Ref and Lua.Mem in web profiler.
• DEF-2522 - Fixed: Support for detection of require with same line access.
• DEF-2541 - Fixed: Issue with Android native extension library order.
• DEF-2585 - Fixed: Some buffer documentation fixes.
• DEF-1408 - Fixed: Argument verification for render.draw and render.render_target.
• DEF-2428 - Fixed: Model UVs can now be outside [0..1].
• DEF-2567 - Fixed: Resources was incorrectly excluded if shared between excluded/bundled collectionproxies.
• DEF-2569 - Fixed: On iOS UIScreen main screen bounds didn't update when rotating the screen.

They also described in more detail the new WebP compression option:

Efficient WebP compression for PVRTC and ETC1

When selecting WebP compression for compressed texture formats (PVRTC1 and ETC1), the WebP compressor has up until now just been compressing the texture file as a raw LUM8 texture (an array of bytes). We have greatly improved this compression by transforming the compressed texture format data into data more suitable for WebP image compression using an internal intermediate format. This is then retransformed back into the compressed texture format when loaded by the run-time. This has shown an average improvement of anything between 40-60% over compressing with ZLib (or WebP with LUM8).

You can read more details about this release here.

Construct 3 is a recently released cross platform 2D game engine with a visual programming interface.  We very recently did a completes hands-on with Construct 3 video if you are interested in learning more about this release.  Today Scirra released their plugin SDK for Construct 3 enabling you to extend the functionality of the game engine using JavaScript.

Details of the SDK release:

Welcome to the Construct 3 plugin SDK forum! Here we'll be providing information and support to third-party plugin developers interested in working with Construct 3.

Note you must use Construct 3 r15 or above for the SDK to work properly.

Current state of the SDK
The full set of editor SDKs we plan to support are very broad and involve a very large API surface. To approach this large task, we are going to gradually roll out the SDK in phases.
At first, the plugin SDK only supports single-global plugin types. (That means plugins that do not draw to the Layout View.) We hope to expand on this to drawing plugins, behaviors, effects and editor addons in future.

SDK documentation
We have provisional SDK documentation available here:
https://www.scirra.com/doc/c3sdk/index.html
The SDK documentation will eventually be hosted on construct.net, but the new documentation system isn't ready yet. Currently the documentation is hosted on scirra.com but likely will be moved in future.
This should help get you going with developing Construct 3 addons. Again this only covers single-global plugins; we'll update the documentation accordingly as we roll out new features and make new APIs available.

Kotlin is a JVM powered programming language created by JetBrains, the people behind popular developer IDEs such as IntelliJ, WebStorm, CLion and ReSharper.  Kotlin offers 100% interop with existing Java code, while offering better performance and more concise code.  The recently released Kotlin 1.1 enabled JavaScript support giving Kotlin the ability to run in the browser.  Today they went one step further with the announcement of Kotlin/Native.  Kotlin/Native is a compiler that creates a stand alone executable with no need for a Java Virtual Machine at all.  Built over the LLVM technology suite, Kotlin/Native is in early technology preview for Mac OS, Ubuntu Linux, iOS and Raspberry Pi meaning Windows based developers are currently out of luck, with the following being noted:

Due to significant difference in exception handling model on MS Windows and other LLVM targets, current Kotlin/Native may not produce executables working on MS Windows. This situation could be improved in upcoming releases.

Details of Kotlin/Native from the announcement blog:

Kotlin/Native is another step toward making Kotlin usable throughout a modern application. Eventually, it will be possible to use Kotlin to write every component, from the server back-end to the web or mobile clients. Sharing the skill set is one big motivation for this scenario. Another is sharing actual code.

Our vision for inter-platform code reuse is the following: one can write entire modules in Kotlin in a platform-independent way and compile them for any supported platform (currently these are Kotlin/JVM, Kotlin/JS and the upcoming Kotlin/Native). We call these common modules. Parts of a common module may require a platform-specific implementation, which can be developed individually for each platform. Common modules provide a common API for all clients, but other (platform-specific) modules can extend this API to provide some exclusive capabilities on their platform.

Note that we do not intend to make arbitrary Kotlin/JVM programs runnable on Kotlin/Native or Kotlin/JS. It would be equivalent to implementing another JVM, which is both a lot of work and a lot of limitations for the runtime. We are going another way: providing a common language for all platforms while enabling creation of common libraries through seamless interoperability with platform code.

In moving from the JVM to native code, that does lead to the question of how memory is managed.  This is also addressed in the blog post:

Kotlin/Native is designed to potentially enable different memory management solutions for different target platforms. For example, in the future it may make sense to have a tracing GC for server/desktop platforms, while ARC makes a lot more sense on iOS. Some platforms may only need manual memory management, and get an even smaller Kotlin/Native runtime in return.

This Technology Preview features automatic reference counting with a cycle collector on top, but what the final memory management solution(s) will look like is unknown at this point.

Kotlin/Native is open source and available on github under the Apache 2 open source license.

A very early iteration, DLScript for Godot was just released today.  What exactly is DLScript?  The description from the Github project is probably the best definition:

DLScript stands for Dynamic Linking Script. It's a module that enables you to use shared libraries, which are dynamically linked, for scripting. DLScript was originally named "cscript" because it exposes a C API, but people thought it was related to C#, which is sometimes abbreviated as "cs". You can build these libraries with C++ as well as C, D, Rust, or any other language that supports C linkage and creating dynamic libraries.

One of the immediate powers to DLScript is the ability to link other shared libraries or to use critical code without recompiling the engine.

Currently there are C++ bindings that make developing for Godot with C++ easier, but DLScript is not limited to C++.

There is a much more detailed blog post, with usage instructions available here:

So what is DLScript?

DLScript is a module for Godot that adds a new "scripting language" to it. I put "scripting language" in quotes because it's not a language.

A "script" in Godot is defined as something that has methods, properties and signals. It also offers a way to use these things (calling methods, get and set properties...). Instead of having a text file representing these things (like a GDScript file for example), DLScript uses shared libraries.

In some ways, shared libraries have things in common with scripts.

• you can load them
• you can unload them
• you can load function symbols
• you can call functions

A method in a DLScript is just native machine code. You can call third party libraries from that code as well. You can call GDScript functions from a DLScript and vice versa. When C# will be supported optionally, you'll be able to call C# code as well.

So essentially DLScript is a new module for Godot that acts as a go between of the Godot Scripting API ( and not the entire C++ API!) and your own code, which is loaded at runtime in library form.

Cocos Creator is a full game engine and editor powered by JavaScript created by the team behind the Cocos2d-x project.  If you want to learn more about the Cocos Creator project be sure to check out our hands on video.  Today Cocos Creator learned a new trick in the form of C++ and Lua support for creator alpha zero.  This doesn’t actually add C++ or Lua language support to Cocos Creator editor.  Instead it’s a pair of new features.  First Cocos Creator is now capable of exporting projects in .ccreator file format.  Second they have provided a reader enabling Lua and C++ Cocos2d-x projects to read and use ccreator files.  Essentially this enables Cocos Creator to be an editor for your C++/Lua Cocos games.  Loading the scene in C++ is simple as illustrated by this code:

#include"reader/CreatorReader.h"voidsome_function(){creator::CreatorReader* reader =creator::CreatorReader::createWithFilename("creator/CreatorSprites.ccreator");// will create the needed spritesheets + design resolution
    reader->setup();// get the scene graph
    Scene* scene = reader->getSceneGraph();// ...and use itDirector::getInstance()->replaceScene(scene);}

Details from the Cocos Creator forum:

What's C++ and lua support for creator

It includes two parts:

• First, it is a Cocos Creator plugin that can export scenes generated by Cocos Creator into .ccreator files.
• Second, it has a reader that can parse .ccreator files. The reader can be used in cocos2d-x c++/lua project.

Download

There are two ways to get the plugin

• clone the repo29
• download the zip file8

The Godot Engine is inching closer to the major 3.0 update and a recent progress report illustrated several new features that have been added to the engine.  If you are currently unaware of it, Godot is an open source fully featured 2D/3D game engine with a complete editing environment.  You can learn how to use Godot with our comprehensive tutorial series available here. 

Several new features have just been added, in varying degrees of completion, including:

• Web Export an experimental exporter to WebAssembly and WebGL enabling you to publish your Godot game to run in browsers, although only the most current Firefox and Chrome browsers are currently supported
• GDNative was recently announced as DLScript but was thankfully renamed to the much more expressive GDNative.  This provides a bridge between the Godot engine and native code without requiring any recompilation
• New Particle System that works entirely on the GPU enabling a huge number of particles, many more than the current implementation.  The new system also allows tighter control, curve based tweaking, mesh based particles and more options for particle emitters, as seen in the image to the right.

Godot 3.0 alpha will be released soon.  If you are interested in playing with the new features, you will instead have to build Godot from the current master branch.  For details on how to build Godot using Visual Studio refer to this tutorial.

For more details on Godot 3.0, be sure to check the Godot engine blog post.

Articy:draft is a unique tool aimed at game designers for visually creating and organizing game content.  In many ways it is like a version of Visio created specifically for game developers handling such tasks as conversation trees, game flow, inventory, characters and more.  Additionally with the most recent release you can directly consume your data in the Unity game engine.  As the title suggests, articy:draft 2 SE is currently on sale for 95% off on the Bundle Stars website.  Available for less than $5 USD instead of the usual $200 price tag, this represents a pretty massive discount.  Act fast though, the sale ends on April 14th.

-------------------

EDIT – Be aware of the following limitation!

This version is for non-commercial use only. You can acquire an upgrade for commercial usage via Steam.

I am unable to determine the upgrade price for the commercial edition!

If you’ve never heard of articy:draft, be sure to watch the video below for more information!

Ogre3D is a popular C++ based open source 3D renderer and scene graph.  It has been used to make several games including Torchlight 1 and 2, Dungeons, Ankh 2/3 and more.  The 1.10 release adds several new features including the ability to target the browser via Emscripten, a better build system, new documentation, better renderers and more.

Details of the release:

• Python bindings as a component
• vastly improved GL3+/ GLES2 renderers with GL3+ now being the recommended choice on *nix systems
• Bites Component for rapid prototyping of applications
• Emscripten platform target– supporting Web Assembly & WebGL2
• improved build system, automatically fetching all required dependencies.
• A new HLMS Component implementing physically based shading
• Unified Documentation: the API docs, the manual and some Wiki pages have been merged and are now managed with Doxygen. As a consequence, the Wiki is outdated when it comes to OGRE 1.10. If you find something particularly missing, feel free to submit an additional tutorial.

Despite the amount of new features OGRE 1.10 provides the smoothest upgrade experience between OGRE releases so far. See the API/ ABI change overview for OGRE 1.7 – 1.10that is kindly provided by ABI-laboratory.
Note that some components are marked as [BETA]. This does not mean that they are likely to crash, but that we can not give any API stability guarantees for them right now. You should expect their API to change without a deprecation period while we we iron the warts out as the Component get more exposure.

In turn for the core components, our deprecation list has grown considerably. You can keep using these APIs for now, as we intend to support them until OGRE 1.11. Speaking of which; to make OGRE releases predictable, we will switch away to a feature based to a time based release model for the 1.x branch. This means that you can expect OGRE 1.11 in April 2018.

You can read more about the release here.

Cocos2D-x 3.15 was released today.  Cocos2D-x is a cross platform 2D game framework written in C++.  If you want to learn Cocos2D-x we have a complete tutorial series available here.  This new release updates a number of the underlying dependencies as well as adding support for Android Studio, Google’s version of IntelliJ IDEA which recently received C++ support.

Details from the release notes:

Highlights

• full Android Studio supports: include editing, compiling and debugging c++ codes: doc
• audio engine uses tremolo and MP3 Decoder Library to decode audio files on Android: high performance and more adaptable to different Android devices
• WebSockets and SocketIO supports SSL
• AssetsManagerEx is more stable
• update Spine runtime to v3.5.35
• update flatbuffer to v1.5
• remove support for Windows 8.1 store and phone
• update OpenSSL to v1.1.0
• remove linux 32-bit support

Cocos2d-x is available for download here.

In beta for a couple of years now, Silicon Studios have just released Xenko Game Engine.  If you are interested in learning more, we did a complete tutorial series back when it was known as Paradox 3D.  As part of the release pricing information has finally been announced.

Until July 31st, the Pro version will be available for free.  Xenko is a cross platform 2D/3D game engine with an editor and full Visual Studio integration.  The primary language is C#.  The personal release requires a splashscreen and has a $200K USD revenue limit.

We did a hands on video detailing the new release below and embedded below.

Unreal Engine have been a bit quite on releases lately, however they just dropped a preview of their upcoming massive release.  Of course it is just a preview so I wouldn’t recommend using this release in a production environment.  There are just a massive number of improvements and new features in this release however including an all new audio engine, the addition of volumetric fog, a new cloth simulation, HTML5 support of WebAssembly and much more.

Details of the release from the Unreal Engine forums:

• Animation/Physics Updates:
  • A new clothing solver from Nvidia called NvCloth replaces APEX. This new solver gives more control over simulation and it is pretty close to the core solver of the previous APEX solution so should behave largely the same, although there are a few slight behavior changes and some extra exposed parameters for inertia settings. We now also always simulate clothing in local space - this gives us the benefit of only having one transform path through the solver and allows external inertia to be tweaked in much finer detail.
  • Vertex & Texture Painting on Skeletal Meshes has been added.
  • Vertex & Texture Painting on Static Meshes has been overhauled to improve usability.
  • A Spline IK node has been added to Animation Blueprints; useful for character spines.
  • Animation Modifiers are a new type of class which allow developers to apply a sequence of actions to a given animation sequence or skeleton. They should always implement OnApply and OnRevert to allow modifying data and remove previously applied changes.
    • Accessing Animation Modifiers is done through a new tab in the skeleton and animation editor.
    • A new set of functions to access specific animation data has been added, they’re contained by a new editor-only function library (Animation blueprint Library).
  • The RigidBody node supports simulating a physics asset inside an Animation Blueprint. This is similar to AnimDynamics, but instead of specifying a node per bone a single node is used for the entire skeletal mesh. Performance has also been improved.
  • PoseDriver has been improved, including more control over selected and modified bones, curve control, and UI improvements.
  • The ability to have Kinematic bodies with simulated parents has been added, allowing effects like a kinematic hand attached to other objects.
  • The 'Look At' node has been improved to be usable relative to a bone or socket.
  • Capsule collision can now be imported from an FBX file. You now use the ‘UCP’ prefix on a capsule poly mesh, and it will be removed on import, and replaced by a corresponding capsule collision shape.
  • The ability to store asset viewer profiles on a 'shared' or 'local' level has been added. This allows team to have a shared set of profiles which can be used as a unified scene to assess art assets. Shared profiles are stored in DefaultEditor.ini and will require you to check out or make it writable.
  • Added support to import Retarget Base Pose. A new option allows you to import the pose from Pose Asset.
  • Animation Export improvements support run-time retargeting results and animation that applies Post Process Graph.
  • Add ‘GetMaterialFromFaceIndex’ function for components retrieves the actual material after performing a complex line trace. This is supported for StaticMeshes, ProceduralMeshes and BSP.
  • The Play Montage Blueprint is an Async node, that can be used in any Blueprint logic to play Anim Montages, and have easy access to some of the callback events it provides.
• Rendering Updates:
  • Volumetric Fog is now supported. Please follow this link to provide feeback.
    • Volumetric Fog controls are on the Exponential Height Fog Component.
    • Localized fog density can be controlled via particles. To do so, create a Material, set the material's domain to Volume, and apply it to a particle emitter. The volume material describes Albedo, Emissive and Extinction for a given point in space. Albedo is in the range [0-1] while Emissive and Extinction are world space densities with any value greater than 0. Volume materials currently only work on particles, and only positions inside the particle's radius are valid.
    • Each light has a 'Volumetric Scattering Intensity' and 'Cast Volumetric Shadow' setting. (fast-changing lights like flashlights and muzzle flashes leave lighting trails. Disable volumetric fog contribution on these lights with 'Volumetric Scattering Intensity' set to 0)
    • Supported lights include:
      • A single Directional Light, with shadowing from Cascaded Shadow Maps or static shadowing, with a Light Function
      • Any number of point and spot lights, with dynamic or static shadowing if 'Cast Volumetric Shadow' is enabled.
      • A single skylight, with shadowing from Distance Field Ambient Occlusion if enabled
      • Particle lights, if 'Volumetric Scattering Intensity' is greater than 0
    • Not currently supported:
      • Precomputed global illumination
      • Shadowing of Stationary skylights
      • IES profiles and Light Functions on point and spot lights
      • Shadowing from Ray Traced Distance Field Shadows
      • Shadowing from the volumetric fog itself
    • The GPU cost of Volumetric Fog is primarily controlled by the volume texture resolution, which is set from the Engine Shadow Scalability level. Use 'profilegpu' to inspect this cost.
  • Distance Field Lighting has been optimized for current generation consoles and mid-spec PC.
    • The Global Distance Field is much faster to update when a Movable object changes.
    • New project settings ‘Eight Bit Mesh Distance Fields’ and ‘Compress Mesh Distance Fields’ which significantly reduce memory requirements when enabled
    • Runtime cost has been reduced between 30-50%
    • Mesh Distance Field generation uses Intel’s Embree ray tracing library, for a 2.5x speedup
  • Vertex Interpolator nodes have been added to the material graph. These nodes offer better control for value interpolation between vertex and pixel work. These are intended as a workflow improvement, there are no changes to interpolator limits nor will shaders change. The feature is compatible with Customized UVs and will pack results together.
  • Post processing now supports Image-based (FFT) convolution for physically realistic bloom effects in addition to the existing bloom method. This new post processing feature is designed for use in cinematics or on high-end hardware.
    • Image based Convolution adds new control parameters to the existing Lens | Bloom section found in Post Process volumes.
    • In using a new texture to serve as the kernel image, it is important to ensure that the full image is present on the gpu and available at full resolution. Two settings are required to ensure this:
      • Mips Gen Setting should be set to NoMipmaps
      • Texture option Never Stream should be selected.
• Core Updates:
  • Garbage Collection improvements make collection times twice as fast.
  • Removed support for Visual Studio 2013. VS 2015 and VS 2017 are currently supported.
• Tools Updates:
  • Localized String Tables are now supported. These provide a way to centralize your localized text into one (or several) known locations, and then reference the entries within a string table from other assets or code in a robust way that allows for easy re-use of localized text. String Tables can be defined in C++, loaded via CSV file, or created as an asset.
  • Color Grading improvements include polished UI, a new HSV mode, dynamically changing the min/max value of sliders using Ctrl+drag, and a new Reset button.
  • The Asset Audit Window, built on top of the experimental Asset Management Framework, can be used to audit disk size, memory usage, and general asset properties for many assets at once. It is a specialized version of the Content Browser, and can be accessed from the Window->Developer Tools menu, or from the right click menu in the Content Browser or Reference Viewer. Once you have opened the window assets can be added using the buttons, and platform data loaded out of cooked asset registries can be loaded using the platform drop down.
  • Updates to VR Mode's UI and interation include a new asymmetrical controller setup where you can change which controller has the interaction laser in Editor Preferences > VR Mode, and an updated Radial Menu with access to all major editor features and UI panels. Additional updates include smoothed interaction lasers and improved teleportation.
  • VR Mode now has access to the Sequencer Editor
  • Physics simulation is now possible in VR mode
  • Smart Snapping in VR Mode uses the bounds of your object to align to other actors in the scene, enabling you to exactly fit them together without needing to build modular assets with a grid in mind.
• Sequencer Updates:
  • Shot enhancements include pre/post roll and hierarchical bias.
  • UI enchancements include re-sizable tracks and audio thumbnails now render the peak samples with an inner RMS curve
  • Material Parameter Collection Tracks have been added
  • Various minor improvements including Binding Override improvements, additional event receivers on Level Sequence Actors, event ordering, and more.
• Audio Updates:
  • The new Unreal Audio Engine is available for testing on PC, Mac, iOS, and Android. It is not enabled by default in 4.16 as there is continued work on implementing backends for console platforms, Linux, and HTML5, as well as stability and performance improvements, especially on mobile platforms. It is enabled for each platform by changing the AudioDeviceModuleName ini setting in the platform’s Engine.ini file:
    • For PC, in WindowsEngine.ini set AudioDeviceModuleName=AudioMixerXAudio2
    • For MacOS, in MacEngine.ini set AudioDeviceModuleName=AudioMixerCoreAudio
    • For iOS, in IOSEngine.ini set AudioDeviceModuleName=AudioMixerAudioUnit
    • For Android, in AndroidEngine.ini set AudioDeviceModuleName=AudioMixerAndroid
  • The Steam Audio SDK has a fully-integrated implementation using the capabilities of the new Unreal Audio Engine. Click here for more details.
  • The new Synthesis Plugin contains two new real-time synthesizers written using the new Unreal Audio Engine’s “SynthComponent” class to implement a fully-featured subtractive synthesizer as well as a real-time granulator. It also contains a host of new DSP source and submix effects for use with the new Unreal Audio Engine.
• Mobile Updates:
  • Android 23 (and above) now supports runtime permissions. Permissions are requested at runtime for the required ones used by the engine, and there is an Android Permission plugin to check for permission (Check Permission BP node), request it (AcquirePermissions BP node), and get the response (OnPermissionsGrantedDynamicDelegate). This is only necessary if Android Target SDK is set to 23 or above, otherwise any permissions in the Android Manifest are granted as usual.
    • 4.16 requires Android SDK 23 or higher to be installed. Please use the SDK manager to install it if you have an earlier install. Also, in Android SDK project settings, please change your Android SDK API Level from “matchndk” to “latest”. This will use the newest installed SDK found in your Android SDK platforms directory. There is no need to change the NDK API Level; “android-19” is correct to allow installing your APK on Android version prior to Lollipop (Android 5.0); setting this higher will require Android 5.0+.
  • Improved Virtual Keyboard support on Android (Experimental). A new option in Project Settings > Platforms > Android > APKPackaging enables the improved virtual keyboard. This replaces the dialog input box. When this option is enabled, users should bind event handlers to FGenericApplication::OnVirtualKeyboadShown and FGenericApplication::OnVirtualKeyboardHidden.
  • Mobile performance improvements for Slate and UI rendering. Set the console variable Slate.CacheRenderData=0 to enable the option for Invalidation Panels to cache only widget elements, which improves texture batching and reduces draw calls.
  • HTML5 support for WebAssembly (WASM). This feature comes from Mozilla's latest Emscripten toolchain (v1.37.9) and reduces app download size, startup times, memory consumption, and improves performance.
  • HTML5 support for WebGL 2. This provides better rendering performance, visual fidelity, and more rendering feature sets.
• VR Updates:
  • Unified Console Commands across VR platforms. The previous code base did not share common interfaces across HDMs; now there is a shared layer that developers can work from rather than maintaining each platform individually. This provides several benefits such as easier bootstrapping of new platforms, consistent interfaces, and less redundancies in HMD implementations.
  • The mobile multiview path now supports GearVR. Mobile multiview is similar to instanced stereo on the desktop, and provides an optimized path for stereo rendering on the CPU. Enable this in your Project Settings under VR, and restart the editor to take effect.

The preview release is available via the Epic game launcher.

Amazon have released version 1.9 of the Lumberyard game engine.  Lumberyard is a fork of Crytek’s CryEngine, used in such titles as Crysis, Ryse, MechWarrior Online and the massive Star Citizen, which has now switched to using Lumberyard.  It’s available for developers free of cost with the only caveat being use of Amazon’s online services.

The 1.9 release brings new functionality including:

• New Player Account Cloud Gem for player authentication and management
• Web portal for managing player data
• Improvements to the Particle Editor
• Express install option (thank goodness!) for easier installs
• Blend layer updates (specular color and smoothness sliders)
• New VR features, mostly starter projects
• UI system improvements
• Physically based shader reference examples compiled into a gem
• New Comment component

You can read more details in the release notes available here.