Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
26. July 2016

 

Today at SIGGRAPH, Allegorithmic made a couple announcements regarding their Substance texturing product lines.  We featured Substance Painter in our GameDev Toolbox series if you want more details.  Among their announcements today, the revealed that Substance Painter, Designer and B2M will be free for students for personal use.   They also announced that they will be shipping a “massive amount” of high quality content as part of their Live subscription plan.

 

From the Allegorithmic blog:

FREE SUBSTANCE PERSONAL LICENSES FOR STUDENTS

We're proud to announce that Substance Painter, Substance Designer and Substance B2M will become entirely free for students, for personal use, starting on August 4th, 2016. Teachers may also request their free personal license, and can also continue to benefit from Academic pricing to equip their school's lab/campus by contacting us. We believe that students should have access to the best tools at no cost and join our community to help us shape the future of digital art.

SUBSTANCE LIVE WITH FREE CONTENT

Substance Live will soon include a massive amount of high-quality content at no additional cost. We have partnered with selected producers to provide thousands of professional assets to all Substance Live subscribers. For $19.90 per month, subscribers will have access to the latest versions of Substance Painter, Substance Designer, Substance B2M and dozens of assets to download every month from a huge database of production-ready content. 

SUBSTANCE ACADEMY

As announced in the keynote, Substance Painter alone was launched over 1.1 million times between April 1 and June 30, 2016. The number of people learning and using Substance products is greater than ever, as is the need for tutorials and training. To help users everywhere learn Substance inside out, Substance Academy will launch on the Allegorithmic website in the near future. This free online learning resource will feature tutorials, videos, assets and more for users at all levels who want to learn Substance at their own pace. 

SCAN WORKFLOW

Capturing data via 3D scanning or photogrammetry has now become a mature technique. Numerous initiatives are underway at Allegorithmic to streamline the management and processing of scanned data within the Substance toolset. We are currently working with a number of partners and clients to make this workflow as seamless as possible. You can see a demo in the keynote above beginning at 22m35s.

GameDev News

26. July 2016

 

Today at SIGGRAPH 2016, Autodesk announced updates to both their Stingray game engine and Maya LT, the indie focused version of their Maya content creation application.  The Stingray Game Engine updates mostly revolve around VR support, including improved Vive and Rift support.  Maya LT 2017 gets an updated UI, improved Viewport performance, a shape authoring tool and more. 

 

Full press release:

 

Autodesk Upgrades VR Capabilities and 3D Animation Tools for Indie Game Developers at SIGGRAPH 2016
San Francisco, CA (July 26, 2016)
-- At SIGGRAPH 2016, Autodesk unveiled its latest version of 3D animation and modeling software for indie game developers (Autodesk Maya LT 2017), as well as Autodesk Stingray 1.4, the newest version of its powerful 3D game engine and real-time rendering solution.
One of the most significant updates for Maya LT is the time editor, a new tool which helps indie game developers streamline animation of complex characters. Additional updates include improvements to existing animation tools and a newmayaStingray way to organize the tools and user interface (UI) into customized workspaces.
“Subscribing to Maya LT allows us to equip a growing team more easily, and always have the most up-to-date tools available" Sam Abbott, COO, Compulsion Games.

Additional highlights include:

Autodesk Maya LT 2017 Additional Features:
-- An updated graph editor has many new features including a UI/UX refresh that simplifies day-to-day tasks.
-- Shape authoring tool improvements in Maya LT provide artists with more control to create, tweak, and correct animations in a very detailed way.
-- Viewport 2.0 improvements facilitate faster selection performance for scenes with large numbers of nodes and scenes containing hidden objects.
-- Vertex order transfers and corrections make it easier to work between different game creation tools, without losing data as an asset moves through the pipeline.

