Tag: C#

Posted on by — Leave a comment

Raylib 3.5 Released

Eight months after the release of Raylib 3.0, Raylib 3.5 was just released. Raylib is an open source cross platform C/C++ game framework. Raylib runs on a ton of different platforms and has bindings available for more than 50 different programming languages. The Raylib 3.5 release brings the following new features.

  • NEW Platform supported: Raspberry Pi 4 native mode (no X11 windows) through DRM subsystem and GBM API. Actually this is a really interesting improvement because it opens the door to raylib to support other embedded platforms (Odroid, GameShell, NanoPi…). Also worth mentioning the un-official homebrew ports of raylib for PS4 and PSVita.
  • NEW configuration options exposed: For custom raylib builds, config.h now exposes more than 150 flags and defines to build raylib with only the desired features, for example, it allows to build a minimal raylib library in just some KB removing all external data filetypes supported, very useful to generate small executables or embedded devices.
  • NEW automatic GIF recording feature: Actually, automatic GIF recording (CTRL+F12) for any raylib application has been available for some versions but this feature was really slow and low-performant using an old gif library with many file-accesses. It has been replaced by a high-performant alternative (msf_gif.h) that operates directly on memory… and actually works very well! Try it out!
  • NEW RenderBatch system: rlgl module has been redesigned to support custom render batches to allow grouping draw calls as desired, previous implementation just had one default render batch. This feature has not been exposed to raylib API yet but it can be used by advance users dealing with rlgl directly. For example, multiple RenderBatch can be created for 2D sprites and 3D geometry independently.
  • NEW Framebuffer system: rlgl module now exposes an API for custom Framebuffer attachments (including cubemaps!). raylib RenderTexture is a basic use-case, just allowing color and depth textures, but this new API allows the creation of more advance Framebuffers with multiple attachments, like the G-Buffers. GenTexture*() functions have been redesigned to use this new API.
  • Improved software rendering: raylib Image*() API is intended for software rendering, for those cases when no GPU or no Window is available. Those functions operate directly with multi-format pixel data on RAM and they have been completely redesigned to be way faster, specially for small resolutions and retro-gaming. Low-end embedded devices like microcontrollers with custom displays could benefit of this raylib functionality!
  • File loading from memory: Multiple functions have been redesigned to load data from memory buffers instead of directly accessing the files, now all raylib file loading/saving goes through a couple of functions that load data into memory. This feature allows custom virtual-file-systems and it gives more control to the user to access data already loaded in memory (i.e. images, fonts, sounds…).
  • NEW Window states management system: raylib core module has been redesigned to support Window state check and setup more easily and also before/after Window initialization, SetConfigFlags() has been reviewed and SetWindowState() has been added to control Window minification, maximization, hidding, focusing, topmost and more.
  • NEW GitHub Actions CI/CD system: Previous CI implementation has been reviewed and improved a lot to support multiple build configurations (platforms, compilers, static/shared build) and also an automatic deploy system has been implemented to automatically attach the diferent generated artifacts to every new release. As the system seems to work very good, previous CI platforms (AppVeyor/TravisCI) have been removed.

Release notes are available here and a complete change log is available here. Binary versions of Raylib are available on Raylib.com while the source code is hosted under the ZLib license on GitHub. If you are interested in learning Raylib you can check out their community on Discord. You can also download Raylib via vcpkg on Visual Studio with step by step instructions available here. You can learn more about Raylib and the 3.5 release in the video below.

Posted on by — Leave a comment

Flax Engine Released

The Flax Engine game engine has just seen it’s 1.0 release. We’ve had our eyes on this engine since it’s first public beta in 2018, which was then followed by a few years of radio silence. The in July of 2020 we got the 0.7 release which added several new features including C++ live scripting support. With today’s release the Flax Engine is now available to everyone.

Key features include:

  • Seamless C# and C++ scripting
  • Automatic draw calls batching and instancing
  • Every asset is using async content streaming by default
  • Cross-platform support (Windows, Linux, Android, PS4. Xbox One, Xbox Series X/S, UWP…)
  • GPU Lightmaps Baking
  • Visual Scripting
  • VFX tools
  • Nested prefabs
  • Gameplay Globals for technical artists
  • Open World Tools (terrain, foliage, fog, levels streaming)
  • Hot-reloading C#/C++ in Editor
  • Full source-code available
  • Direct communication and help from engine devs
  • Lightweight development (full repo clone + compilation in less than 3 min)

Flax is available for Windows and Linux developers with the source code available on GitHub. Flax is a commercial game engine, but under fairly liberal terms. Commercial license terms are:

Use Flax for free, pay 4% when you release (above first $25k per quarter). Flax Engine and all related tools, all features, all supported platforms, all source code, all complete projects and Flax Samples with regular updates can be used for free.

If you want to learn more about Flax Engine, be sure to check out the following links:

You can learn more about the game engine and see it in action in the video below. Stay tuned for a more in-depth technical video on Flax Engine in the future.

Posted on by — Leave a comment

Wave Engine 3.1 Released

Wave Engine recently released version 3.1. Wave Engine is a completely free to use 3D game engine capable of targeting most platforms and XR devices. We have been keeping an eye on this engine since 2015 when we featured it in the Closer Look series. More recently we looked at Wave Engine again in 2019 when WaveEngine 3.0 was previewed after a long period of silence. After another long period of silence we received the 3.1 release which brings .NET 5 and C# 9 support as well as graphical improvements.

Details from a guest post on the DotNet team blog:

We are glad to announce that, aligned with Microsoft, we have just released WaveEngine 3.1 with official support for .NET 5 and C# 9. So if you are using C# and .NET 5, you can start creating 3D apps based on .NET 5 today. Download it from the WaveEngine download page right now and start creating 3D apps based on .NET 5 today. We would like to share with you our journey migrating from .NET Core 3.1 to .NET 5, as well as some of the new features made possible with .NET 5.

From .NET Core 3.1 to .NET 5

To make this possible we started working on this one year ago, when we decide to rewrite our low-level graphics abstraction API to support the new Vulkan, DirectX12 and Metal graphics APIs. At that time, it was a project based on .NET Framework with an editor based on GTK# which had problems to support new resolutions, multiscreen or the new DPI standards. At that time, we were following all the great advances in performance that Microsoft was doing in .NET Core and the future framework called .NET 5 and we decided that we had to align our engine with this to take advantage of all the new performance features, so we started writing a new editor based on WPF and .NET Core and changed all our extensions and libraries to .NET Core. This took us one year of hard work but the results comparing our old version 2.5 and the new one 3.1 in terms of performance and memory usage are awesome, around 4-5x faster.

Now we have official support for .NET 5 and this technology is ready for .NET 6 so we are glad to become one of the first engines to support it.

In the video below we review Wave Engine 3.1. All of the samples used in the video are available on GitHub. Please note this repository should not be cloned, it simply links to a different repository for each sample.

Posted on by — Leave a comment

Unigine 2.13 Released

The Unigine engine just released version 2.13. The new release includes an all new GPU based lightmapping tool, a new terrain generation tool, improved clouds, better lighting and a whole lot more. Since Unigine 2.11 there is a free community version available making Unigine a lot more viable for indie game developers.

Highlights of the release include:

  • GPU Lightmapper tool
  • Introducing SRAA (Subpixel Reconstruction Anti-Aliasing)
  • Upgraded 3D volumetric clouds
  • Performance optimizations for vast forest rendering
  • New iteration of the terrain generation tool with online GIS sources support (experimental)
  • Adaptive hardware tessellation for the mesh_base material
  • Project Build tool: extended functionality and a standalone console-based version
  • New samples (LiDAR sensor, night city lights, helicopter winch)
  • Introducing 3D scans library

For further information on the release be sure to check the much more in-depth release notes or watch the video below.

Posted on by — Leave a comment

The Machinery Game Engine Enters Open Beta

The Machinery by Our Machinery is an in development professional game engine that just entered open beta. We went hands-on with The Machinery earlier in the year when it was still in closed beta if you want an in-depth but slightly out of date hands-on experience. With the move to open beta all you need to do is register an account and download the engine to get started.

In a world dominated with game engines, what makes The Machinery unique? This engine is being developed by members behind the Stingray/BitSquid engines, used in such titles as Magicka and Warhammer Vermintide. The engine is light weight, modular and written in the C language with a focus on customizibility. Details from the open beta announcement:

If you are still wondering what The Machinery is, it’s a new lightweight and flexible game engine, designed to give you all the power of a modern engine in a minimalistic package that is easy to understand, extend, explore, rewrite, and hack. Beyond games, the API can also be used for simulations and visualizations as well as building custom tools, editors, and applications. 

 Some of the things that make The Machinery more hackable than other game engines are:

  • The Machinery’s API is written in C. It’s easy to understand without learning the complexities of modern C++. And don’t worry, you still have type-safe vectors and hash tables, just as in C++.
  • We use a modular design that is completely plugin-based. This makes it easy to extend and replace parts of the engine.
  • The engine can be stripped down to a minimalistic core. Don’t need physics, animation, or sound? Just ship the engine without those DLLs.
  • Individual DLLs can be hot-reloaded. You can modify gameplay, UI, etc, while the editor is running.
  • The codebase is small, readable and well documented.
  • We offer licenses with full source code for both small and large developers. 

