Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
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


22. July 2016

 

Somewhat recently Unity announced new pricing that didn’t exactly make Unity developers the world over cheer.  Then a few weeks later, they announced newer and much improved pricing.  Part of this new pricing included the ability to make the Unity splash screen optional in the Pro version and “customizable” in the Basic version.  They said:

The new splash screen will read “Made with Unity” in all editions of Unity – no more mention of “Personal Edition”. You will also be able to customize it with your own (blurred) background image and your own company logo in addition to the Unity logo. This feature is coming, but give us a bit of time to perfect the technical aspects of it before we release it. The customizable splash screen will be available in all versions of Unity, but can be completely turned off in Unity Plus and Unity Pro. We’ll have a blog post with further details later.

Well later is here and that blog post has arrived.

As you saw in our recent pricing announcements, part of our new structure allows you as a Plus or Pro subscriber to disable the Splash Screen feature of Unity. In addition to this we wanted to provide a set of simple tools to let you display a co-branded splash screen with animation, for those of you that do wish to use them.

As we still require Personal Edition users to show a Unity splash screen for now, these tools will also be available and become the default method of showing the Made with Unity splash. The tools are still in development, and are currently aimed to be part of Unity 5.5. Check out the video above for what they look like in practice, and please provide us with feedback in the comments below.

 

They also included the following video demonstrating the tool:

GameDev News


AppGameKit Studio

See More Tutorials on DevGa.me!

Month List