Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
27. January 2016

 

RoboVM just release version 1.13.0 adding Twitter Fabric support.  RoboVM is a virtual machine that enables you to run Java JVM applications on iOS devices and is commonly used to power LibGDX games on iPhones and iPads as well as recently added support of Apple TV.  This release adds:

Bug Fixes & Enhancements

As always, we squashed bugs, improved performance and added some bells and whistles. Here are the most important changes:

  • Fixed an issue with RxJava in high-concurrent scenarios as well as alignment issues
  • Fixed memory leak in IntelliJ IDEA plugin and RoboVM Studio that would eat up CPU and memory
  • Fixed crash in Android SDK setup on Linux
  • Added automatic installation of HAXM to the Android SDK setup
  • Updated RoboVM Studio to IntelliJ IDEA 15.0.3
  • Updated Android SDK to the latest version for Windows, Linux and Mac OS X
  • Added setting to IntelliJ IDEA plugin/RoboVM Studio to disable automatic setting of language level to 1.8
  • Added various improvements to the device selection dialogs in Eclipse and IntelliJ IDEA/RoboVM Studio
  • Minimized the amount of Gradle demons that are being spawned by IntelliJ IDEA when creating or importing Gradle-based projects
  • Added methods to NSData to retrieve contents without producing garbage
  • Fixed classpath/bootclasspath setup in dynamic frameworks
  • Fixed linking on Linux x86_64
  • Fixed crash in debugger due to wrong JDWP event ordering
  • Updated all 3rd party SDKs used in RoboPods to their latest versions
  • Bindings for all new iOS 9.2 APIs
  • Fixed 30 second watchdog limit on iOS for unit tests. iOS would kill a process that takes longer than 30 seconds to establish a UI run loop. Unit tests do now set up an artificial run loop, while tests are being run on a separate thread.

GameDev News


26. January 2016

 

Maya LT, the stripped version of Maya aimed at indie game developers, just got a version of the Bonus Tools, previously available only for the full release of Maya.

 

From the Autodesk blog:

Are you a Maya LT user?  Have you seen or heard of BonusTools and felt a little left out?  well I'm happy to announce that BonusTools is finally available for Maya LT!  It has consistently been one of the most requested improvements on the Maya LT user forums. 

I should note that it is technically a subset of the regular version due to the fact that some plugins and python scripts are not supported in Maya LT.  But, with around 100 new tools included, there is still a lot of functionality in the LT version.

Links to the install package as well as to the installation instructions have been posted on the Bonus Tools Resource Page.  Here you'll also find tutorials and movies related to the individual tools.

If you're not familiar with BonusTools you can check out the following movie as good intro to the kinds of tools that are available.

GameDev News


26. January 2016

 

I’ve been waiting on this one for a while, Godot 2.0 has finally been released in beta form.

Never one for ...  lengthy release notes, this release is not exception:

After a long, long time in development Godot 2.0 is now in beta!

Godot 2.0 Beta features a new interface , and huge amounts of usability improvements.
It is also more stable than ever, with hundreds of bug fixes and small enhacements.
Give it a test in the Downloads section!

Due to the lack of details of what is in this release (EDIT—Actually, read below, author contacted me via twitter with WIP change log), I instead leave you with a screenshot of the new 2.0 UI in action:

image

EDIT – The change log is still a work in progress, but here are it’s contents at present:

Useful links:

Related GH issue: https://github.com/godotengine/godot/issues/3355

Closed issues against 2.0: https://github.com/godotengine/godot/issues?q=milestone%3A2.0+is%3Aclosed

Closed PRs against 2.0: https://github.com/godotengine/godot/issues?q=milestone%3A2.0+is%3Aclosed

Closed PRs since 1.1-stable: https://github.com/godotengine/godot/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aclosed+updated%3A%3E2015-05-21

Remember to compare between the current status and 1.1-stable, we don't need to mention changes that were done in between, like fixing regressions added after 1.1-stable.

 

Added

- INI-style `.tscn` and `.tres` file formats for scenes and resources

- Haiku platform support

- Scene inheritance: scenes can be based on another one and save only changes relative to the base scene

