Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
16. September 2019


Today at CppCon, Microsoft announced they are open sourcing the Visual C++ implementation of the Standard Template Library.  Available now on GitHub and licensed under the Apache License v2.0 with LLVM Exceptions.

Details of why Microsoft have open sourced their STL implementation from the C++ team blog:

Q: Why are you doing this?

A: There are several reasons. Working on the STL in GitHub will allow our customers to follow our development as it happens, try out our latest changes, and help improve our pull requests by reviewing them. As C++ Standardization accelerates, with more large features being voted in every year, we believe that accepting major features as open source contributions will be important. (For example, C++20’s chrono and format libraries are potential candidates.) We also want to contribute back to the C++ community by making it possible to take our implementations of major features. (For example, C++17’s charconv.)

If you’re getting your hopes up that this is the first step in open sourcing more of Visual Studio, don’t get your hopes up too high!

Q: Are you going to open source anything else in the MSVC toolset?

A: We have no such plans. We chose the STL because it’s different from other MSVC libraries and the compiler. Specifically, the STL is fast-evolving and designed by the C++ Standardization Committee, unlike other MSVC libraries. (Being designed by Committee is an advantage for open sourcing! It means that we don’t need to spend any time and energy on feature design review. Implementation strategy and tactics are far more constrained, and therefore easier to review.) The STL is also relatively easy to contribute to, and somewhat loosely coupled, unlike the compiler (where, as a general rule, everything interacts with everything else).

(One exception: there are support libraries for the STL that we may open source in the future, but we have nothing to announce at this time.)

You can learn more about this open source release in the video below.

GameDev News


10. September 2019


Fanatical have just entered the book market with a number of eBook bundles on a variety of subjects including Blender, Unity, Unreal and C++ development.  In the case of the Unreal and C++ books you can even buy individual books or smaller bundle packages to suit your needs.  Additionally there are bundles on machine learning, security, blockchain, Wordpress, command line and more.

The primary bundles of interest to game developers are:

The books in this bundle are from Packt Press, which can vary massively in quality.  Several of the books have also been in prior Humble Bundles, so be sure to check your Humble library before making a purchase.  All of the above links contain an affiliate code that helps support the channel if you use them to make a purchase (and thanks if you do!). 

Learn more about the bundles in the video below.

GameDev News


17. June 2019


The nCine Engine is a C++ powered, open source MIT licensed 2D game engine that has been under development for over 7 years.  It is a lower level code based framework, although it does support Lua scripting out of the box.  The engine also integrates the ImGui framework making creating tools and UIs a breeze.  The nCine engine works on Windows, Linux, Mac and Android.

Highlighted features include:

  • ImGui debug overlay and profilers
  • Lua integration for scripting
  • OPenGL 3.3/OpenGL ES 3.0
  • Spritesheet based animated sprites
  • Scengraph based transformations
  • Particle simulation with affectors
  • Sound and music playback
  • Text rendering with kerning
  • Support for multiple texture formats
  • Profiler graphs and statistics
  • Works on multiple platforms
  • Template containers and algorithms
  • Fully C++11 compliant codebase
  • High precision monotonic timers
  • Atomic counters
  • Thread pool creation, synchronization and affinity assignment
  • Basic math lbrary for vectors, 4x4 matrices and quaternions
  • Logging system with multiple levels and console or file output
  • GLFW 3 or SDL 2 for window and input on PC
  • Joystick support with hot swap and gamepad mappings
  • Android assets support
  • Google Test based unit tests with coverage checked with Gcovr
  • Microbenchmarked with the Google Benchmark support library
  • Doxygen based documentation with Graphviz class diagrams
  • Periodically checked with Cppcheck and Valgrind
  • Periodically linted with clang-format (previously with Artistic Style and Uncrustify)
  • Instrumentation for the Tracy frame profiler

With so many game engines on the market, you may be wondering… why another one?  Well the author explains exactly that right here.  The cCine project is hosted on GitHub and provides a Pong demo to get you started, implemented in both C++ and Lua.

GameDev News Programming


3. June 2019