You can learn more about The Machinery open beta and a quick hands-on/getting started guide in the video below.

Posted on by — Leave a comment

Drag[en]gine Hands-On

The Drag[en]gine is a highly modular, open source (C++) game engine that has been under active development for several years. The Drag[en]gine’s modular approach is built around the GLEM concept breaking your game project into the Game Script, Launcher, Engine and Modules layers. The Game Script is implemented by default in Dragonscript, another open source project available here. Drag[en]gine is open source under the LGPL license on GitHub.

If you want to get started with Drag[en]gine you can download binaries for Linux and Windows available here, it’s most likely the IGDE file you want to start with. There are a number of samples to get you started available here. You can learn more about Drag[en]gine in the video below.

Posted on by — Leave a comment

FlatRedBall Engine Review

FlatRedBall is an open source C# based game engine with development dating back to 2005. It was originally built to run on-top of Managed Direct X, then was ported to XNA and when XNA was depreciated, it was again ported to run on top of the MonoGame framework.

FlatRedBall provides a layer of APIs and tooling on top of MonoGame designed to simplify the process of creating 2D games. You can currently create games for Windows (and UWP), Android and iOS, with Mac and Linux targets currently a work in progress. The heart of the tooling is Glue, which “glues” together the various other tools, including plugins for tasks such as UI development as well as support for the Tiled 2D map editor.

FlatRedBall is open source with the source code available on GitHub under the flexible and permissive MIT open source license. You can check out FlatRedBall in action in the video below (or here on Odysee). If you are interested in learning more or encounter a problem, they have an active Discord server available here.

Posted on by — Leave a comment

Miniaudio — Open Source Single File C Audio Library

Miniaudio is a cross platform open source C library for implementing low level audio functionality including playback and capture. MiniAudio is released under either public domain or MIT No Attribution licenses and amazingly enough is implemented as a single .H file with no external dependencies (except optionally stb_orbis if Ogg Vorbis format support is desired).

Miniaudio features include:

  • Your choice of either public domain or MIT No Attribution.
  • Entirely contained within a single file for easy integration into your source tree.
  • No external dependencies except for the C standard library and backend libraries.
  • Written in C and compilable as C++, enabling miniaudio to work on almost all compilers.
  • Supports all major desktop and mobile platforms, with multiple backends for maximum compatibility.
  • Supports playback, capture, full-duplex and loopback (WASAPI only).
  • Device enumeration for connecting to specific devices, not just defaults.
  • Connect to multiple devices at once.
  • Shared and exclusive mode on supported backends.
  • Backend-specific configuration options.
  • Device capability querying.
  • Automatic data conversion between your application and the internal device.
  • Sample format conversion with optional dithering.
  • Channel conversion and channel mapping.
  • Resampling with support for multiple algorithms.
    • Simple linear resampling with anti-aliasing.
    • Optional Speex resampling (must opt-in).
  • Filters.
    • Biquad
    • Low-pass (first, second and high order)
    • High-pass (first, second and high order)
    • Second order band-pass
    • Second order notch
    • Second order peaking
    • Second order low shelf
    • Second order high shelf
  • Waveform generation.
    • Sine
    • Square
    • Triangle
    • Sawtooth
  • Noise generation.
    • White
    • Pink
    • Brownian
  • Decoding
    • WAV
    • FLAC
    • MP3
    • Vorbis via stb_vorbis (not built in – must be included separately).
  • Encoding
  • Lock free ring buffer (single producer, single consumer).

Miniaudio is available on GitHub and has solid documentation available here and several examples available here. Installation consists of downloading and #include’ing the header and that is it, making this a remarkably simple library to get started using. There are also unofficial language bindings for Go, Rust and Python available as well. You can learn more about the Miniaudio library in the video below (or view here on Odysee).

Posted on by — Leave a comment

Echo Engine Hands-On

Today we are taking a look at the open source cross platform 2D/3D C++ based Lua-powered game engine Echo. While Echo is very much it’s own engine, it has a very Godot vibe in the way your game scene is organised, taking a node based approach to game development. The engine is released under the very permissive MIT open source license.

From the project GitHub page, Echo is described as:

Echo is a new game engine, which used more industry-standard of nowadays for game development. The new design concept makes the engine simplicity to use. but more powerful. Scene manager is easy, No Entiy, No GameObject, No Component, No Prefab. Only Node and NodeTree.

In the video below we go hands-on with this active open source project. In the later half of the video we show how you can build the engine on Windows, before you begin however you will need to have Visual Studio 2019 with C++ support and CMake installed on your machine.