- Support for Opus audio codec

- Godot icon for Windows editor using `pe_bliss` (GH-2195)

- Added ability to export current scene to a .zip file // what is this feature?

- Option to keep collision shapes at run-time (GH-1045)

- ConfigFile.get() now has an optional "default" value to return in case the value is not found

- Alt+Right click to pick layered nodes (GH-837)

- Z-position in Node2D to specify draw order (GH-405)

- GUI node (Control) rotation and scaling

- Building on Windows now works with Visual Studio 2015

- Improved joystick support

Export

- Option to convert .tscn format scenes to binary .scn format on export

- Option for zip-compressed resources (rather than binary pck)

- Option to export resources only

Editor

- Live scene editing

- Open several scenes at once

- Dockable UI windows

- Revamped script editor; recently viewed scripts appear in a red color, whereas less recent ones appear in a blue color

- Merged Script and Help tabs, help is now viewable from the Script tab

- Alt+Right click to pick layered nodes (GH-837)

- Improved "Project Settings" and "Editor Settings" dialogs (sections)

Debugging

- Option for  visible collision shapes, navigation, joints and paths at run-time (GH-934) (GH-2439) // clarify what is visible in 3D

- GDScript keyword `breakpoint` for persistent breakpoints (GH-3165)

GDScript

- Custom signal syntax `signal my_signal(parameter_a, parameter_b)` at class level

- Constructor `Color8(r, g, b, a)` and members `r8`, `g8`, `b8`, `a8` for `Color` type to define colors using 8-bit (0-255) values (GH-2339)

- GDScript export hints

  • - `int, FLAGS` — full range of bit flags (GH-2282)
  • - `int, FLAGS, "Flag 1", "Flag 2"` —set of  named bit flags (GH-2988)
  • - `float, EXP` — float edited with exponential slider (GH-2988)
  • - `float, EASE` —  float edited with easing functions display (GH-2403)
  • - `String, MULTILINE` —  string edited with multiline editor (GH-2323)
  • - Global filesystem hints restricted to tool scripts
  • - `String, FILE, GLOBAL` — File in global filesystem (GH-2988)
  • - `String, DIR, GLOBAL` —Directory in global filesystem (GH-2988)

- Extend directly from `Object` type (GH-2776)

Changed

- New default theme by Andreas Esau (@ndee85)

- Replaced JPEG decoding library with a new one, supporting progressive JPEG

// don't think we should mention that - Removed some extraneous prints in console

- Updated to libpng 1.5.26, fixing various upstream security issues

- SpinBoxes now repeatedly increase/decrease value when the up/down button is held

- Improved text selection in TextEdit

- PI is now a constant (GH-2134)

Fixed

- KP5 now toggles between orthogonal and perspective mode as expected in 3D view

< and > not longer get swapped in .xscn/.xml format (note that this might break some logic in 1.1-stable games that relied on the buggy behaviour) (GH-2649)

- Fix uniform scaling of non-square CanvasItem nodes (GH-3224)

Removed

- Undocumented GDScript aliases `vec2`, `mat32`, `vec3`, `mat3`, `trn`, `dict` and `function`

Sandbox

(things that might be integrated in some categories above, once sorted)

Node-specific stuff:

    - VideoPlayer:

        o add possibility to set the audio stream (GH-158)

GameDev News


26. January 2016

 

This one comes care of /r/gamedev and I have to say on first glance I am rather impressed.  This is a C++ based open sourced game engine with a WYSIWYG editor and C# scripting support.  A look at this screenshot from the Github page should get you somewhat excited:

Banshee Editor

 

The engine description direct from the author:

A modern open-source game development toolkit. It aims to provide simple yet powerful environment for creating games and other graphical applications. A wide range of features are available, ranging from a math and utility library, to DirectX 11 and OpenGL render systems all the way to asset processing, fully featured editor and C# scripting.

For game developers Banshee aims to provide a complete set of tools and APIs needed to make a game from start to finish. It provides a highly intuitive and customizable editor that is easy to use by artists, designers and programmers alike, supporting development stages from asset management, scene building, scripting to game publishing. C# scripting makes your development easier by giving you access to the entire .NET library, along with fast iterations times while being safe and easy to write. Editor is fully extensible with the help of specially developed scripting API so you may customize it for exact needs of your project.

