Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon Join the GFS Discord Server!
18. June 2017

Unity released a new patch for the Unity 5.6 branch, 5.6.1p4.  This patch has several improvements and fixes, details from the patch release notes:

  • Android: Enabled NEON in Umbra.
  • UI: CanvasRenderer::OnTransformChanged will not be called when object is inactive. (815861)
  • Video: Optimized video decoding directly into RenderTexture if it is the same size as the video stream
  • Video: Skip-ahead functionality improvements.
  • GI: Added support for LOD baking in Progressive Lightmapper. Light Probes are not necessary anymore when baking LODs using Progressive Lightmapper.
  • GI: Support for double sided materials in Progressive Lightmapper. Added a new material setting that causes lighting to interact with backfaces. When enabled, both sides of the geometry get accounted for when calculating Global Illumination. Backfaces do not count as invalid when seen from other objects. Backface rendering is not controlled by this setting nor will backfaces be represented in the lightmaps. Backfaces bounce light using the same emission and albedo as frontfaces.
  • (916119) - Android: Fixed a regression where Banner Ads are invisible, but still clickable.
  • (905867) - Android: Fixed an out of memory crash when using a static splash screen.
  • (910194) - Animation: Fixed an issue where using an override controller multiple times would not animate correctly.
  • (917343) - IL2CPP: Fixed an issue which caused IL2CPP to fail to convert assemblies if two non-existing methods with the same declaring type were referenced from any assemblies.
  • (907449) - Particles: Correctly initialize default curves, when creating new Particle Systems.
  • (907277) - Particles: Fixed an occasional crash when emitting from a skinned mesh renderer shape.
  • (none) - Particles: Fixed incorrect values for emission burst min and max when upgrading from an older Unity version.
  • (912158) - Physics 2D: Fixed an issue where ContactFilter2D collision normal limits failed.
  • (917323) - Physics 2D: Fixed an issue with Raycast not always detecting a CapsuleCollider2D or a BoxCollider2D.
  • (909020) - Video: Fixed issues regarding video looping/end detection.
  • (904924) - Video: Fixed failing VP8 transcode on Windows due to unsupported audio codec.
  • (898171) - Video: Fixed an intermittent failure to load video tracks on iOS.
  • (906044) - Video: Fixed invalid video stride evaluation.
  • (900524) - Video: Added support for transcoding to tiny VP8 resolutions.
  • (904578) - WebGL: Fixed AudioSource.time return value.
  • (903767) - WebGL: Fixed IE InvalidStateError load-time error.
  • (901252) - WebGL: Fixed Profiler connection.
  • (903092) - WebGL: Fixed Template Custom tags not being replaced at build time.
  • (892185) - WebGL: Fixed WebAssembly build failure with Full exceptions on Windows.
  • (897782) - WebGL: Fixed WebAssembly missing setTempRet function.
  • (891835) - WebGL: Fixed WebAssembly missing setThrow function.
  • (891431) - WebGL: Fixed WebAssembly runtime error: integer overflow/unrepresentable.
  • (905625) - WebGL: Fixed custom cursor support.
  • (898210) - WebGL: Released WebCam after use so other tabs can use it.
  • (871541) - Windows Store: Fixed a crash which happened when retrieving WheelHit.Collider after having previously set it to null on .NET scripting backend.
  • (909977) - Windows Store: Fixed a potential stack overflow when building a project with a large custom cursor.
  • (914797) - Windows Store: Fixed exceptions thrown in OnGUI callback not being logged on .NET scripting backend.
  • (912074) - Windows Store: Fixed System.Numerics.dll not being referenced by scripts when using IL2CPP scripting backend.
  • (909703) - Windows Store: Fixed UNetWeaver crashing when using .NET 4.6 API Compatibility level with IL2CPP scripting backend when deriving from .NET 4.6 specific types.
  • (902234) - Windows Store: Fixed WorldAnchorStore.GetAsync crashing the player.

GameDev News

14. June 2017

This is a brand new series being launched on YouTube and GameFromScratch and is somewhat different in scope.  The aim is to essentially make the same game several times in different game engines.  We are creating a simple bowling game in various different 3D game engines.  In fact, we are creating this bowling game which we completed earlier using the PlayCanvas game engine.

For each game engine in the series we will implement basically the exact same game, along with a step by step text version, plus a video of the process.  This should be useful for a number of reasons.  First it enables you to directly compare the workflow between different game engines.  Second, it shows... perhaps not best practices, but how to get started creating a full featured, if extremely limited, 3D game with physics, scenes, model importing an more.

At this point in time I have begun implementing it in a number of different engines, including:

    • PlayCanvas
    • Atomic Game Engine
    • Godot 2.x
    • Unity
    • Unreal Engine

