Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

16. August 2017

Lumberyard, Amazon’s version of the venerable CryEngine, is now available in source code form on Github.  This does not however mean that the Lumberyard game engine is now open source, it still has a proprietary license available here.  The major difference in this change is that source code is now available using Github instead of requiring you to download it using the Lumberyard binary installer.  This update does however enable you to migrate to new versions easier, as they will be released as new branches.  This change also makes it possible for community members to easily submit engine improvements and fixes.

From the announcement:

Today, we’re excited to announce that Lumberyard source is now available on GitHub. This has been one of the most requested features from the community, and we’re happy to finally make it a reality. You can check it out at

Because making games is challenging enough. Here are two ways that GitHub makes it easier.

Get Lumberyard using GitHub

Up until now, the only way to get Lumberyard was to install Lumberyard using our standard installer. This would place all of Lumberyard, including the source, on your machine, in a new but separate directory. We heard you loud and clear: it was tedious to incrementally upgrade Lumberyard. That changes with GitHub.

Now you can get the Lumberyard source code directly from our GitHub repository and easily use GitHub to manage your code. Integrating a new version of Lumberyard is now a relatively simple operation. And since each new release of Lumberyard is a separate branch, you can integrate against any version. Plus, you can even create your own GitHub account to use GitHub for source control on your own project and use that as your remote repository, giving you an easy way to collaborate with your team.

If you are new to Lumberyard, we recently did a hands-on video available here and embedded below.

GameDev News

11. August 2017

All the way back to Unity 1.0, the Unity game engine has supported a version of JavaScript called UnityScript.  Today on the Unity blog, Unity have announced that they will no longer be supporting UnityScript going forward.  Starting in Unity 2017 beta 2, they will remove the ability to create JavaScript files directly inside the editor.  Then they will be removing the ability to submit .js files to the Asset Store.  Then at some point in the future they will be removing the compiler completely, although it will be available to be forked on Github.  According to Unity analytics numbers on a very small portion of the community is even using UnityScript at this point, with under 4% using it as the primary language. 

They actually published some fairly interesting stats about language usage:

  • To date, of all the projects that have used Unity 5.6, about 14.6% of them have at least one file with a .js extension in it. 14.6% sounds quite high, but then we broke the numbers down further, and looked at how many files were .js files as a fraction of total script files in the project (.js + .cs).
  • So, that leaves 85.4% of all projects which are entirely in C#, with no UnityScript files at all.
  • 9.5% of all projects are mostly in C# – they have some UnityScript files, but fewer than 10% of their total script file count. Another 1.5% of all projects have between 10% and 20% of their code in UnityScript files.
  • That leaves 3.6% of all projects that have more than 20% of their code in UnityScript.
  • Only 0.8% of all projects are exclusively (i.e. 100%) in UnityScript.

With only a small portion of the community using UnityScript it does make very little sense to continue supporting it, especially now that C# support isn’t stuck in the stone ages.

GameDev News

8. August 2017

Epic have just released a new version of the Unreal game engine, bringing it to version 4.17.  This release adds several new features including Sequencer improvements, a new beta compositing plugin “Composure”, new global shader support in plugins, XBox One X support, VR spectator support, experimental ARKit support, experimental support for new cloth tools and much more.

Details from the Unreal Engine blog:

The new Composure compositing system and Image Plate plugin provide a powerful and flexible means of combining content rendered in realtime with live action footage. Numerous improvements to Sequencer continue to refine the workflow for creating cinematics and linear media.

Discover and load quests, heroes, or other game-specific content with the new Asset Management Framework. Query information about Assets at runtime in Blueprints using the Asset Registry's new Blueprint accessors.

Develop games for Microsoft's Xbox One X console as part of the platform improvements. Make your VR project a social experience using the new VR Spectator Screen support. On Android, we have improved several aspects on high end devices, and we continue the effort to reduce executable sizes even further.

Be sure to read the blog for a great deal more information on new features in this release.  As always you can upgrade using the Epic Game Launcher.

GameDev News

7. August 2017

With the upcoming release of Godot 3.0, Visual Programming is now officially part of the game engine.  In this tutorial we are going to look at the basics of programming using the new Visual Programming interface.

To get started using Visual Programming, just like using GDScript or other options, you have to attach a script to an object in Godot, like so:


In the script creation dialog, you can now select the programming language to use:


It will now bring you to the following programming interface:


To get started, we need to implement one of the available Godot callbacks.  These are exactly the same as GDScript and represent various different functions that will be called over time by the game engine.  To get started, in the Members section, click the following icon:


The various different callback functions available for the selected object type are available:


The most commonly used callbacks are _process() which is called every pass through the game loop, _ready() which is called when the object has been created, _init() which is called to create the object (think constructor), and _input() which is called when input is received.  We are going to create an exceedingly simple example here that moves our sprite each from, so select _process.  Now you should see:


White arrows represent program flow.  Connections on the right represent output, while connections on the left represent input.  This is the entry point for our code and is going to be called each frame.  You can see we are passed a floating point value “delta” as a parameter.  Now we need to get a reference to our object, we use a “self” node for this.  You can locate notes via search:


This gives us access to the Sprite object our script is attached.