Raylib is an open source C based cross platform game framework released under the zlib/libpng open source license that I previously referred to as “the easiest C/C++ game framework I’ve ever found” and that description is still true today.  Raylib started life as a way to teach non-programmers game development in an accessible manner and I would say for the most part, mission accomplished.  Since that initial release, raylib has continued to improve and the just released raylib 2.5 is one of the biggest releases yet.

Details from the release notes:

  • New window management and filesystem functions to query monitor information, deal with clipboard, check directory files info and even launch a URL with default system web browser. Experimental High-DPI monitor support has also been added through a compile flag.

  • Redesigned Gamepad mechanism, now generic for all platforms and gamepads, no more specific gamepad configurations.
    Redesigned UWP input system, now raylib supports UWP seamlessly, previous implementation required a custom input system implemented in user code.

  • rlgl module has been redesigned to support a unique buffer for shapes drawing batching, including LINES, TRIANGLES, QUADS in the same indexed buffer, also added support for multi-buffering if required. Additionally, rlPushMatrix()/rlPopMatrix() functionality has been reviewed to behave exactly like OpenGL 1.1, models_rlgl_solar_system example has been added to illustrate this behaviour.

  • VR simulator has been reviewed to allow custom configuration of Head-Mounted-Device parameters and distortion shader, core_vr_simulator has been properly adapted to showcase this new functionality, now the VR simulator is a generic configurable stereo rendering system that allows any VR device simulation with just a few lines of code or even dynamic tweaking of HMD parameters.

  • Support for Unicode text drawing; now raylib processes UTF8 strings on drawing, supporting Unicode codepoints, allowing rendering mostly any existent language (as long as the font with the glyphs is provided). An amazing example showing this feature has also been added: text_unicode.

  • Brand new text management API, with the addition of multiple functions to deal with string data, including functionality like replace, insert, join, split, append, to uppercase, to lower... Note that most of those functions are intended for text management on rendering, using pre-loaded internal buffers, avoiding new memory allocation that user should free manually.

  • Multiple new shapes and textures drawing functions to support rings (DrawRing(), DrawRingLines()), circle sectors (DrawCircleSector(), DrawCircleSectorLines()), rounded rectangles (DrawRectangleRounded(), DrawRectangleRoundedLines()) and also n-patch textures (DrawTextureNPatch()), detailed examples have been added to illustrate all this new functionality.

  • Experimental cubemap support, to automatically load multiple cubemap layouts (LoadTextureCubemap()). It required some internal rlgl redesign to allow cubemap textures.

  • Skeletal animation support for 3d models, this addition implied a redesign of Model data structure to accomodate multiple mesh/multiple materials support and bones information. Multiple models functions have been reviewed and added on this process, also glTF models loading support has been added.

You can download raylib here, while the source code is available here.  In terms of learning the API, pretty much all you need to know is available on this cheatsheet.  Additionally there are a huge number of examples available (that can run in your browser) right here, each including full source code.

GameDev News


2. May 2019


OGRE, Object-oriented Graphics Rendering Engine, an open source MIT licensed 3D renderer just released version 1.12 after almost a year in development.  The release is heavily focused on internal rearchitecting for future development.

Key features from the 1.12 release:

  • #include directive supported for GLSL shaders
  • PF_DEPTH support for shadows with the RTSS and the Terrain component
  • RTSS 3.0: vastly improved internal API and refactored shader library
  • Per pixel-shading on D3D11/ GL3+/ GLES2 by default (via RTSS)
  • The GL3+ RenderSystem is now used for rendering the reference Test images
  • More precise timings for built-in profiler and support for external profiling via Remotery
  • unified API for fixed-function pipeline and shaders
  • NEON intrinsics for OptimizedMath on ARM (Android)
  • Stable Material library (Media/) that you can reference in your projects
  • the MSVC SDK now also includes the Python and Java components
  • support for loading 1.7 style terrains (aka “terrain.cfg”)

You can learn more about the release in the New and Noteworthy document available here.  Additionally the source code for OGRE is available here on GitHub.  The book mentioned in the video below that covers OGRE for game engine development is Game Engine Architecture.

GameDev News


GFS On YouTube

See More Tutorials on DevGa.me!

Month List