For engine developers it aims to provide a high quality foundation to build and improve upon. Banshee runs on a powerful multi-threaded C++14 core created to take advantage of all resources modern hardware can offer. Built from ground up using modern design principles, everything is modular, layered and decoupled as much as possible, making it easier to modify, replace or add functionality. Platform specific functionality is kept at a minimum making porting as easy as possible. Additionally every non-trivial method, class and field is documented. All this combined makes Banshee a great platform to build upon, for developing higher level systems like editor tools, core enhancements like new rendering techniques and platform ports, all the way to creating fully specialized toolsets that fit your team's needs exactly.

 

Engine code looks nice and clean from the examples shown:

    RENDER_WINDOW_DESC renderWindowDesc;
    renderWindowDesc.videoMode = VideoMode(1280, 720);
    renderWindowDesc.title = "My App";
    renderWindowDesc.fullscreen = false;

    Application::startUp(renderWindowDesc, RenderSystemPlugin::DX11);
    Application::instance().runMainLoop();
    Application::shutDown();

 

The engine is currently Windows only and requires Visual Studio 2013 or 2015. I have to say by first impressions, this is certainly an interesting looking engine and one I will have to check into a bit closer if I get the chance.  Obviously it’s a 0.2 release, so expect the usual menagerie of bugs and performance issues.

If you are interested in learning more, be sure to check out the introduction video:

GameDev News


26. January 2016

 

Phong shading has been somewhat the gold standard as far as game engines go.  The Phong algorithm, named after founder Bui Tuong Phong, is an algorithm for how light interacts with a 3D surface.  With the upcoming Unity 5.4 release however, Unity will be moving from Phong to GGX shading.  For more details on GGX shading, you can read the original paper Microfacet Models for Refraction through Rough Surfaces.

 

As to why Unity is changing shader models, you can read on here, or excerpt below:

In Unity 5.3 Standard Shader we have switched to GGX as the BRDF of choice for both analytical lights such as point/directional light but also for image based lighting. Furthermore, a complete overhaul has been performed on our implementation for convolution of cube maps to achieve both accurate and noiseless results at low execution time (latter part is in Unity 5.4). The most characteristic difference between GGX and normalized Phong is that the microfacet distribution profiles associated with GGX has a higher and more narrow spike followed by a prevailing tail as we see here.

Profiles for GGX and Normalized Phong.

The impact of this on the final lit result is GGX has a brighter highlight followed by a trailing halo as shown below which gives a more realistic appearance.

Comparison between GGX and conventional normalized phong.

Cross-industry Compatible Materials

In academics physically based BRDFs use roughness as the parameter to control the microfacet distribution function. Academic roughness is defined as the root mean square slope of the profile. A common misunderstanding is that roughness maps in CG are the same as academic roughness which is not the case. The reason academic roughness is not used for texture maps or sliders is because the “blur levels” are not evenly distributed which is both very difficult to work with but also leverages the limited bit precision of a texture map poorly. To avoid confusion Unity uses smoothness instead of roughness maps where smoothness is converted into academic roughness in the shader using the formula (1-smoothness)^2. Distribution wise this is equivalent to Burley’s roughness but reversed such that the most blurry response maps to 0.0 and perfect mirror reflection maps to 1.0 which we find more intuitive.

The significance to such a standardized distribution is it allows you to import content into Unity made with external tools and achieve close/similar results. Most CG painting tools today support smoothness maps. To be clear an identical match is not guaranteed but proportionality between diffuse and specular brightness and overall blurriness of the specular reflection should be close. The following comparison shot between Unity 5 and Substance Painter was kindly provided by Wes McDermott from Allegorithmic.

As we see the visuals are very similar. I would also like to thank Wes and Allegorithmic for their collaboration and helpful iteration on this. For more details on the subject people are encouraged to check out their detailed course on PBR and Unity 5.

GameDev News


AppGameKit Studio

See More Tutorials on DevGa.me!

Month List