Depending on the popularity of the series I am willing to implement the game in other engines as well with a few caveats.  The engines need to support all the required features ( level editor, 3d model importing, physics, etc ) required to make the game.  So while I could implement such a title in a code focused API such as Ogre or LibGDX, it’s completely outside of the scope of what I am trying to accomplish here.  I also need to have access to the game engine, either through public domain, free trial, etc.  This currently rules out some engines such as Leadwerks and Shiva unfortunately. 

Beyond the engines listed above, I’d love to hear what other engines you would like to see covered? 

GameDev News

14. June 2017

Godot 3.0 is a massive update for the Godot game engine that is actively underdevelopment and anxiously anticipated.  Today they posted an update describing the newest functionality that will be appearing in Godot 3.0.  The blog post goes into a great deal of detail, but here is the TL;DR version:

  • GDNative – native language bindings rewritten C++, as well as RUST and D bindings addedGodot
  • Customizable themes and general UI improvements
  • WebGL 2.0 and WebAssembly support
  • C# (Mono) support
  • AR/VR Support development work using OpenVR
  • “Freelook” 3D scene navigation for WASD type scene control in Godot
  • Script editor enhancements
  • MFI controller support
  • Various fixes and improvements

So this of course leads to the most obvious question... when are we going to see Godot 3.0?  Well...

Godot 3.0 is coming along pretty nicely, and though its development is taking longer than we initially planned back in Fall 2016, it's all for the better. The many compatibility changes that we had the opportunity to make over the last 9 months will make Godot 3.0 more consistent and easy to use.

Still, as we often repeat it to newcomers, please continue using Godot 2.1.x until the 3.0 branch is ready - we speak a lot of compatibility changes but the workflow stays very similar, and the vast majority of what you will learn using Godot 2.1.x will be reusable 1:1 in the future branch. It will be the same engine, just better.

Okay, but when do we get the alpha build?

When it's ready™. There has been a lot of progress on many blocking bugs lately, which we track in a dedicated issue. We expect to be ready for an alpha release in ca. 2 weeks, so stay tuned :)

By then we will consider 3.0 feature complete, and we should stop breaking compatibility every other day. Count likely two months of testing and bugfixing and we should be ready to release the stable version, probably some time in August.

I have checked out in progress builds for Windows a few times in the last few weeks, and for me it’s been pretty much unplayable due to some OpenGL bugs, so hopefully the alphas become a bit more stable and I can get some hands on time soon.

GameDev News

12. June 2017

In their most recent release of 3ds Max, version 2018.1, Autodesk have launched a new VR focused feature with the name 3ds Max Interactive.  This is essentially a version of their Stingray Game engine, tuned for pre-visualization and VR work, instead of for games.  If you are interested in learning more about the Stingray game engine powering this feature, we featured it in the Closer Look game engine series last year.  You canimage learn more about the new VR functionality in 3ds Max on their home page.

Additionally, Autodesk have released a first look blog post discussing the new functionality.  One thing that is interesting to note from that discussion is, although this could be used for games, it’s actually intended for the visualization market.  Comments from the blog post:

Why add VR tools to Max when there are a lot of broadly adopted game engines out there? And why now? 

Here’s how we see it: when you’re trying to learn a new skill, it’s way easier to tackle if you have a familiar point of reference. Same deal here. We see the best path for arch viz VR as starting with the familiar language of Max, then easing into the less familiar territory and terminology of virtual reality – which is where Max Interactive comes in. It’s far less intimidating than being dropped in the middle of an unfamiliar game engine designed for game developers and trying to work your way back, or settling for an unknown set of 3D tools retrofit onto a VR game engine.

Could you use Max Interactive to build a VR game?

That’s a matter of “could” versus “should.” Sure, you could use Max and Max Interactive to build a game because the tools aren’t that different today. But over time, you’ll see Max Interactive evolve and adapt to the specific demands of design visualization in VR and AR. Meanwhile, game developers have already established their open workflows and pipelines based on Max and real-time engines like Unity and Unreal. We’re not trying to upend that. They’re just not optimized for architectural visualization workflows.

GameDev News

6. June 2017

There are several game engines out there that present a code free option such as Stencyl and Construct.  Today we are looking at an open source alternative, GDevelop.  It is a cross platform, open source 2D game engine with a visual programming interface that requires no previous experience.  However there is also the ability to extend the engine using the C++ programming language if desired.  If you are new to the Closer Look series, it is a combination of game engine review and getting started tutorial helping you decide if a game engine is right for you.

As always, there is a video version of this tutorial available here and embedded below.

Without further ado, let’s jump into GDevelop.

Meet GDevelop

As mentioned above, GDevelop is an open source 2D game engine.  It is released under the MIT license for the core engine, while the editor is available under the GPL v3 open source license.  The code is available on Github.