Autodesk Stingray 1.4 Additional Features:
-- The Stingray 1.4 release offers improved VR capabilities and enhanced connectivity with Maya LT, facilitating a powerful art-to-engine workflow for game developers.
-- Improved support for VR platforms includes compatibility with the Oculus Rift SDK v1.3 and the SteamVR SDK v0.9.19.
-- Flow scripting for HTC Vive controllers offers a faster and more efficient way to add interactivity to VR experiences, while simplifying the process for designers to create and test their prototypes.
-- Unique to Stingray, support for WebGL2 enables developers to test their projects on WebGL2 supported browsers.
-- Level sync, with Maya LT, enables artists to link and export entire scenes directly to Stingray. This creates an easier way to build, iterate, review and change game levels and design scenes, without having to manually reproduce layouts in two tools.
-- Easier asset share between different Stingray projects further benefits collaborative work environments.
-- NavMesh improvements for better AI behavior.
-- Edit UV scale and offset values in materials exported from Maya LT allows users to continue edit UV tiling in Stingray.


Maya LT 2017 is available globally via subscription. Subscribers of Maya LT receive access to Stingray 1.4 as part of their subscription. For more information, visit Maya LT or Stingray on Autodesk.com .

GameDev News

25. July 2016

 

BDX can best be though of as a mashup between Blender and LibGDX, a game engine built on top of the LibGDX framework, directly integrated inside the Blender application.  This enables you to create levels directly in Blender and take advantage of Blender features such as physics, but code your game using Java and LibGDX.  I took a look at a very early version of the engine available here and it’s come a long way since.

 

Version 0.25 is primarily a bug fix release, but brings some new features to the table.  From the /r/gamedev announcement:

 

  • Render-to-texture is now supported.
  • GameObjects can now be invisible on select cameras, simply by adding a reference to the GameObject to the camera's "ignoreObjects" list. This, when combined with render-to-texture support, allows for some nice shader effects.
  • Texture loading and texture switching on Materials is now supported.
  • A new Mesh class has been added, allowing you to easily alter vertex information for GameObjects' meshes.
  • Fog / mist is now fully supported.
  • Support for a Viewport has been added to allow you to tweak how your game scales onscreen.
  • Many bug-fixes, and other tiny added features.

For more detail, see the commit log over on GitHub.

 

It’s a cool engine, one I highly recommend you check out if Blender is core to your workflow.

GameDev News ,

24. July 2016

 

Traditionally I don’t recommend beginners start with C++.  There are a number of reasons behind this opinion, most of which are explained in this video.  Most of the reasons however have very little to do with the language itself (which does of course have some downsides) and more to do with the build system, linker and limited included libraries.  I recently discovered a library aimed at beginners that alleviates a great deal of the downsides of learning using C++, raylib.  It’s free, open source (available on Github) and provides most of the functionality you require to make a game.  Most importantly, it’s aimed at beginners meaning the library is easy to use and comes with a turn key installer that enables you to hit the ground running.

If you are interested in learning more about raylib, be sure to watch this video (also embedded below).

 

The key features of raylib are:

- Written in plain C code (C99)
- Uses C# PascalCase/camelCase notation
- Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES 2.0)
- Unique OpenGL abstraction layer (usable as standalone module): [rlgl]
- Powerful fonts module with SpriteFonts support (XNA fonts, AngelCode fonts, TTF)
- Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
- Basic 3d support for Geometrics, Models, Heightmaps and Billboards
- Materials (diffuse, normal, specular) and Lighting (point, directional, spot)
- Shaders support, including Model shaders and Postprocessing shaders
- Powerful math module for Vector and Matrix operations [raymath]
- Audio loading and playing with streaming support (WAV, OGG, XM, MOD)
- VR stereo rendering support with configurable HMD device parameters
- Multiplatform support: Android, Raspberry Pi, HTML5, Oculus Rift CV1
- Custom color palette for fancy visuals on raywhite background
- Minimal external dependencies (GLFW3, OpenGL, OpenAL)

 

The part I found most impressive though is the installer.  It comes with a pre-configured version of the MingW compiler and Notepad++ set up for development right away.  Basically you run the installer, open notepad++, start writing code and hit F6 to run it.  No dealing with setting up a compiler, learning about linkers and all the various things that make the C++ learning curve so painful.  Well, most of the things...

 

I should point out quickly, while I’ve been calling it a C++ library, it’s actually a C library.  This is a minor distinction as it is perfectly usable in C++ and feels like C++.  It comes with a copious amount of examples, with very easy to understand code.  Here for example is an, um, example that illustrates loading and drawing images:

/********************************************************************************
***********
*
*   raylib [textures] example - Image loading and drawing on it
*
*   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU 
memory (VRAM)
*
*   This example has been created using raylib 1.4 (www.raylib.com)
*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h 
for details)
*
*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
*
*********************************************************************************
***********/

#include "raylib.h"

int main()
{
    // Initialization
    //---------------------------------------------------------------------------
    -----------
    int screenWidth = 800;
    int screenHeight = 450;

    InitWindow(screenWidth, screenHeight, "raylib [textures] example - image 
    drawing");

    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context 
    is required)

    Image cat = LoadImage("resources/cat.png");             // Load image in CPU 
    memory (RAM)
    ImageCrop(&cat, (Rectangle){ 100, 10, 280, 380 });      // Crop an image 
    piece
    ImageFlipHorizontal(&cat);                              // Flip cropped 
    image horizontally
    ImageResize(&cat, 150, 200);                            // Resize flipped-
    cropped image
    
    Image parrots = LoadImage("resources/parrots.png");     // Load image in CPU 
    memory (RAM)
    
    // Draw one image over the other with a scaling of 1.5f
    ImageDraw(&parrots, cat, (Rectangle){ 0, 0, cat.width, cat.height }, (
    Rectangle){ 30, 40, cat.width*1.5f, cat.height*1.5f });
    ImageCrop(&parrots, (Rectangle){ 0, 50, parrots.width, parrots.height - 100 }
    ); // Crop resulting image
    
    UnloadImage(cat);       // Unload image from RAM

    Texture2D texture = LoadTextureFromImage(parrots);      // Image converted 
    to texture, uploaded to GPU memory (VRAM)
    UnloadImage(parrots);   // Once image has been converted to texture and 
    uploaded to VRAM, it can be unloaded from RAM
    
    SetTargetFPS(60);
    //---------------------------------------------------------------------------
    ------------

    // Main game loop
    while (!WindowShouldClose())    // Detect window close button or ESC key
    {
        // Update
        //-----------------------------------------------------------------------
        -----------
        // TODO: Update your variables here
        //-----------------------------------------------------------------------
        -----------

        // Draw
        //-----------------------------------------------------------------------
        -----------
        BeginDrawing();

            ClearBackground(RAYWHITE);

            DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 
            - texture.height/2 - 40, WHITE);
            DrawRectangleLines(screenWidth/2 - texture.width/2, screenHeight/2 - 
            texture.height/2 - 40, texture.width, texture.height, DARKGRAY);

            DrawText("We are drawing only one texture from various images 
            composed!", 240, 350, 10, DARKGRAY);
            DrawText("Source images have been cropped, scaled, flipped and 
            copied one over the other.", 190, 370, 10, DARKGRAY);

        EndDrawing();
        //-----------------------------------------------------------------------
        -----------
    }

    // De-Initialization
    //---------------------------------------------------------------------------
    -----------
    UnloadTexture(texture);       // Texture unloading

    CloseWindow();                // Close window and OpenGL context
    //---------------------------------------------------------------------------
    -----------

    return 0;
}

 

All examples are a single .c file and there are plenty of them.  All you need to do is open them in Notepad++ and hit F6 to run.

 

At the end of the day, I still don’t personally think C++ is the ideal language to learn game programming, or programming in general.  However if you are going to start using C++, raylib is the single best starting point I have ever seen.  In fact, let me know if you would be interested in a beginner C++ tutorial series built around this library, let me know!

 

The Video

Programming

23. July 2016

 

Khronos Group, the organizational body behind OpenAL, OpenCV, OpenGL and it’s successor Vulkan, have just released Vulkan-hpp on Github.

Khronos introduces Vulkan Hpp, an open source Vulkan C++ API. Vulkan is a C API and as such inherits all common pitfalls of using a general C programming library. The motivation of a low-level Vulkan C++ API is to avoid these common pitfalls by applying commonly known C++ features while keeping the overall structure of a Vulkan program and preserving the full freedom it provides as low-level graphics API

 

As the description says, it’s a C++ API over top of the C based Khronos API.  The design goal is to add no additional overhead over using the C API, implemented entirely using header files.  Some of the headline features are:

  • Type-safe enums
  • Improvements to Bit Flags
  • String Conversions
  • Alternative Initialization of Structs
  • Enhancements beyond native Vulkan
  • Exceptions and Returns Types

 

There are a collection of C Vulkan examples ported to the new C++ wrapper available here.

 

To get started with Vulkan-Hpp:

  • Clone the repository: git clone https://github.com/KhronosGroup/vkcpp
  • Update submodules: git submodule update --init --recursive
  • Use CMake to generate a solution or makefile for your favourite build environment
  • Launch the build

 

Vuklan-Hpp is available for download on Github here.

GameDev News

Month List

Popular Comments

Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
3. April 2016

 

Allegro, a cross platform C++ based 2D game engine, just released version 5.2.0.  This release is source compatible with prior releases, but is not binary compatible.  The following changes occurred in this release:

Core:

  • Add al_is_event_source_registered (koro).

  • Make destructors log messages more meaningful.

  • Mouse emulation API for touch devices is now unstable.

  • Rename al_convert_bitmaps to al_convert_memory_bitmaps.

Input:

  • Haptic API is now unstable.

Android port:

  • Fixed bogus display destruction on Android which previously caused zombie states.

OSX port:

  • Fix OSX mouse state position scaling.

  • Fix other various scaling issues.

  • Make toggling ALLEGRO_FRAMELESS work.

  • Fix an issue where fullscreen windows would occasionally leave empty space for the titlebar.

  • Fix incorrect debug assert in the audio addon.

Windows port:

  • Make Allegro apps DPI-aware by default, which means that they won't be scaled by the OS.

  • Fix compilation for the CPU detection code on some compilers.

  • Don't sync the D3D bitmap when locking with WRITE_ONLY.

  • Remove dsound.dll runtime loading.

  • Don't link xinput and d3dx9 libraries (they are still required at runtime though if you're using the relevant features).

  • Fix a bug where al_wait_for_event_timed can block despite 0 timeout (Aldo Nunez).