Now click on the blue/green ball output from the Sprite and drag a connection out, selecting Get as the option:


This will now give you access to all of the data of a sprite object and all other inherited classes:


Locate and select position, which is a Vector2 object.  Now lets create a variable we are going to use to define our move amount.  In the variables section, click +:


Now right click and select Edit Variable:


Select type as Vector2 and value of (1,0)


Finally click the variable name and rename it to moveBy.  Now drag our newly created variable onto the canvas:


Now we want to create an Add node and add our two vectors together, like so:


Now we use another Self (or the same one we created earlier) and this time do a Set and select position.  We now pass in the added Vector2 result, also we attach program flow from _process, like so:


This simple program will cause the sprite to move by 1 pixel per update.

Video Version

Programming ,

7. August 2017

A release candidate of the upcoming Blender 2.79 has just been released.  Blender is a popular cross platform open source comprehensive 3D application available at for most popular platforms.  RC1 brings several new features to Blender including Cycles renderer improvements, automatic DPI scaling, improved Alembic support, grease pencil improvements and tons of bug fixes.

One important warning about this release is the .blend file generated may not be backward compatible with earlier versions of Blender if using certain add-ons.

When using add-ons in Blender 2.79 that take advantage of the new data-block pointer properties, the resulting .blend files can't be opened in earlier versions of Blender. Attempting to open such .blend files in Blender 2.78c and earlier may crash.

Details from the release notes:

  • Cycles: Built-in Denoising, Shadow catcher, Principled shader, AMD OpenCL optimizations.
  • Grease Pencil: New frame interpolation tools, per-layer onion skinning.
  • Alembic: Improvements to compatibility, stability and support.
  • User Interface: Initial support for reusable custom configurations, automatic DPI scaling.
  • Twenty Three new and several updated add-ons.
  • And: 100s of bug fixes and other improvements!

Month List

Popular Comments

OpenStreetMap Plugin For Unreal Engine Released
Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

2. January 2017


Mike Fricker, UE4 Technical Director at Epic Games, just released a new plugin for Unreal Engine that enables you to utilize OpenStreetMap data directly in Unreal Engine.  Keep in mind this is just a hobby project and isn’t directly supported by Epic. is a crowd sourced (think Wikipedia) map of the world.  This plugin enables you to take data from OSM and use it directly in your game, quickly creating real world accurate cityscapes like the one shown to the right.OSM  Additionally all of the location information is retained upon import, so if you are creating an Alternate Reality based game like Pokemon Go, the data is available to you.  Keep in mind however that OpenStreetMap data is released under the Open Data Commons Open Database License (ODbL).  I am no lawyer, but I believe the license enables you to create closed source projects using the data so long as you give proper attribute, share any modifications you make to the database and make sure that the data itself (not your game code) remains available and open.


Details of the plugin from the Readme:

Street Map Assets

When you import an OSM file, the plugin will create a new Street Map asset to represent the map data in UE4. You can assign these to Street Map Components, or directly interact with the map data in C++ code.

Roads are imported with full connectivity data! This means you can design your own navigation algorithms pretty easily.

OpenStreetMap positional data is stored in geographic coordinates (latitude and longitude), but UE4 doesn't support that coordinate system natively. That is, we can't easily deal with spherical worlds in UE4 currently. So during the import process, we project all map coordinates to a flat 2D plane.

The OSM data is imported at double precision, but we truncate everything to single precision floating point before saving our UE4 street map asset. If you're planning to work with enormous map data sets at runtime, you'll need to modify this.

Street Map Components

An example implementation of a Street Map Component is included that generates a renderable mesh from loaded street and building data. This is a very simple component that you can use as a starting point.

The example implementation creates a custom primitive component mesh instead of a traditional static mesh. The reason for this was to allow for more flexible rendering behavior of city streets and buildings, or even dynamic aspects.

All mesh data is generated at load time from the cartographic data in the map asset, including colorized road strips and simple building meshes with triangulated roof polygons. No spline interpolation is performed on the roads.

The generated street map mesh has vertex colors and normals, and you can assign a custom material to it. If you want to use the built-in colors, make sure your material multiplies Vertex Color with Base Color. The mesh is setup to render very efficiently in a single draw call. Roads are represented as simple quad strips (no tesselation). Texture coordinates are not supported yet.

There are various "tweakable" variables to control how the renderable mesh is generated. You can find these at the top of the UStreetMapComponent::GenerateMesh() function body.

(Street Map Component also serves as a straightforward example of how to write your own primitive components in UE4.)

OSM Files

While importing OpenStreetMap XML files, we store all of the data that's interesting to us in an FOSMFile data structure in memory. This contains data that is very close to raw representation in the XML file. Coordinates are stored as geographic positions in double precision floating point.

After loading everything into FOSMFile, we digest the data and convert it to a format that can be serialized to disk and loaded efficiently at runtime (the UStreetMap class.)

Depending on your use case, you may want to heavily customize the UStreetMap class to store data that is more close to the raw representation of the map. For example, if you wanted to perform large-scale GPS navigation, you'd want higher precision data available at runtime.


The plugin and it’s source code is hosted on Github available here.  The plugin is released under the very liberal MIT open source license.

GameDev News

blog comments powered by Disqus

Month List

Popular Comments