Of course you don’t ever have to touch the source code to work with GDevelop.  You can download binaries for Windows, Mac, Linux as well as Browsers, iOS and Android in the form of GDevApp.  I will not be covering GDevApp today however.  GDevelop is able to compile native applications, HTML5 pages as well as Android applications, which is currently an experimental feature.

The vast majority of your time is going to be spent in the GDevelop editor, shown below.


The center of the screen is currently showing the Scene editor.  There is where you can compose scenes.  It is a tabbed view that can contain multiple open scenes as well as Events, the programming model of GDevelop, which we will discuss more shortly.

On the right hand side is the Objects Editor, which contain the building blocks of your game.  On the left hand side is the Project Manager containing the assets and scenes that make up your game.

Let’s walk through creating a sprite in a game.  In the Objects editor, right click objects and select Add an object.


This will show us a list of possible objects:


For every object except the Sprite you need to enable it before you can use it (thus why they are grayed out).  It’s as simple as double clicking a grayed out object to enable it however, like so:


In this case however we are going to use the Sprite object, which is already enabled.  Simply double click Sprite.  Double clicking the newly created object in the Object editor will open up the sprite editor screen:


At the top right corner of the editor window you will see the Images bank’s editor, click the plus icon and add the images you will use for your sprite.  Next drag the selected images down to the images section, like so:


You can rename and configure the animation (if any) under the Animations panel.


Now you can create an instance of your Sprite object by simply dragging it into the scene.


As we saw earlier, there are several built in objects in addition to the Sprite object, including Admob integration, a Text object, a tiled sprite (spritesheet), etc.   Next lets move on to adding some logic to our newly created object.

Scripting in GDevelop

Logic in GDevelop are implemented using Events.  Let’s look at an example of moving the sprite around when the mouse moves.  Click on the Events tab.


In the Events ribbon, click Add an Event:


In this case we have no conditions, we want this to happen every single frame.  Hover over No actions, then select Add an Action.


This is where the building block aspect of GDevelop programming comes into play.  Select All Objects->Position->Position of an object.


Now we can set the parameters for positioning our object.  First select the object to modify, then set each parameter.  In this case we set the X and Y values to those of the mouse cursor, like so:


Upon completion, you will see we now have an event defined:


In this particular case we have no condition, so our event will fire every pass through the event loop.  We could however have set a condition which causes our event to fire or not.  Here for example is a condition that will start playing some music once the scene is loaded.


Beyond conditions, there are other control structures you can add to events:


Link enables you to break link to another event sheet, enabling you to modularize your code.  It is also possible to define variables, both globally, to the scene and at the object level.  For example, right click the Project and select Modify Global Variables.


This now enables us to define new variables:


This can also be done at the object level, right click an object and select Other Properties.  Then in the resulting panel select Click to Edit...


While we are here, notice the Behaviors option?  This enables us to add new functionality to game objects.  Click the Add... button:


You will notice once again, by default all behaviors are disabled.  Double click a behavior to add it in.  Let’s go ahead and add Top-down movement as an example.  You can now edit properties of the new behavior in the same dialog:


This will instantly add arrow key navigation abilities to your object.  When you play your game, arrow keys will cause your object to move around screen.  Speaking of playing your game, hit the Preview button in the Scene ribbon to launch your game in your browser.


You can control application level settings of your project by right clicking your project and selecting Edit the property of the game.


This will bring up the next dialog.


Finally, if your project has Native extensions enabled, under the File menu you have the option to build a native version of your application.


Then simply click the Compile button.


Documentation and Community

GDevelop is reasonably well documented, with a Getting Started tutorial, several other tutorials and a decent number of starter templates to choose from.


There is also a manual available online.  If you are intending to extend GDevelop using C++ however, the documentation is almost non-existent.  However being an open source project, all of the code is available.  All of the behaviors and objects we used in this example are available in source form on Github in the extensions folder:


GDevelop has a dedicated forum available here.  It is reasonably active with a decent sized community.  Forums are available in both English and French.


If open source, free and a visual programming interface are important to you, GDevelop is definitely an engine to consider.  The documentation is adequate, the engine is mostly feature complete, although annoyingly some features such as Tiled support are only available for native targets.  The entire thing is designed around extensibility and if you are willing to dive into C++, the sky’s the limit on what you can do.  My biggest complaint is a lack of polish on the UI layer, experiencing a few crashes, some UI glitches that went away on a reload and some buttons that simply do nothing.  Most annoyingly, the engine is basically unusable on a high DPI display.

It is however an easy engine to jump into and use if you are willing to deal with some UI warts.  An MIT license around the core engine is always an excellent feature.

The Video


AppGameKit Studio

See More Tutorials on!

Month List