Build system:

  • Install PDB files when building with MSVC.

Documentation:

  • Fix source links for API entries with multi-line prototypes.

  • Make the readme look prettier on GitHub.

  • Tons of assorted documentation improvements, especially for the audio addon.

Other:

  • Add a stability system where some unstable APIs need to be opted into by defining ALLEGRO_UNSTABLEbefore including Allegro headers.

Audio addon:

  • Fix sporadic deadlocks

  • Recorder API is now unstable.

Native dialog addon:

  • al_toggle_menu_item_flags is now unstable.

TTF addon:

  • Add an option to pre-cache the glyphs, useful for platforms where the current algorithm is buggy (typically some Android devices).

Video addon:

  • Temporarily remove FFmpeg backend, as it was too buggy, didn't build and was too hard to fix.

Examples:

  • Make ex_vsync less likely cause a seizure.

  • Make ex_draw_bitmap and ex_touch_input switch in/out on Android.

  • Add documentation to ex_bitmap (Daniel Johnson).

  • Improve ex_logo text entry experience.

The full change log is available here, Allegro can be downloaded here.

GameDev News

3. April 2016

 

Wave Engine, a cross platform C# powered 2D/3D engine I reviewed recently, just released version 2.1 codenamed Hammerhead Shark.

hh

 

This release brings several new features including:

  • New profile system.
  • Visual Editor Offline mode.
  • Project Upgrader Tool.
  • Spine upgrade.
  • TileMap upgrade.
  • iOS Storyboard support.
  • Static entities on Visual Editor.
  • Non-serializable entities.

 

You can read the entire release notes here.

This release actually happened earlier in the week, but my complete refusal to post any news posts of any kind during April Fools day delayed this announcement slightly.

GameDev News ,

31. March 2016

 

