Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
11. March 2019


The Haxe powered Heaps game engine just updated to version 1.6.0.  The Heaps game engine is a battle tested game engine responsible for such titles as Dead Cells, Northgard and Evoland.  It was created by the same developer as the Haxe language, Nicolas Cannasse.  The game engine is open source under the MIT license and is available on a number of different platforms including most modern game consoles.

The 1.6 release brings several new features, including:

2D:

  • added DomKit support
  • added h2d.Camera
  • review h2d filters wrt alpha handling
  • added h2d.Flow.layout
  • support for SDF fonts
  • support for sub pixel Tiles (various coordinates/sizes are now Float instead of Int)
  • added h2d.Interactive.onReleaseOutside and .shape for custom shape handling
  • h2d.Object.onParentChanged is now onHierarchyMoved
  • handle multiple Interactive onOver

3D:

  • added h3d.col.Capsule
  • added h3d.col.Collider.inSphere + changed inFrustum
  • added Driver.capturePixels sub region
  • added h3d.scene.MeshBatch
  • optimized shadows maps culling
  • optimized internal pass lists handling
  • moved h3d.scene.DirLight/PointLight/LightSystem/Renderer to h3d.scene.fwd package
  • more work on pbr renderer and terrain system
  • various optimizations (less allocations)

Other:

  • [js] heaps now defaults to canvas instead of window for events
  • review hxd.prefab.Prefab API
  • added mp3 sound support
  • added S3TC dds texture support
  • new samples : Camera2D, Domkit, Flows, FXView, Interactive2D, MeshBatch, Lights


If you are interested in learning Heaps, we have a few tutorials to get you started:

Additionally there is an excellent Database/Level editor for Haxe called CastleDB that you should certainly check out.

CastleDB Introduction

GameDev News


26. February 2019


The Haxe programming language is capable of generating code in several other languages, including more recently the Lua programming language.  The Defold game engine is a powerful free 2.5D game engine from King, that we have covered extensively in tutorial series.  It was only a matter of time until the two came together, and that is exactly what has happened.  The hxdefold open source project enables you to program Defold using the Haxe programming language. 

Features

  • Fully typed Defold API with proper compile-time errors and IDE services.
  • Type-safe game object messages and properties with zero overhead.
  • Strengths of Haxe without compromises: powerful type system, meta-programming, static optimizations and cross-target code sharing.

The getting started instructions are pretty straight forward, from the Github page:

  • Install this library (from this repo): haxelib git hxdefold https://github.com/hxdefold/hxdefold
  • Run haxelib run hxdefold init inside your Defold project. It will create a sample Hello.hx script component class and a build.hxml for building it.
  • Read the comments in these files to quickly get some idea.
  • Build with haxe build.hxml to get the lua output.
  • Add Hello.script to your game object in the editor and observe the greeting in the debug console.
  • Proceed with writing well-structured, expressive and type safe code for your Defold game.

The editor won’t become Haxe aware however, so you will still have to build your code externally.

GameDev News


10. September 2018


Following up on our C#, C++ and Lua game engine lists, today we are going to look at frameworks and engines that use the Haxe programming language.  In the Haxe ecosystem, many frameworks are build on top of other frameworks, so we will be covering them in order, from lowest level to the highest.  If we have previously done a tutorial on video on the engine/framework, there will be a learn more link to the right.


Lowest Level

NME – Native Media Engine

Lime


Intermediate Level

Kha (Learn More)

OpenFL


High Level 2D

HaxeFlixel (Learn More)

HaxePunk

Stencyl (Learn More)


High Level 3D

Away3D

Heaps (Learn More)

Armory3D (Learn More)


Programming


26. June 2018


Version 8.3 of the popular Haxe media library OpenFL was just released.  OpenFL implements the Flash api, enabling developers to create cross platform rich media apps and games for several different platforms.

The 8.3 release includes some improvements to tilemap supports but mostly contains a variety of fixes including:


  • Added tile.blendMode and tilemap.tileBlendModeEnabled
  • Added netStream.dispose() and improved netStream.close() support
  • Improved buffer handling for OpenGL Tilemap rendering
  • Fixed default HTML5 template after Chrome passive event listener change
  • Fixed a regression in rendering of TextFormatAlign.JUSTIFY text
  • Fixed dispatching of Event.ADDED_TO_STAGE on document class in NPM builds
  • Fixed missing loader.contentLoaderInfo.bytes field
  • Fixed using bitmapData.hitTest against another BitmapData object
  • Fixed return value of eventDispatcher.dispatchEvent() when default is prevented
  • Fixed timing issue with multiple texture units in custom OpenGL shaders
  • Fixed MouseEvent.MOUSE_OVER/MouseEvent.MOUSE_OUT to dispatch in each event phase
  • Fixed some issues when using -Dopenfl-power-of-two textures
  • Fixed stage.color to mark rendering as dirty when changed
  • Fixed openfl.net.Socket on HTML5 to allow reading of input later


You can read more about the release here, and learn how to download OpenFL here.

GameDev News


12. June 2018


Haxe 4.0 got one step closer with today’s release of Haxe 4.0.0 preview 4.  The release focuses heavily on improved compiler display services that will enable better editor support in IDEs such as Visual Studio Code.  Change will support auto imports, override completions, structure field name completion and more.  The Visual Studio code extension has already been updated to support the new Haxe 4.0.0 functionality.


Details of the release:

Improved compiler display services

Our focus for this release has been compiler display services. We implemented a new, JSON-RPC-based protocol which is utilized by the vshaxe Visual Studio Code Extension to provide a variety of new features:

  • Support for auto-import
  • Completion on override |
  • Completion for structure field names
  • Support for auto-generating structure declarations, functions, switches and more
  • Context-aware, sorted toplevel completion
  • Reference finding which explores modules that are not necessarily part of the compilation

Improved enum abstracts

Enum abstracts now get the treatment they deserve with a proper enum abstract syntax. Furthermore, values can now be omitted if the enum abstract is defined over Int or String:

enum abstract MyEnum(String) {
    var MyValue; // implicit = "MyValue"
}

enum abstract MyOtherEnum(Int) {
    var MyValue0; // implicit = 0
    var MyValue1; // implicit = 1
    var MyValue5 = 5;
    var MyValue6; // implicit = 6
}

Various syntactic improvements

  • extern is now recognized as a field-level modifier and can be used instead of @:extern
  • Metadata names can now use dots, e.g. @:haxe.json becomes a metadata entry named "haxe.json"
  • Structure fields now consistently allow var ?x and final ?x, meaning the same as @:optional var x
  • Type1 & Type2 is now a recognized syntax for intersection types. For the time being, it is only supported to merge structures (replacing the { >Type1, >Type2, } syntax) and for type parameter constraints (replacing T:(Type1, Type2) which has been removed from the language).

Be sure to check the change log for a complete list of changes and bug fixes in the release.  You can download Haxe 4.0.0 p4 right here.  If you are interested in developing games using the Haxe programming language be sure to check out our new Armory tutorial series or our HaxeFlixel tutorial series available here.

GameDev News


GFS On YouTube

See More Tutorials on DevGa.me!

Month List