Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
16. March 2017


Wave Engine 2.3.1 was just released.  Wave Engine is a C# powered cross platform 3D game engine I previously featured in the Closer Look series.  The Wave Engine 2.3.1 released brings several new features and improvements, including:

    • OpenGL support on Windows platforms
    • Binary serialization with Protobuf-NET libraryDarkWaveEngine
    • WPF, Windows Form and GTK# templates
    • New Dark and Light themes
    • EdgeCollider2D component added to Physics2D
    • Texture support in vertex shaders
    • New RequiredService attribute
    • Oculus Touch support
    • Relative path support for entity paths
    • Bokeh lens image effect and a new sample illustrating it
    • Add Child button added
    • New QuickStarter sample, with code available on Github.


You can learn more about the release here, while Wave Engine can be downloaded here.

GameDev News

15. March 2017


Two key Haxe libraries same new releases today, OpenFL 4.9.0 and Lime 4.0.  Lime is a low level cross platform multimedia library, while OpenFL is a reimplementation of several Flash APIs used for game development.  OpenFL is layered over top of Lime, while several other Haxe libraries are in turn dependent on OpenFL.  The OpenFL team also released a blog post describing how to make use of the improved OpenGL bindings in Lime.


Details from the release notes.


OpenFL 4.9.0 Changelog

  • Updated for Lime 4
  • Added initial support for openfl process for SWF-based assets
  • Added support for loading generated SWFLite bundles in Loader
  • Added support for multiple HTML5 embeds on the same page
  • Added support for loaderInfo.parameters through the HTML5 embed
  • Added support for TextField restrict and maxChars
  • Added support for Float-based keys in Dictionary
  • Added a hack to add stroke support for TextField
  • Improved support for Lime asset manifests in SWF library
  • Improved template behavior to work if Lime is included before OpenFL
  • Improved the behavior of TextField setTextFormat/replaceText
  • Improved support for String-based messages in HTML5 Socket
  • Improved support for non-smoothed bitmapData in SWF libraries
  • Improved "missing font" warning to only occur once per font name
  • Improved "asset not found" warnings to throw errors
  • Improved animated mask support in MovieClip
  • Fixed support for embedded SWF libraries on Flash
  • Fixed the array count calculation in AGAL to GLSL conversion
  • Fixed support for CubeTexture in Stage3D renderToTexture
  • Fixed the reset position after using byteArray.uncompress
  • Fixed a type-cast error when retrieving a missing MovieClip asset
  • Fixed a possible bug when rendering an object with no parent
  • Fixed wrongful error on Stage3D viewport on OS X
  • Fixed cases where stage3D x/y is set before a backbuffer is created
  • Fixed support for GL context loss


Lime 4.0.0 Changelog

  • Added support for WebGL 2 APIs on HTML5
  • Recreated GL bindings in preparation for GLES3 support
  • Added support for running different Lime tools to match project version
  • Added WebGL, WebGL 2, GLES 2 and GLES 3 abstracts
  • Added initial support for WebGL/GLES2 extension constants
  • Added GL context, type and version properties
  • Added window.displayMode for full-screen display mode switching
  • Added lime.utils.DataPointer for managing native pointers
  • Added lime.utils.BytePointer for Bytes + offset without a new typed array
  • Added lime.utils.ObjectPool as a convenience API for object pooling
  • Added support for <assets path="" library="" /> for library packing
  • Added support for loading *.bundle directories as asset libraries
  • Added support for ${meta.title} and other project data in project.xml
  • Added support for Cairo textPath
  • Added support for multiple Lime embeds, rewrote HTML5 embed code
  • Added asset type to verbose Preloader messages
  • Added -Dwebgl1 to use a WebGL 1 context instead of WebGL 2 on HTML5
  • Removed deprecated behaviors from Lime 3
  • Updated Gamepad mappings to support additional models
  • Updated HTML5 window to dispatch resize event if parent element is resized
  • Improved support for deferred loading of asset libraries
  • Improved Asset error events, updated to throw errors when assets not found
  • Improved handling of GL context loss on WebGL
  • Improved behavior of asset manifests included as assets of another library
  • Improved behavior of path groups for audioBuffer assets
  • Improved error message if ANDROID_SDK or ANDROID_NDK_ROOT is not defined
  • Fixed caching for HTML5 cache groups
  • Fixed native HTTPRequest if file is not found or uses ~/ for home directory
  • Fixed copying of files when a directory exists of the same name
  • Fixed dispatch of Renderer.onRender when there is no context
  • Fixed dispatch of Renderer.onContextLost on native platforms
  • Fixed use of image.threshold when source is canvas or HTML5 image
  • Fixed missing warning if <icon path="" /> is null
  • Fixed <app path="" /> to be relative to include.xml path
  • Fixed <splashScreen path="" /> to be relative to include.xml path
  • Fixed case where assets could be processed as templates
  • Fixed support for ATF textures on Flash target
  • Fixed ID value for Joystick/Gamepad guid property
  • Fixed double dispatch of preloader complete verbose message
  • Fixed path of -options parameter when calling HXCPP