After weeks of preview release, the final release of Unreal Engine 4.11 is here.  This release brings a large number of new features and improvements including:image_6

  • performance and multithreading improvements
  • realistic hair shading
  • realistic eye shading
  • improve skin shading
  • realistic cloth shading (shown right) 
  • capsule (soft) shadows
  • particle depth of field
  • dithered opacity mask
  • dithered LOD crossfades
  • improved hierarchical LOD
  • VR instanced stereo rendering
  • fast physics simulation for characters (Anim Dynamics)
  • live animation recording from gameplay
  • higher quality depth of field
  • platform/sdk updates (Oculus Rift, Steam, nVidia, PlayStation, etc)
  • improved DirectX12 support and DX12 for Xbox One support
  • Metal rendering on MacOS
  • Fast lighting builds
  • Lightmass portals
  • animation pose copying
  • LOD bone reduction tool
  • particle cutouts
  • stereo spatialization
  • sound focus (sound positioning angles)
  • sound occlusion
  • sound concurrency options
  • marker based animation syncing
  • curve blending for animation montages
  • hierarchical LOD outline
  • complex text rendering (experimental)
  • advanced blueprint searching
  • VR head mounted display camera improvements
  • VR Stereo Layers
  • improvements on animation sequencer
  • much, much more.

 

You can read the full release notes here.  As always, the newest version can be downloaded using the Epic Game Launcher.

GameDev News ,

31. March 2016

 

Microsoft recently acquired Xamarin, the company that makes it possible to port .NET applications to Android and iOS devices.  Ever since that announcement I have been waiting for Microsoft to announce that Xamarin was going to be made free.  That just happened:Ce41KLVW4AATnDB

 

“We are pleased to announce that we will be making Xamarin available free of charge for Visual Studio developers”

 

This includes all tiers, including the free tier.  Xamarin Studio for the Mac will also be available as part of MSDN, as well as a free Mac based Xamarin Studio.

 

On top of this announcement, the Xamarin platform is going open source.  This now makes the entire .NET framework open source and completely cross platform.   More details as I find them.

 

A quick trip to the Xamarin Store ( spotted by keen eyed Twitter user @sol_proj ), shows a quick update:

image

 

As you can see from the pricing above, some features in Professional and Enterprise will still have a price tag attached.  They are mostly enterprise focused features and should not affect game developers.

 

Microsoft announced that the Xamarin open source release would be part of the .NET Foundation along side such projects as Roslyn and Xamarin.Auth.  Given that both projects are currently released under the Apache V2 license, it’s a good bet that the entire Xamarin package will be as well.

 

EDIT – It appears my guess about the license may be wrong.  According to this post ( thanks Mario ), Xamarin have relicensed Mono to use the MIT license:

At Microsoft Build today, we announced that we are re-releasing Mono under the MIT license and have contributed it to the .NET Foundation. These are major news for Mono developers and contributors, and I am incredibly excited about the opportunities that this will create for the Mono project, and for other projects that will be able to benefit from this.

Mono Runtime Released under MIT License

While Mono’s class libraries have always been available under the MIT license, the Mono runtime was dual-licensed. Most developers could run their apps on Windows, Linux or Mac OS X on the LGPL version of the runtime, but we also offered Mono’s runtime under commercial terms for scenarios where the LGPL was not suitable.

Moving the Mono runtime to the MIT license removes barriers to the adoption of C# and .NET in a large number of scenarios, embedded applications, including embedding Mono as a scripting engine in game engines or other applications.

 

Mono is the underlying cross platform implementation of the .NET runtime that Xamarin is built over top of.  Of course this doesn’t mean that the Xamarin suite itself is going to be MIT as well.  Regardless, both the MIT license and Apache license are incredibly permissive, so it shouldn’t be a big deal either way.

 

For those that prefer their news in video form, here it is:

GameDev News

30. March 2016

 

I just recently took an in-depth look at Cocos Creator, an open source JavaScript powered 2D game engine with full editor.  They just hit the milestone release of Cocos Creator 1.0.

 

So, what’s in this release?

  1. A better coding environment
  2. A reliable native development and publishing workflow
  3. New UI elements: EditBox and Grid Layout
  4. Spine skeleton animation and Tiled Map support

 

More details of the release are available here.  Or you can see an earlier version of Cocos Creator in action in the video below.

 

GameDev News

Month List

Popular Comments