GameDev News

15. March 2017


There is no requirement to use Visual Studio Code when developing in Haxe, it is however the editor I will be using for this series.  If you would prefer to use HaxeDevelop, be sure to check this earlier tutorial on how to get up and running.  There are several other editor options available with varying levels of Haxe language support.


First things first, we need to install Visual Studio Code, you can download it here.



The install process is pretty straight forward, run the installer and chose the defaults and you should be fine.  Once installed run Visual Studio Code.


Now we need to add Haxe language support.  Click the extensions tab, filter on “haxe” and click the install button for “Haxe -- Haxe language support”.



Once installed it will prompt you to reload Visual Studio Code.  Do so.



If you haven’t already, create a project.  Instructions for doing so are available here.  Projects are folder based in Visual Studio Code.  To load your project either switch to the project directory from the commandline and type “code .” or load Visual Studio Code and select File->Open Folder.



Now you can run your game using Ctrl (Or Cmd) + Shift + P to bring up the command palette.  Now enter run task, like so:



Next pick the target platform you want to build for:



And TADA, your running application, assuming everything worked right:



If an error occurred, it will be show in the Problems panel:



Granted this process is a bit of a pain in the backside.  Thankfully there is a short cut for building and running the default build.  Simply hit Ctrl + Shift + B and it will compile for the default platform.  So… what is the default platform?  That would be Flash.  This of course means you have to have a Flash player installed.  Thankfully you can download one here.


What do you do if you want to change the default platform?  It’s a simple enough task, simply locate the file tasks.json in the .vscode folder.  Next locate the line “isBuildCommand”:true, and make sure this is copied to the entry you want to be the default build.  Like Highlanders, there can be only one, so be sure to erase it from the default “flash debug” task.



The Video


14. March 2017


A few days back Google released GAPID, Graphics API Debugger, which is open source and available on Github.  GAPID is described as:

GAPID is a collection of tools that allows you to inspect, tweak and replay calls from an application to a graphics driver.


GAPID is composed of several different components, including:

GAPII: Graphics API Interceptor

A layer that sits between the application / game and the GPU driver, recording all the calls and memory accesses.

GAPIS: Graphics API Server

A process that analyses capture streams reporting incorrect API usage, processes the data for replay on various target devices, and provides an RPC interface to the client.

GAPIR: Graphics API Replay daemon

A stack-based VM used to playback capture files, imitating the original application’s / game's calls to the GPU driver. Supports read-back of any buffer / framebuffer, and provides profiling functionality.

GAPIC: Graphics API Client

The frontend user interface application. Provides visual inspection of the capture data, memory, resources, and frame-buffer content.

GAPIL: Graphics API Language

A new domain specific language to describe a graphics API in its entirety. Combined with our template system to generate huge parts of the interceptor, server and replay systems.

GameDev News

13. March 2017


Welcome to our tutorial series on creating games using Haxe and HaxeFlixel.  This particular tutorial is going to cover setting up your Haxe development environment, installing and configuring HaxeFlixel and finally creating your first simple game.  Throughout this series I will be using Visual Studio Code as my editor, you can learn more about setting up Visual Studio Code for Haxe development here.


First we need to install the Haxe toolchain.  First head on over to the Haxe download page and pick the installer appropriate for your development platform.








Run the installer.  The default settings should be fine.



Now we need to install Haxe Flixel.  With Haxe installed we can now use command line tools to finish the installation process.  Create a new command prompt or terminal as Administrator if possible.  Then run the command

haxelib install flixel


This will download all the various required libraries for HaxeFlixel to run including lime ( a low level hardware library ) and OpenFL.  Please note that as of writing, HaxeFlixel is NOT compatible with the most recent version of OpenFL and Lime, hopefully this is fixed soon.  Don’t worry though, the above command will download and configure the correct version.


Next run the command

haxelib run lime setup


Finally, HaxeFlixel has a set of command line tools and templates available, I will be using these tools for this tutorial series, so lets install those as well.  Run the following two commands:

haxelib install flixel-tools

haxelib run flixel-tools setup




At this point the “flixel” command is now available for you.  Let’s use it to create a new game project.  In the directory you want to create your game, enter:

flixel tpl –n “MyFirstFlixelGame”


A new project will be created for you and if you selected an IDE during the install process, it will automatically open:



As part of the previous process several demos were installed as well.  If you want to jump into some code, instead run the command:

flixel create

This will present you will all of the available templates you can create from:



That’s it for the setup process, in the next tutorial we jump in to the code of our first application.


The Video


AppGameKit Studio

See More Tutorials on!

Month List