The Forge Cross-Platform Rendering Framework PC Windows, Linux, Ray Tracing, macOS / iOS, Android, XBOX, PS4, PS5, Switch, Quest 2

Overview

The Forge is a cross-platform rendering framework supporting

  • PC
    • Windows 10 / 7
      • with DirectX 12 / Vulkan 1.1
      • with DirectX Ray Tracing API
      • DirectX 11 Fallback Layer for Windows 7 support
    • Linux Ubuntu 18.04 LTS with Vulkan 1.1 and RTX Ray Tracing API
  • Android Pie or higher with
    • Vulkan 1.1
    • OpenGL ES 2.0 fallback for large scale business application frameworks
  • macOS / iOS / iPad OS with Metal 2.2 and M1 support
  • Quest 2 using Vulkan 1.1
  • XBOX One / XBOX One X / XBOX Series S/X *
  • PS4 / PS4 Pro *
  • PS5 *
  • Switch using Vulkan 1.1 *

*(only available for accredited developers on request)

Particularly, the graphics layer of The Forge supports cross-platform

  • Descriptor management. A description is on this Wikipage
  • Multi-threaded and asynchronous resource loading
  • Shader reflection
  • Multi-threaded command buffer generation

The Forge can be used to provide the rendering layer for custom next-gen game engines. It is also meant to provide building blocks to write your own game engine. It is like a "lego" set that allows you to use pieces to build a game engine quickly. The "lego" High-Level Features supported on all platforms are at the moment:

  • Resource Loader as shown in 10_PixelProjectedReflections, capable to load textures, buffers and geometry data asynchronously
  • Lua Scripting System - currently used in 06_Playground to load models and textures and animate the camera and in several other unit tests to cycle through the options they offer during automatic testing.
  • Animation System based on Ozz Animation System
  • Consistent Math Library based on an extended version of Vectormath with NEON intrinsics for mobile platforms
  • Extended version of EASTL
  • Consistent Memory Managament:
  • Input system with Gestures for Touch devices based on an extended version of gainput
  • Fast Entity Component System based on flecs
  • Cross-platform FileSystem C API, supporting disk-based files, memory streams, and files in zip archives
  • UI system based on imGui with a dedicated unit test extended for touch input devices
  • Shader Translator using a superset of HLSL as the shader language, called The Forge Shading Language. There is a Wiki page on The Forge Shading Language
  • Various implementations of high-end Graphics Effects as shown in the unit tests below

Please find a link and credits for all open-source packages used at the end of this readme.

Twitter Join the Discord channel at https://discord.gg/hJS54bz

Twitter Join the channel at https://twitter.com/TheForge_FX?lang=en

The Forge Interactive Inc. is a Khronos member

Build Status

  • Windows Build status
  • macOS Build Status

News

Release 1.51 - December 21st, 2021 - ECS uses flecs | Better Borderless Window | Descriptor Management improvements | sRGB | Android Game Development Extensions | FSL Improvements | Ray Tracing | Meshoptimizer | Buildbox | Lethis



Happy Holidays! 🎄🎅🔥🎁🧨

We wish you and your loved ones all the best for the Holidays and a Happy New Year 2022!


This update is again a mixture of things we learned while integrating The Forge and feedback and contributions from our users. Thanks for all the support!

In one of the next updates we will remove EASTL and offer dedicated containers compatible with C99. Over time EASTL was a huge productivity burner. The inefficient memory access patterns hugged too much CPU time in games where we integrated TF and we always had to go back and fix those later manually. We know this is a breaking change but considering that STL was a good idea on CPUs 20+ years ago, we would like to align more with what modern CPUs are expecting.

  • We keep moving towards C99 usage. We replaced the old ECS code with Flecs:

flecs

Now our build times are much better and the overall system runs faster:

CPU: Intel i7-7700k
GPU: AMD Radeon RX570

Old ECS
Debug
Single Threaded: 90.0ms 
Multi Threaded 29.0ms

Release:
Single Threaded: 5.7ms
Multi Threaded: 2.3ms


flecs
Debug
Single Threaded: 23.0ms   
Multi Threaded 6.8ms

Release
Single Threaded 1.7ms
Multi Threaded 0.9ms
  • Descriptor Management improvements - we changed the rendering interface for all platforms - cmdBindPushConstants now takes an index instead of a name, we also allow partial updates of array descriptors

  • Borderless window - there are improvements to borderless windows support

    • remove borderless window "top white bar" on Windows OS
    • add "Win Key + arrow" behavior (for standard maximize/minimize/split of the borderless window using keyboard)
    • top resize area necessarily overlaps rendering (this is how we can remove the top white bar)
  • FSL improvements

    • incremental shader generation and build with header dependencies
    • improved error reported by extending line directives, errors now show up at the correct line in source fsl file
    • extended matrix column/row access functions for all targets
    • vec type padding to match our math lib datatypes
  • sRGB - all examples should be now more correct when it comes to linear lighting and sRGB

  • Android Game Extension usage: in one of our AAA game engine projects, we are now using successfully for the first time Android Game Extensions. So we also brought it to The Forge.

    Android Game Extension

    We redid a lot of the Android development setup to streamline the experience a bit. We still use Visual Studio 2017 because it allows to be more productive compared to other IDEs. Two years ago we went back and forth between IDEs but concluded that the only IDE that we could efficiently integrate into our Jenkins testing setup was Visual Studio. Please check out the new Readme below and let us know if we missed anything.

  • Vulkan: moved to KHR ray tracing extensions. Upgraded max spec to Vulkan SDK 1.2.162 and tested ray tracing support on an AMD RX 6700 XT GPU

  • meshoptimizer - somehow the integration of meshoptimizer "got lost" over time and we just re-integrated it into the resource loader. Here are some numbers that we got

meshoptimizer on various art assets meshoptimizer improvements

  • Buildbox

The game engine BuildBox is now using The Forge (click on Image to go to Buildbox website):

BuildBox

  • Lethis

The game Lethis Path of Progress uses The Forge now (click on image to go to the Steam Store)

Lethis

Release 1.50 - October 13, 2021 - M²H uses The Forge | Unlinked Multi GPU Support | Central Config.h | glTF Viewer improvements | Scalar High Precision Math

  • M²H uses The Forge for Stroke Therapy - M²H is a medical technology company. They developed a physics-based video game therapy solution that is backed by leading edge neuroscience, powered by Artificial Intelligence and controlled by dynamic movement – all working in concert to stimulate vast improvement of cognitive and motor functions for patients with stroke and the aged. The Forge provides the rendering layer for their application. Here is a YouTube video on what they do:

M²H on YouTube

  • Unlinked multiple GPU Support: for professional visualization applications, we now support unlinked multiple GPU. A new renderer API is added to enumerate available GPUs. Renderer creation is extended to allow explicit GPU selection using the enumerated GPU list. Multiple Renderers can be created this way. The resource loader interface has been extended to support multiple Renderers. It is initialized with the list of all Renderers created. To select which Renderer (GPU) resources are loaded on, the NodeIndex used in linked GPU configurations is reused for the same purpose. Resources cannot be shared on multiple Renderers however, resources must be duplicated explicitly if needed. To retrieve generated content from one GPU to another (e.g. for presentation), a new resource loader operation is provided to schedule a transfer from a texture to a buffer. The target buffer should be mappable. This operation requires proper synchronization with the rendering work; a semaphore can be provided to the copy operation for that purpose. Available with Vulkan and D3D12. For other APIs, the enumeration API will not create a RendererContext which indicates lack of unlinked multi GPU support.

  • Config.h: We now have a central config.h file that can be used to configure TF.

    • Created config files:
Common_3/OS/Core/Config.h
Common_3/Renderer/RendererConfig.h
Common_3/Renderer/{RenderingAPI}/{RenderingAPI}Config.h
    * Modified PyBuild.py
        * Proper handling of config options.
        * Every config option has --{option-name}/--no-{option-name} flag that uses define/undef directives to enable/disable macros. 
        * Macros are guarded with ifndef/ifdef.
        * Updated Android platform handling
      * Deleted Common_3/Renderer/Compiler.h. It's functionality was moved into Config.h
      * Moved all macro options to config files
      * Renamed USE_{OPTON_NAME} to ENABLE_{OPTION_NAME}
      * Changed some macros to be defined/not defined instead of having values of 0 or 1.
      * Deleted all DISABLE_{OPTION_NAME} macros
      * When detecting raytracing replaced ENABLE_RAYTRACING with RAYTRACING_AVAILABLE. This was done, because not all projects need raytracing even if it is available. RendererConfig.h defines ENABLE_RAYTRACING macro if it is available. So, it can be commented out in singular place instead of searching for it for every platform
      * Removed most of the macro definitions from build systems. Some of the remaining macros are:
        * Target platform macros: NX64, QUEST_VR
        * Arm neon macro ANDROID_ARM_NEON.
        * Windows suppression macros(like _CRT_SECURE_NO_WARNINGS)
        * Macros specific to gainputstatic
  • glTF viewer improvements:
    • sRGB fixes
    • IBL support now with prefiltered CCO/public domain cube maps
    • TAA support on more platforms and fixes
    • Vignette support

glTF Viewer running on Android Galaxy Note 9 glTF Viewer running on Android Galaxy Note 9

glTF Viewer running on iPhone 7 glTF Viewer running on iPhone 7

glTF Viewer running on Linux with NVIDIA RTX 2060 glTF Viewer running on Linux with NVIDIA RTX 2060

glTF Viewer running on Mac Mini M1 glTF Viewer running on Mac Mini M1

glTF Viewer running on PS5 glTF Viewer running on PS5

glTF Viewer running on Switch glTF Viewer running on Switch

glTF Viewer running on XBOX One Original glTF Viewer running on XBOX One Original

  • Specialization/Function constants support on Vulkan and Metal only - these constants get baked into the micro-code during pipeline creation time so the performance is identical to using a macro without any of the downsides of macros (too many shader variations increasing the size of the build).

Good read on Specialization constants. Same things apply to function constants on Metal

https://arm-software.github.io/vulkan_best_practice_for_mobile_developers/samples/performance/specialization_constants/specialization_constants_tutorial.html

Declared at global scope using SHADER_CONSTANT macro. Used as any regular variable after declaration

Macro arguments:

#define SHADER_CONSTANT(INDEX, TYPE, NAME, VALUE)

Example usage:

SHADER_CONSTANT(0, uint, gRenderMode, 0);
// Vulkan - layout (constant_id = 0) const uint gRenderMode = 0;
// Metal  - constant uint gRenderMode [[function_constant(0)]];
// Others - const uint gRenderMode = 0;

void main()
{
    // Can be used like regular variables in shader code
    if (gRenderMode == 1)
    {
        // 
    }
}
  • Resolved GitHub Issues
    • #206 - Executing Unit Tests on Mac OS 10.14 gives a Bad Access error
    • #209 - way to read texture back from GPU to CPU - this functionality is now in the resource loader
    • #210 - memory allocation challenge - not an issue
    • #212 - Question: updating partial uniform data on OpenGLES backend - not possible with OpenGL ES 2.0 run-time
    • #219 - Question : way to support Vulkan SpecializationInfo? - support is now in the code base see above

Release 1.49 - September 09, 2021 - Quest 2 Support | Apple M1 support

  • Quest 2 Support - after working now for the last 4 years on various Quest projects, we decided to add Quest 2 support to our framework.
  • Quest 2 running 01_Transformations Quest 2 Running 01_Transformations

    Quest 2 running 09_ShadowPlayground Quest 2 Running 09_ShadowPlayground

  • At this moment the following unit tests do not work:
    • 07_Tessellation: Tesselation is not supported when using Multiview. Unit test has been removed from Quest solution file.
    • 10_ScreenSpaceReflections: Lots of artifacts.
    • 14_WaveIntrinsics: Wave intrinsics are not supported.
  • Apple M1 support - we are testing now on a M1 iMac and a M1 iPad Pro. Unfortunately we have crashes in one unit test and all the more complex examples and middleware.
  • iMac with M1 chip running at 3840x2160 resolution iMac with M1 Running 10_PerPixelProjectedReflections

    iPad with M1 chip running with 1024x1366 resolution iPad with M1 Running 10_PerPixelProjectedReflections

    It is astonishing how well the iPad with M1 chip perform. Due to -what we consider driver bugs- M1 hardware crashes in

    • Aura
    • 16_raytracing
    • Visibility Buffer
    • Ephemeris
  • UI / Fonts / Lua interface refactor
    • Moved Virtual Joystick to IInput.h / InputSystem.cpp
    • Pulled current Lua implementation out of AppUI and gave it its own interface (IScripting.h)
    • Pulled Fontstash implementation out of AppUI and gave it its own interface (IFont.h)
    • IFont and IScripting are now initialized on the OS Layer, with user customization functions available on the App Layer
    • Fonts and Lua can now be disabled via preprocessor defines and UI will still function (using default 'ProggyClean' font)
  • Zip unit test refactor to support encryption and writes into archive
  • For one of our customer projects we need password encryption, so we replaced our old zip library with

    minizip ng

  • Extended iOS Gesture / Android gesture support
  • For the same project we added more gesture support for mobile platforms.
  • Partial C99 rewrite of OS/Interfaces headers and implementation files
  • Our on-going effort to make TF easier to use is to rewrite parts in C99, so that teams can work with it more efficiently, the compile time goes down as well as the memory footprint is smaller.
  • OpenGL ES 2 - Unit test 17 is now working as well.
  • GitHub fixes:
    • Pull Request "Fix typo" #199
    • Pull Request "Fix iOS Xcode OpenGL ES Error breakpoint crash" #202
    • Pull Request "Reduce GL ES buffer allocation frequency" #204
    • Pull Request "Apple silicon m1 fixes" #208

See the release notes from previous releases in the Release section.

PC Windows Requirements:

  1. Windows 10

  2. Drivers

  • AMD / NVIDIA / Intel - latest drivers
  1. Visual Studio 2017 with Windows SDK / DirectX (you need to get it via the Visual Studio Intaller)
  • Base version:

    • The minimum Windows 10 version is 1803.
    • The minimum SDK version is 1803 (10.0.17134.12).
  • To use Raytracing:

    • The minimum Windows 10 version is 1809.
    • The minimum SDK version is 1809 (10.0.17763.0).

https://developer.microsoft.com/en-us/windows/downloads/sdk-archive

  1. The Forge supports now as the min spec for the Vulkan SDK 1.1.82.0 and as the max spec 1.2.162

  2. The Forge is currently tested on

  • AMD 5x, VEGA GPUs (various)
  • NVIDIA GeForce 9x, 10x. 20x GPUs (various)

macOS Requirements:

  1. macOS min spec. 10.15.7

  2. Xcode 12.1

  3. The Forge is currently tested on the following macOS devices:

  • iMac with AMD RADEON 580 (Part No. MNED2xx/A)
  • iMac with M1 macOS 11.6

At this moment we do not have access to an iMac Pro or Mac Pro. We can test those either with Team Viewer access or by getting them into the office and integrating them into our build system. We will not test any Hackintosh configuration.

iOS Requirements:

  1. iOS 14.1

  2. XCode: see macOS

To run the unit tests, The Forge requires an iOS device with an A9 or higher CPU (see GPU Processors or see iOS_Family in this table iOS_GPUFamily3_v3). This is required to support the hardware tessellation unit test and the ExecuteIndirect unit test (requires indirect buffer support). The Visibility Buffer doesn't run on current iOS devices because the texture argument buffer on those devices is limited to 31 (see Metal Feature Set Table and look for the entry "Maximum number of entries in the texture argument table, per graphics or compute function") , while on macOS it is 128, which we need for the bindless texture array.

We are currently testing on

  • iPhone 7 (Model A1778)
  • iPhone Xs Max (Model MT5D2LL/A)

iPad OS Requirements:

  1. iPadOS 14

  2. XCode: see macOS

We are currently testing on:

  • iPad (Model A1893)
  • iPad Pro with M1 with 14.7.1

PC Linux Requirements:

  1. Ubuntu 18.04 LTS Kernel Version: 4.15.0-20-generic

  2. GPU Drivers:

  1. Workspace file is provided for codelite 12.0.6

  2. Vulkan SDK Version 1.1.108: download the native Ubuntu Linux package for all the elements of the Vulkan SDK LunarG Vulkan SDK Packages for Ubuntu 16.04 and 18.04

  3. The Forge is currently tested on Ubuntu with the following GPUs:

  • AMD RADEON RX 480
  • AMD RADEON VEGA 56
  • NVIDIA GeForce 2070 RTX

Android Requirements:

  1. Android Phone with Android Pie (9.x) for Vulkan 1.1 support
  2. Visual Studio 2017
  3. Android API level 23 or higher

At the moment, the Android run-time does not support the following unit tests due to -what we consider- driver bugs or lack of support:

  • 09_LightShadowPlayground
  • 09a_HybridRayTracing
  • 11_MultiGPU
  • 16_RayTracing
  • 16a_SphereTracing
  • 18_VirtualTexture
  • 32_Window
  • 35_VariableRateShading
  • Visibility Buffer
  • Aura
  • Ephemeris
  1. We are currently testing on

Setup Android Environment

  • Download and install .NET Core SDK 2.2
  • Download and Install Android Game Development Extension (Version 21.1.51) (AGDE Quickstart)
  • After AGDE installation, open the SDK Manager from the toolbar and:
    • Install SDK
    • Install Android NDK r21e (21.4.7075529) The versions might not be visible so be sure to check the "Show Package Details" option.
    • Set ANDROID_SDK_ROOT environment variable to point at the installed SDK

Steps if You want to create a new Project

  1. Create a new project

  2. Project->Add Item->Android->Android APK

  3. Setup the properties of the project for the Android-arm64-v8a platform, this can be done using one of two ways:

  • You can copy the properties from any Unit Test.
  • Use the already provided .props files
    • There are 2 .props files
      1. Android-arm64-v8a.props can be added to the project using the property manager
      2. AGDEVersions.props needs to be added manually into the project between the <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> and <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> lines (see Unit Tests for reference)

For link directories,

  • $(SolutionDir)$(Platform)$(Configuration)\ (this is where we have all our libs. set it accordingly)
    • NOTE This can be avoided by adding our libs as references (Right-click project -> Add -> Reference -> Pick the ones you want to link -> Ok)

Notes:

  • Add -lm to you project Linker Command Line options for if you get any undefined math operations error
  • If you get error related to "cannot use 'throw' with exceptions disabled", Enable exceptions in C++ Project settings
  • If you get error related to multiple instances of ioctl add BIONIC_IOCTL_NO_SIGNEDNESS_OVERLOAD in preprocessor definitions
  • If you get errors related to neon support not enabled -Enable Advance SIMD to Yes -Set floating point ABI to softfp

Quest 2 Requirements:

  1. Follow the Android setup instructions for Visual studio 2017 with "Mobile Development with C++" with the following notes:
  • It's recommended for Visual Studio 2017 to not install default Visual Studio Installer Android NDK
  • For compatibility with other components the best Android NDK to use is the 21.1.635 version from UE4 or the official 21e releases
  • The official (now unsupported) NDK can be downloaded here: https://github.com/android/ndk/wiki/Unsupported-Downloads#r21e
  1. Download OVR mobile sdk from oculus website. https://developer.oculus.com/downloads/package/oculus-mobile-sdk/
  2. Tested with ovr-mobile-sdk version 1.46
  3. Place unzipped sdk in The-Forge/Common_3/ThirdParty/OpenSource/ovr_sdk_mobile_1.46.0
  4. Download vulkan validation libs for android from https://github.com/KhronosGroup/Vulkan-ValidationLayers/releases a) Place unzipped sdk in The-Forge/Common_3/ThirdParty/OpenSource/Vulkan-ValidationLayer-1.2.182.0 b) Folder should contain the following: Vulkan-ValidationLayer-1.2.182.0/arm64-v8a/libVkLayer_khronos_validation.so
  5. Run examples from Examples_3/Unit_Tests/Quest_VisualStudio2017. As a side note the following examples may not be current compatible with the Quest:
  • 04_ExecuteIndirect
  • 05_FontRendering
  • 08_GltfViewer
  • 13_UserInterface
  • 17_EntityComponentSystem
  • 33_YUV

Install

  • For PC Windows run PRE_BUILD.bat. It will download and unzip the art assets and install the shader builder extension for Visual Studio 2017.

  • For Linux and Mac run PRE_BUILD.command. If its the first time checking out the forge make sure the PRE_BUILD.command has the correct executable flag by running the following command chmod +x PRE_BUILD.command

    It will only download and unzip required Art Assets (No plugins/extensions install).

Unit Tests

There are the following unit tests in The Forge:

1. Transformation

This unit test just shows a simple solar system. It is our "3D game Hello World" setup for cross-platform rendering.

Image of the Transformations Unit test

2. Compute

This unit test shows a Julia 4D fractal running in a compute shader. In the future this test will use several compute queues at once.

Image of the Compute Shader Unit test

3. Multi-Threaded Rendering

This unit test shows how to generate a large number of command buffers on all platforms supported by The Forge. This unit test is based on a demo by Intel called Stardust.

Image of the Multi-Threaded command buffer generation example

4. ExecuteIndirect

This unit test shows the difference in speed between Instanced Rendering, using ExecuteIndirect with CPU update of the indirect argument buffers and using ExecuteIndirect with GPU update of the indirect argument buffers. This unit test is based on the Asteroids example by Intel.

Image of the ExecuteIndirect Unit test Using ExecuteIndirect with GPU updates for the indirect argument buffers

Image of the ExecuteIndirect Unit test Using ExecuteIndirect with CPU updates for the indirect argument buffers

Image of the ExecuteIndirect Unit test Using Instanced Rendering

5. Font Rendering

This unit test shows the current state of our font rendering library that is based on several open-source libraries.

Image of the Font Rendering Unit test

6. Material Playground

This unit test shows a range of game related materials:

Hair: Many years ago in 2012 / 2013, we helped AMD and Crystal Dynamics with the development of TressFX for Tomb Raider. We also wrote an article about the implementation in GPU Pro 5 and gave a few joint presentations on conferences like FMX. At the end of last year we revisited TressFX. We took the current code in the GitHub repository, changed it a bit and ported it to The Forge. It now runs on PC with DirectX 12 / Vulkan, macOS and iOS with Metal 2 and on the XBOX One. We also created a few new hair assets so that we can showcase it. Here is a screenshot of our programmer art:

Hair on PC

Metal:

Material Playground Metal on PC

Wood:

Material Playground Wood on PC

7. Hardware Tessellation

This unit test showcases the rendering of grass with the help of hardware tessellation.

Image of the Hardware Tessellation Unit test

8. glTF Model Viewer

A cross-platform glTF model viewer that optimizes the vertex and index layout for the underlying platform and picks the right texture format for the underlying platform. This modelviewer can utilize Binomials Basis Universal Texture Support as an option to load textures. Support was added to the Image class as a "new image format". So you can pick basis like you can pick DDS or KTX. For iOS / Android we go directly to ASTC because Basis doesn't support ASTC at the moment.

glTF Viewer running on Android Galaxy Note 9 glTF Viewer running on Android Galaxy Note 9

glTF Viewer running on iPhone 7 glTF Viewer running on iPhone 7

glTF Viewer running on Linux with NVIDIA RTX 2060 glTF Viewer running on Linux with NVIDIA RTX 2060

glTF Viewer running on Mac Mini M1 glTF Viewer running on Mac Mini M1

glTF Viewer running on PS5 glTF Viewer running on PS5

glTF Viewer running on Switch glTF Viewer running on Switch

glTF Viewer running on XBOX One Original glTF Viewer running on XBOX One Original

9. Light and Shadow Playground

This unit test shows various shadow and lighting techniques that can be chosen from a drop down menu. There will be more in the future.

  • Exponential Shadow Map - this is based on Marco Salvi's @marcosalvi papers. This technique filters out the edge of the shadow map by approximating the shadow test using exponential function that involves three subjects: the depth value rendered by the light source, the actual depth value that is being tested against, and the constant value defined by the user to control the softness of the shadow
  • Adaptive Shadow Map with Parallax Correction Cache - this is based on the article "Parallax-Corrected Cached Shadow Maps" by Pavlo Turchyn in GPU Zen 2. It adaptively chooses which light source view to be used when rendering a shadow map based on a hiearchical grid structure. The grid structure is constantly updated depending on the user's point of view and it uses caching system that only renders uncovered part of the scene. The algorithm greatly reduce shadow aliasing that is normally found in traditional shadow map due to insufficient resolution. Pavlo Turchyn's paper from GPU Pro 2 added an additional improvement by implementing multi resolution filtering, a technique that approximates larger size PCF kernel using multiple mipmaps to achieve cheap soft shadow. He also describes how he integrated a Parallax Correction Cache to Adaptive Shadow Map, an algorithm that approximates moving sun's shadow on static scene without rendering tiles of shadow map every frame. The algorithm is generally used in an open world game to approximate the simulation of day & night’s shadow cycle more realistically without too much CPU/GPU cost.
  • Signed Distance Field Soft Shadow - this is based on Daniel Wright's Siggraph 2015 @EpicShaders presentation. To achieve real time SDF shadow, we store the distance to the nearest surface for every unique Meshes to a 3D volume texture atlas. The Mesh SDF is generated offline using triangle ray tracing, and half precision float 3D volume texture atlas is accurate enough to represent 3D meshes with SDF. The current implementation only supports rigid meshes and uniform transformations (non-uniform scale is not supported). An approximate cone intersection can be achieved by measuring the closest distance of a passed ray to an occluder which gives us a cheap soft shadow when using SDF.

To achieve high-performance, the playground runs on our signature rendering architecture called Triangle Visibility Buffer. The step that generates the SDF data also uses this architecture.

Click on the following screenshot to see a movie:

Signed Distance Field Soft Shadow Map

The following PC screenshots are taken on Windows 10 with a AMD RX550 GPU (driver 19.7.1) with a resolution of 1920x1080.

Exponential Shadow Maps:

Light and Shadow Playground - Exponential Shadow Map

Adaptive Shadow Map with Parallax Correction Cache

Adaptive Shadow Map with Parallax Correction Cache

Signed Distance Field Soft Shadow:

Signed Distance Field Soft Shadow Map

Signed Distance Field Soft Shadows - Debug Visualization

Signed Distance Field Soft Shadow Map

The following shots show Signed Distance Field Soft Shadows running on iMac with a AMD RADEON Pro 580

Signed Distance Field Soft Shadow Map

Signed Distance Field Soft Shadow Map

The following shots show Signed Distance Field Soft Shadows running on XBOX One:

Signed Distance Field Soft Shadow Map

Signed Distance Field Soft Shadow Map

Signed Distance Field Soft Shadow Map

Readme for Signed Distance Field Soft Shadow Maps:

To generate the SDF Mesh data you should select “Signed Distance Field” as the selected shadow type in the Light and Shadow Playground. There is a button called “Generate Missing SDF” and once its clicked, it shows a progress bar that represents the remaining SDF mesh objects utilized for SDF data generation. This process is multithreaded, so the user can still move around the scene while waiting for the SDF process to be finished. This is a long process and it could consume up to 8+ hours depending on your CPU specs. To check how many SDF objects there are presently in the scene, you can mark the checkbox "Visualize SDF Geometry On The Scene".

9a. Hybrid Ray-Traced Shadows

This unit test was build by Kostas Anagnostou @KostasAAA to show how to ray trace shadows without using a ray tracing API like DXR / RTX. It should run on all GPUs (not just NVIDIA RTX GPUs) and the expectation is that it should run comparable with a DXR / RTX based version even on a NVIDIA RTX GPU. That means the users of your game do not have to buy a NVIDIA RTX GPU to enjoy HRT shadows :-) Hybrid Ray Traced Shadows

10. Screen-Space Reflections

This test offers two choices: you can pick either Pixel Projected Reflections or AMD's FX Stochastic Screen Space Reflection. We just made AMD's FX code cross-platform. It runs now on Windows, Linux, macOS, Switch, PS and XBOX.

Here are the screenshots of AMD's FX Stochastic Screen Space Reflections:

Windows final scene: AMD FX Stochastic Screen Space Reflections

Without denoising: AMD FX Stochastic Screen Space Reflections before denoise

With denoising: AMD FX Stochastic Screen Space Reflections before denoise

PS4: AMD FX Stochastic Screen Space Reflections on PS4

macOS: AMD FX Stochastic Screen Space Reflections on macOS

In case you pick Pixel-Projected Reflections, the application features an implementation of the papers Optimized pixel-projected reflections for planar reflectors and IMPLEMENTATION OF OPTIMIZED PIXEL-PROJECTED REFLECTIONS FOR PLANAR REFLECTORS

Image of the Pixel-Projected Reflections Unit test

11. Multi-GPU (Driver support only on PC Windows)

This unit test shows a typical VR Multi-GPU configuration. One eye is rendered by one GPU and the other eye by the other one.

Image of the Multi-GPU Unit test

11a. Unlinked multiple GPUs (Driver support only on PC Windows)

For professional visualization applications, we now support unlinked multiple GPUs. A new renderer API is added to enumerate available GPUs. Renderer creation is extended to allow explicit GPU selection using the enumerated GPU list. Multiple Renderers can be created this way. The resource loader interface has been extended to support multiple Renderers. It is initialized with the list of all Renderers created. To select which Renderer (GPU) resources are loaded on, the NodeIndex used in linked GPU configurations is reused for the same purpose. Resources cannot be shared on multiple Renderers however, resources must be duplicated explicitly if needed. To retrieve generated content from one GPU to another (e.g. for presentation), a new resource loader operation is provided to schedule a transfer from a texture to a buffer. The target buffer should be mappable. This operation requires proper synchronization with the rendering work; a semaphore can be provided to the copy operation for that purpose. Available with Vulkan and D3D12. For other APIs, the enumeration API will not create a RendererContext which indicates lack of unlinked multi GPU support.

Image of the Unlinked Multiple GPUs Unit test

12. File System Test

This unit test showcases a cross-platform FileSystem C API, supporting disk-based files, memory streams, and files in zip archives. The API can be viewed in IFileSystem.h, and all of the example code has been updated to use the new API.

  • The API is based around Paths, where each Path represents an absolute, canonical path string on a particular file system. You can query information about the files at Paths, open files as FileStreams, and copy files between different Paths.
  • The concept of FileSystemRoots has been replaced by ResourceDirectorys. ResourceDirectorys are predefined directories where resources are expected to exist, and there are convenience functions to open files in resource directories. If your resources don’t exist within the default directory for a particular resource type, you can call fsSetPathForResourceDirectory to relocate the resource directory; see the unit tests for sample code on how to do this.

File System Unit Test

13. imGUI integration unit test

This unit test shows how the integration of imGui is done with a wide range of functionality.

Image of the imGui Integration in The Forge

14. Order-Independent Transparency unit test

This unit test compares various Order-Indpendent Transparency Methods. In the moment it shows:

15. Wave Intrinsics unit test

This unit test shows how to use the new wave intrinsics. Supporting Windows with DirectX 12 / Vulkan, Linux with Vulkan and macOS / iOS.

Image of the Wave Intrinsics unit test in The Forge

16. Path Tracer - Ray Tracing Unit Test

The new 16_Raytracing unit test shows a simple cross-platform path tracer. On iOS this path tracer requires A11 or higher. It is meant to be used in tools in the future and doesn't run in real-time. To support the new path tracer, the Metal raytracing backend has been overhauled to use a sort-and-dispatch based approach, enabling efficient support for multiple hit groups and miss shaders. The most significant limitation for raytracing on Metal is that only tail recursion is supported, which can be worked around using larger per-ray payloads and splitting up shaders into sub-shaders after each TraceRay call; see the Metal shaders used for 16_Raytracing for an example on how this can be done.

macOS 1920x1080 AMD Pro Vega 64

Path Tracer running on macOS

iOS iPhone X 812x375

Path Tracer running on macOS

Windows 10 1080p NVIDIA RTX 2080 with DXR Driver version 441.12

Path Tracer running on Windows DXR

Windows 10 1080p NVIDIA RTX 2080 with RTX Driver version 441.12

Path Tracer running on Windows RTX

Linux 1080p NVIDIA RTX 2060 with RTX Driver version 435

Path Tracer running on Linux RTX

16a. Sphere Tracing

This unit test was originally posted on ShaderToy by Inigo Quilez and Sopyer. It shows how a scene is ray marched with shadows, reflections and AO

Image of the Sphere Tracing  unit test in The Forge

17. Entity Component System Test

This unit test shows how to use the high-performance entity component system in The Forge. Image of the Entity Component System unit test in The Forge

This unit test uses

flecs

Compared to our old ECS system our build times are now much better and the overall system runs faster:

CPU: intel i7-7700k
GPU: AMD Radeon RX570

Old ECS
Debug
Single Threaded: 90.0ms 
Multi Threaded 29.0ms

Release:
Single Threaded: 5.7ms
Multi Threaded: 2.3ms


flecs
Debug
Single Threaded: 23.0ms   
Multi Threaded 6.8ms

Release
Single Threaded 1.7ms
Multi Threaded 0.9ms

18. Sparse Virtual Textures

The Forge has now support for Sparse Virtual Textures on Windows and Linux with DirectX 12 / Vulkan. Sparse texture (also known as "virtual texture", “tiled texture”, or “mega-texture”) is a technique to load huge size (such as 16k x 16k or more) textures in GPU memory. It breaks an original texture down into small square or rectangular tiles to load only visible part of them.

The unit test 18_Virtual_Texture is using 7 sparse textures:

  • Mercury: 8192 x 4096
  • Venus: 8192 x 4096
  • Earth: 8192 x 4096
  • Moon: 16384 x 8192
  • Mars: 8192 x 4096
  • Jupiter: 4096 x 2048
  • Saturn: 4096 x 4096

There is a unit test that shows a solar system where you can approach planets with Sparse Virtual Textures attached and the resolution of the texture will increase when you approach.

Linux 1080p NVIDIA RTX 2060 with RTX Driver version 435

Sparse Virtual Texture on Linux Vulkan

Windows 10 1080p NVIDIA 1080 DirectX 12

Sparse Virtual Texture on Windows 10 DirectX 12

Windows 10 1080p NVIDIA 1080 Vulkan

Sparse Virtual Texture on Windows Vulkan

Sparse Virtual Texture on Windows Vulkan

21. Ozz Playback Animation

This unit test shows how to playback a clip on a rig.

Image of Playback Animation in The Forge

22. Ozz Playback Blending

This unit test shows how to blend multiple clips and play them back on a rig.

Image of Playback Blending in The Forge

23. Ozz Joint Attachment

This unit test shows how to attach an object to a rig which is being posed by an animation.

Image of Ozz Joint Attachment in The Forge

24. Ozz Partial Blending

This unit test shows how to blend clips having each only effect a certain portion of joints.

Image of Ozz Partial Blending in The Forge

25. Ozz Additive Blending

This unit test shows how to introduce an additive clip onto another clip and play the result on a rig.

Image of Ozz Additive Blending in The Forge

26. Ozz Baked Physics

This unit test shows how to use a scene of a physics interaction that has been baked into an animation and play it back on a rig.

Image of Ozz Baked Physics in The Forge

27. Ozz Multi Threading

This unit test shows how to animate multiple rigs simultaneously while using multi-threading for the animation updates.

Image of Ozz Multi Threading in The Forge

28. Ozz Skinning

This unit test shows how to use skinning with Ozz

Image of the Ozz Skinning unit test

29. Ozz Inverse Kinematic

This unit test shows how to use a Aim and a Two bone IK solvers

Aim IK Ozz Aim IK

Two Bone IK Ozz Two Bone IK

32. Windows Management

This test demonstrates windows management on Windows, Linux and macOS.

  • The window layout, position, and size are now driven by the client dimensions, meaning that the values that the client demands are the exact values the client area will be represented with, regardless of the window style. This allows for much greater flexibility and consistency, especially when working with a fullscreen window.
  • Multi-monitor support has also been improved significantly, offering smooth consistent transitions between client displays and guaranteeing correct window behavior and data retention. Media layer functionality has been expanded, allowing the client to control mouse positioning, mouse visibility, and mouse visual representation.
  • It is now possible to create independent mouse cursors to further customize the application.

Here are the screenshots:

Windows: Windows Management for Windows

macOS: Windows Management for macOS

Linux: Windows Management for Linux

33. YUV Support

YUV support: we have now YUV support for all our Vulkan API platforms PC, Linux, Android and Switch. There is a new functional test for YUV. It runs on all these platforms:

YUV unit test

35. Variable Shading Rate

  • Per tile Shading Rate Generating a shading rate lookup texture on-the-fly. Used for drawing the color palette which makes up the background. The rate decreases the further the pixels are located from the center. We can see artifacts becoming visible at aggressive rates, such as 4X4. There is also a slider in the UI to modify the center of the circle.

Per-tile Shading Rate

  • Per-draw Shading Rate: The cubes are drawn by a different shading rate. They are following the Per-draw rate, which can be changed via the dropdown menu in the UI. By using a combiner that overrides the screen rates, we ensure that cubes are drawn by an independent rate.

Per-draw Shading Rate The cubes are using per-draw shading rate while the background is using per-tile shading rate.

  • Notes:
    • There is a debug view showing the shading rates and the tiles' size.
    • Per-tile method may not be available on certain GPUs even if they support the Per-draw method.
    • The tile size is enforced by the GPU and is readable, as shown in the example.
    • The shading rates available can vary based on the active GPU.

Examples

There is an example implementation of the Triangle Visibility Buffer as covered in various conference talks. Here is a blog entry that details the implementation in The Forge.

Image of the Visibility Buffer

Tools

Below are screenshots and descriptions of some of the tools we integrated.

MTuner

MTuner MTuner was integrated into the Windows 10 runtime of The Forge following a request for more in-depth memory profiling capabilities by one of the developers we support. It has been adapted to work closely with our framework and its existing memory tracking capabilities to provide a complete picture of a given application’s memory usage.

To use The Forge’s MTuner functionality, simply drag and drop the .MTuner file generated alongside your application’s executable into the MTuner host app, and you can immediately begin analyzing your program’s memory usage. The intuitive interface and exhaustive supply of allocation info contained in a single capture file makes it easy to identify usage patterns and hotspots, as well as tracking memory leaks down to the file and line number. The full documentation of MTuner can be found [here](link: https://milostosic.github.io/MTuner/).

Currently, this feature is only available on Windows 10, but support for additional platforms provided by The Forge is forthcoming. Here is a screenshot of an example capture done on our first Unit Test, 01_Transformations: MTuner

Ray Tracing Benchmark

Based on request we are providing a Ray Tracing Benchmark in 16_RayTracing. It allows you to compare the performance of three platforms:

  • Windows with DirectX 12 DXR
  • Windows with Vulkan RTX
  • Linux with Vulkan RTX

We will extend this benchmark to the non-public platforms we support to compare the PC performance with console performance. The benchmark comes with batch files for all three platforms. Each run generates a HTML output file from the profiler that is integrated in TF. The default number of iterations is 64 but you can adjust that. There is a Readme file in the 16_RayTracing folder that describes the options.

Windows DirectX 12 DXR, GeForce RTX 2070 Super, 3840x1600, NVIDIA Driver 441.99

Windows DXR output of Ray Tracing Benchmark

Windows Vulkan RTX, GeForce RTX 2070 Super, 3840x1600, NVIDIA Driver 441.99

Windows RTX output of Ray Tracing Benchmark

Microprofiler

We integrated the Micro Profiler into our code base by replacing the proprietary UI with imGUI and simplified the usage. Now it is much more tightly and consistently integrated in our code base.

Here are screenshots of the Microprofiler running the Visibility Buffer on PC:

Microprofiler

Microprofiler

Microprofiler

Microprofiler

Here are screenshots of the Microprofiler running a unit test on iOS:

Microprofiler

Microprofiler

Microprofiler

Check out the Wikipage for an explanation on how to use it.

Shader Translator

We provide a shader translator, that translates one shader language -a superset of HLSL called Forge Shader Language (FLS) - to the target shader language of all our target platforms. That includes the console and mobile platforms as well. It is written in Python. We expect this shader translator to be an easier to maintain solution for smaller game teams because it allows to add additional data to the shader source file with less effort. Such data could be for example a bucket classification or different shaders for different capability levels of the underlying platform, descriptor memory requirements or resource memory requirements in general, material info or just information to easier pre-compile pipelines. The actual shader compilation will be done by the native compiler of the target platform.

How to use the Shader Translator

Releases / Maintenance

The Forge Interactive Inc. will prepare releases when all the platforms are stable and running and push them to this GitHub repository. Up until a release, development will happen on internal servers. This is to sync up the console, mobile, macOS and PC versions of the source code.

Products

We would appreciate it if you could send us a link in case your product uses The Forge. Here are the ones we received so far or we contributed to:

BuildBox

The game engine BuildBox is now using The Forge (click on image to go to the Steam Store):

BuildBox

Lethis

The Game "Lethis Path of Progress" is now using The Forge (click on image to go to the Steam Store)

Lethis

Supergiant Games Hades

Supergiant's Hades we are working with Supergiant since 2014. One of the on-going challenges was that their run-time was written in C#. At the beginning of last year, we suggested to help them in building a new cross-platform game engine in C/C++ from scratch with The Forge. The project started in April 2019 and the first version of this new engine launched in May this year. Hades was then released for Microsoft Windows, macOS, and Nintendo Switch on September 17, 2020. The game can run on all platforms supported by The Forge.

Here is a screenshot of Hades running on Switch:

Supergiant Hades

Here is an article by Forbes about Hades being at the top of the Nintendo Switch Charts. Hades is also a technology showcase for Intel's integrated GPUs on macOS and Windows. The target group of the game seems to often own those GPUs.

Bethesda's Creation Engine

Bethesda based their rendering layer for their next-gen engine on The Forge. We helped integrate and optimize it.

Bethesda's Creation Engine

Here is more info about this game engine:

Todd Howard Teases Bethesda's New Game Engine Behind The Elder Scrolls 6 And Starfield

Bethesda's overhauling its engine for Starfield and The Elder Scrolls 6

M²H - Stroke Therapy

M²H uses The Forge - M²H is a medical technology company. They have developed a physics-based video game therapy solution that is backed by leading edge neuroscience, powered by Artificial Intelligence and controlled by dynamic movement – all working in concert to stimulate vast improvement of cognitive and motor functions for patients with stroke and the aged. The Forge provides the rendering layer for their application. Here is a YouTube video on what they do:

M²H on YouTube

StarVR One SDK

The Forge is used to build the StarVR One SDK:

StarVR

Torque 3D

The Forge will be used as the rendering framework in Torque 3D:

Torque 3D

Star Wars Galaxies Level Editor

SWB is an editor for the 2003 game 'Star Wars Galaxies' that can edit terrains, scenes, particles and import/export models via FBX. The editor uses an engine called 'atlas' that will be made open source in the future. It focuses on making efficient use of the new graphics APIs (with help from The-Forge!), ease-of-use and terrain rendering.

SWB Level Editor

Writing Guidelines

For contributions to The Forge we apply the following writing guidelines:

  • We limit all code to C++ 11 by setting the Clang and other compiler flags
  • We follow the [Orthodox C++ guidelines] (https://gist.github.com/bkaradzic/2e39896bc7d8c34e042b) minus C++ 14 support (see above)
  • Please note that we are going to move towards C99 usage more and more because this language makes it easier to develop high-performance applications in a team. With the increased call numbers of modern APIs and the always performance-detoriating C++ features, C++ is becoming more and more a productivity and run-time performance challenge. C is also a better starting point to port to other languages like RUST. In case any of those languages become common in development.

User Group Meetings

There will be a user group meeting during GDC. In case you want to organize a user group meeting in your country / town at any other point in time, we would like to support this. We could send an engineer for a talk.

Support for Education

In case your School / College / University uses The Forge for education, we would like to support this as well. We could send an engineer or help create material. So far the following schools use The Forge for teaching:

Breda University of Applied Sciences

        Contact:
        Jeremiah van Oosten 
        Monseigneur Hopmansstraat 1
        4817 JT Breda

Ontario Tech University

        Contact:
        Andrew Hogue
        Ontario Tech University
        SIRC 4th floor
        2000 Simcoe St N
        Oshawa, ON, L1H 7K4

Open-Source Libraries

The Forge utilizes the following Open-Source libraries:

Issues
  • CMakeLists.txt really needed

    CMakeLists.txt really needed

    Well first of all your library look awesome and I like samples you wrote that bring a view of how to use your lib.

    I like also also the support of different IDE like VisualStudio ode Codelite but personally I use CLion and also like after cloning a lib like this just do mkdir build && cd build && cmake .. && make -j12 for quickly test the project but your project doesn't support it.

    Cmake is a very powerful tool for building a project, managing dependencies, use your lib as dependencies (that we can also integrate as git submodule of in our project), cross compilation via toolchains or also generate project for other IDE.

    The following generators are available on this platform (* marks default):
    * Unix Makefiles               = Generates standard UNIX makefiles.
      Green Hills MULTI            = Generates Green Hills MULTI files
                                     (experimental, work-in-progress).
      Ninja                        = Generates build.ninja files.
      Watcom WMake                 = Generates Watcom WMake makefiles.
      CodeBlocks - Ninja           = Generates CodeBlocks project files.
      CodeBlocks - Unix Makefiles  = Generates CodeBlocks project files.
      CodeLite - Ninja             = Generates CodeLite project files.
      CodeLite - Unix Makefiles    = Generates CodeLite project files.
      Sublime Text 2 - Ninja       = Generates Sublime Text 2 project files.
      Sublime Text 2 - Unix Makefiles
                                   = Generates Sublime Text 2 project files.
      Kate - Ninja                 = Generates Kate project files.
      Kate - Unix Makefiles        = Generates Kate project files.
      Eclipse CDT4 - Ninja         = Generates Eclipse CDT 4.0 project files.
      Eclipse CDT4 - Unix Makefiles= Generates Eclipse CDT 4.0 project files.
    

    I can also found related issues (https://github.com/ConfettiFX/The-Forge/issues/66, https://github.com/ConfettiFX/The-Forge/issues/81, https://github.com/ConfettiFX/The-Forge/issues/138) on your project that request also a cmake version of your lib.

    I hope this new request will be solve by the presence of a CMakeLists.txt in your repo.

    opened by Hideman85 28
  • About FBX resource import?

    About FBX resource import?

    Consult the resource pipeline documentation

    Known problems: -Skeletons and animations scaled from centimeters to meters (* 0.01). This is only required for FBX files. If we want to support other formats this has to be changed. -See: AssetPipeline.cpp - line: 392 & 537 & 546 -Boris (Unreal Paragon asset) rotated 90 degrees on x axis after putting it through the animation pipeline. Blender also doesn’t import model correctly. Rotating the model in either Maya or Blender causes severe problems in the animation. Makes it look like his nose, fingers and ankle are all broken.

    The bone file generated by fbx2ozz is correct。 AssetPipelineCmd.exe generated skeletal rotated 90 degrees on x axis ?

    How should fbx be exported or how to set it correctly, I use

    		AssimpImporter        importer;
    		AssimpImporter::Model model = {};
    		if (!importer.ImportModel(fullPath.c_str(), &model))
    			return false;
    
    

    The fbx model is magnified n times, The FBX in the example is correct, how should the FBX model be derived

    opened by luoxz-ai 19
  • 04_ExecuteIndirect crash on macOS

    04_ExecuteIndirect crash on macOS

    I've tested the Unit Tests on my Mac Pro 2010 / Vega 56 running MacOS Mojave 10.14.4. Xcode: Version 10.2.1 (10E1001) The examples are running fine except the 04_ExecuteIndirect.

    It crashes directly at the beginning of void AsteroidSimulation::Init(uint32_t rngSeed, uint32_t numAsteroids, uint32_t numMeshes, uint32_t vertexCountPerMesh, uint32_t textureCount)

    The error reported by the debugger is: Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)

    Can anybody help?

    Regards

    opened by camots 13
  • Multi-Monitor Support?

    Multi-Monitor Support?

    What is the best way to set up rendering to multiple full-screen monitors using a single GPU adapter in The Forge? Do you have an example that uses multi-monitor?

    opened by mgsim 10
  • Will you be supporting MESA + RADV eventually?

    Will you be supporting MESA + RADV eventually?

    Hi.

    For PC Linux Requirements, you mention support for AMDGPU-Pro.

    Just wanted to know if you'll be supporting MESA + RADV eventually.

    Thanks for your time.

    Cheers.

    enhancement 
    opened by ghost 10
  • Minimal example?

    Minimal example?

    Is there a minimal example on how to use the library? For example, a basic CMake that includes the engine and a main.cpp that shows a window and a teapot?

    opened by VinnyVicious 9
  • InstanceLayers loop is wrong in CreateInstance

    InstanceLayers loop is wrong in CreateInstance

    This is the code : for (uint32_t i = -1; i < pRenderer->mInstanceLayers.size(); ++i)

    It is initializing an unsigned integer to -1, which means it is initialized to UINT32_MAX. It won't ever be lower than mInstanceLayers.size() and the loop will never be taken.

    https://github.com/ConfettiFX/The-Forge/blob/d3b5c2994125dea006f0ef6d62bb09670c52396a/Common_3/Renderer/Vulkan/Vulkan.cpp#L1893

    bug 
    opened by simondeschenes 9
  • All Animation Examples (21 - 29) have a bone calculation / rendering bug

    All Animation Examples (21 - 29) have a bone calculation / rendering bug

    Hello,

    I've had no issues with the other examples but I noticed that all the tutorials using ozz seem to not render any skeleton, bones or joints. I've definitely ticked the boxes to enable this. I was curious what was going on so I had a poke around with RenderDoc + Visual Studio. It seems that Rig::mJointModelMats is allocated but not initialised to any values (which meant the uninitialised values were around e^38). Then in Rig::Pose(), these massive values are used to calculate new values for Rig::mJointWorldMats:

    mJointWorldMats[jointIndex] = rootTransform * mJointModelMats[jointIndex];

    leading to erratic values and NaNs. In RenderDoc I was able to see that the values for Get(toWorld)[InstanceID] were erratic,

    Here's some more info about my setup: Windows 10 Windows SDK 10.0.19041.0 Visual Studio 2019 (v142) MSVC 19.29.30137 for x64

    Occurs across all 3 rendering APIs: Vulkan, DX11, DX12. Compiling 22_Blending as both Debug x64 and Release x64.

    opened by swan-gh 7
  • Segmentation Fault on Linux through CodeLite at vkCreateInstance

    Segmentation Fault on Linux through CodeLite at vkCreateInstance

    Running any of the cpp files from UbuntuUnitTests folder yields the following error:


    2021-06-11 14:09:30 [MainThread ] Vulkan.cpp:2116 ERR| vkCreateInstance(&create_info, &gVkAllocationCallbacks, &(pRenderer->mVulkan.pVkInstance)): FAILED with VkResult: 4294967287 Failed: (false)

    File: .../The-Forge/Common_3/Renderer/Vulkan/Vulkan.cpp Line: 2116

    Segmentation fault Press ENTER to continue...


    I tried switching compilers using the Cross GCC ( x86_64-linux-gnu ), GCC and gnu g++, but no change in output. Platform:

    MX Linux(kernel v5.8.0-3-amd64) Intel(R) Core(TM) i5-9300HF 8GB RAM GTX 1650

    opened by sierret 7
  • Benchmark support?

    Benchmark support?

    Hi, just wondering if The-Forge has any support (or plans) for any integrated command-line driven benchmarking of your rendering code? A setup that could be automated like with your new path tracer test for showing various performance metrics afterwards dumped to the CLI or log file, etc?

    Thanks, Michael

    opened by michaellarabel 7
  • Driver crash with Radeon Mesa driver (RADV) on Linux

    Driver crash with Radeon Mesa driver (RADV) on Linux

    Hi all,

    I've found a segfault crash with the Vulkan backend on Radeon Mesa (RADV). I built the driver in debug optimised mode so I could see exactly where the crash happens: https://github.com/ConfettiFX/The-Forge/blob/master/Common_3/Renderer/Vulkan/Vulkan.cpp#L474

    Which is due to VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV not being anticipated by the RADV driver here: https://gitlab.freedesktop.org/mesa/mesa/blob/master/src/amd/vulkan/radv_descriptor_set.c#L656

    My guess is perhaps this value should be more dynamic in pRenderer rather than at compile time? I'll let you guys decide... :) https://github.com/ConfettiFX/The-Forge/blob/master/Common_3/Renderer/Vulkan/Vulkan.cpp#L436

    Cheers!

    opened by boberfly 7
  • C99 container library

    C99 container library

    Hi,

    In one of your news you wrote:

    In one of the next updates we will remove EASTL and offer dedicated containers compatible with C99.

    Because I am in need of a C99 container library I am wondering if you have any news regarding this topic.

    opened by kterhorst 0
  • vk_updateDescriptorSet is not thread safe

    vk_updateDescriptorSet is not thread safe

    pDescriptorData member of pDescriptorSet->mVulkan make vk_updateDescriptorSet not thead safe see: https://github.com/yaoyao-cn/The-Forge/commit/c44d6cdeb04273531b9850d9a7cd37c8a7bdf18c

    i found this while using multi-thread command recording with each thread may update some sub index of a large(mMaxSets is large) descriptor set. because all thead use the same pDescriptorData when update texture, all my mesh with texture will flicker like this:

    https://user-images.githubusercontent.com/10138823/172975573-aa66a75e-3fea-45d1-a502-c27370da1487.mp4

    opened by yaoyao-cn 7
  • (Windows 7) WindowsThread.c - SetThreadDescription()

    (Windows 7) WindowsThread.c - SetThreadDescription()

    Hello! I've been looking around to toy with several graphics libraries for a game engine I'm in the process of building, and I ran into a minor hiccup with this one.

    I'm not sure if you guys still support Windows 7 at all, but I just did a fresh clone and build attempt and I ran into a bit of an issue - When compiling OS, it fails in WindowsThread.c at a function called SetThreadDescription. After some research, it seems that this function doesn't exist at all under Windows 7 (or 8 for that matter) as detailed here.

    Commenting out these two lines results in compilation (seemingly) without issue, though I have to imagine that randomly commenting out lines won't be ideal long-term.

    Common_3\OS\Windows\WindowsThread.c:

    /*137*/                HRESULT res = SetThreadDescription(GetCurrentThread(), windowsThreadName);
    /*138*/                ASSERT(!FAILED(res));
    

    The error log is as follows:

    1>I:\Development\Github\ConfettiFX\The-Forge\Common_3\OS\Windows\WindowsThread.c(137,37): error C2220: the following warning is treated as an error
    1>I:\Development\Github\ConfettiFX\The-Forge\Common_3\OS\Windows\WindowsThread.c(137,37): warning C4013: 'SetThreadDescription' undefined; assuming extern returning int
    

    Would be really cool to see this fixed - as outside of commenting out D3D12 rendering support, this was the only roadblock to getting it to compile and run under Win7.

    opened by haloman30 7
  • Visibility Buffer on iOS

    Visibility Buffer on iOS

    The visibility buffer demo seems to work on iPhone 12 (A14, MTLGPUFamilyApple7, max number of the texture argument buffe is 128), and I saw a folder named 'Visibility_Buffer_iOS' in the visibility buffer project, but there is no iOS target in the xcode project. I tried to port the macOS target to iOS by duplicate and modify it but it did't work.

    opened by zyjisdog 2
  • Request: Support Xcode Quick Look Debugging

    Request: Support Xcode Quick Look Debugging

    It's convenient for multimedia developers to view the content of texture using Xcode Quick Look Debugging without capturing the whole gpu frame which can spend a few seconds for replaying a complex frame.

    Maybe the following code is acceptable for a temp debug session.

    TextureLoadDesc textureDesc = {};
    textureDesc.pFileName = "QuickLookTest";
    textureDesc.ppTexture = &pDebugTexture;
    textureDesc.mContainer = TEXTURE_CONTAINER_JPG;
    addResource(&textureDesc, NULL);
    // ...
    waitForAllResourceLoads();
    
    TextureXcodeQuickLook* quickLook = [[TextureXcodeQuickLook alloc] initWithTexture:pDebugTexture];
    printf("%p\n", quickLook); //meaningless, just for avoiding compile warning
    

    It looks like the following debug screen capture of demo 01_Transformations. 截屏2021-10-29 下午7 13 35

    opened by Michael-Lfx 0
Releases(v1.50)
  • v1.50(Oct 26, 2021)

    • M²H uses The Forge for Stroke Therapy - M²H is a medical technology company. They developed a physics-based video game therapy solution that is backed by leading edge neuroscience, powered by Artificial Intelligence and controlled by dynamic movement – all working in concert to stimulate vast improvement of cognitive and motor functions for patients with stroke and the aged. The Forge provides the rendering layer for their application. Here is a YouTube video on what they do:

    M²H on YouTube

    • Unlinked multiple GPU Support: for professional visualization applications, we now support unlinked multiple GPU. A new renderer API is added to enumerate available GPUs. Renderer creation is extended to allow explicit GPU selection using the enumerated GPU list. Multiple Renderers can be created this way. The resource loader interface has been extended to support multiple Renderers. It is initialized with the list of all Renderers created. To select which Renderer (GPU) resources are loaded on, the NodeIndex used in linked GPU configurations is reused for the same purpose. Resources cannot be shared on multiple Renderers however, resources must be duplicated explicitly if needed. To retrieve generated content from one GPU to another (e.g. for presentation), a new resource loader operation is provided to schedule a transfer from a texture to a buffer. The target buffer should be mappable. This operation requires proper synchronization with the rendering work; a semaphore can be provided to the copy operation for that purpose. Available with Vulkan and D3D12. For other APIs, the enumeration API will not create a RendererContext which indicates lack of unlinked multi GPU support.

    • Config.h: We now have a central config.h file that can be used to configure TF.

      • Created config files:
    Common_3/OS/Core/Config.h
    Common_3/Renderer/RendererConfig.h
    Common_3/Renderer/{RenderingAPI}/{RenderingAPI}Config.h
    
        * Modified PyBuild.py
            * Proper handling of config options.
            * Every config option has --{option-name}/--no-{option-name} flag that uses define/undef directives to enable/disable macros. 
            * Macros are guarded with ifndef/ifdef.
            * Updated Android platform handling
          * Deleted Common_3/Renderer/Compiler.h. It's functionality was moved into Config.h
          * Moved all macro options to config files
          * Renamed USE_{OPTON_NAME} to ENABLE_{OPTION_NAME}
          * Changed some macros to be defined/not defined instead of having values of 0 or 1.
          * Deleted all DISABLE_{OPTION_NAME} macros
          * When detecting raytracing replaced ENABLE_RAYTRACING with RAYTRACING_AVAILABLE. This was done, because not all projects need raytracing even if it is available. RendererConfig.h defines ENABLE_RAYTRACING macro if it is available. So, it can be commented out in singular place instead of searching for it for every platform
          * Removed most of the macro definitions from build systems. Some of the remaining macros are:
            * Target platform macros: NX64, QUEST_VR
            * Arm neon macro ANDROID_ARM_NEON.
            * Windows suppression macros(like _CRT_SECURE_NO_WARNINGS)
            * Macros specific to gainputstatic
    
    • glTF viewer improvements:
      • sRGB fixes
      • IBL support now with prefiltered CCO/public domain cube maps
      • TAA support on more platforms and fixes
      • Vignette support

    glTF Viewer running on Android Galaxy Note 9 glTF Viewer running on Android Galaxy Note 9

    glTF Viewer running on iPhone 7 glTF Viewer running on iPhone 7

    glTF Viewer running on Linux with NVIDIA RTX 2060 glTF Viewer running on Linux with NVIDIA RTX 2060

    glTF Viewer running on Mac Mini M1 glTF Viewer running on Mac Mini M1

    glTF Viewer running on PS5 glTF Viewer running on PS5

    glTF Viewer running on Switch glTF Viewer running on Switch

    glTF Viewer running on XBOX One Original glTF Viewer running on XBOX One Original

    • Specialization/Function constants support on Vulkan and Metal only - these constants get baked into the micro-code during pipeline creation time so the performance is identical to using a macro without any of the downsides of macros (too many shader variations increasing the size of the build).

    Good read on Specialization constants. Same things apply to function constants on Metal

    https://arm-software.github.io/vulkan_best_practice_for_mobile_developers/samples/performance/specialization_constants/specialization_constants_tutorial.html

    Declared at global scope using SHADER_CONSTANT macro. Used as any regular variable after declaration

    Macro arguments:

    #define SHADER_CONSTANT(INDEX, TYPE, NAME, VALUE)
    

    Example usage:

    SHADER_CONSTANT(0, uint, gRenderMode, 0);
    // Vulkan - layout (constant_id = 0) const uint gRenderMode = 0;
    // Metal  - constant uint gRenderMode [[function_constant(0)]];
    // Others - const uint gRenderMode = 0;
    
    void main()
    {
        // Can be used like regular variables in shader code
        if (gRenderMode == 1)
        {
            // 
        }
    }
    
    • Resolved GitHub Issues
      • #206 - Executing Unit Tests on Mac OS 10.14 gives a Bad Access error
      • #209 - way to read texture back from GPU to CPU - this functionality is now in the resource loader
      • #210 - memory allocation challenge - not an issue
      • #212 - Question: updating partial uniform data on OpenGLES backend - not possible with OpenGL ES 2.0 run-time
      • #219 - Question : way to support Vulkan SpecializationInfo? - support is now in the code base see above
    Source code(tar.gz)
    Source code(zip)
  • v1.49(Oct 26, 2021)

    • Quest 2 Support - after working now for the last 4 years on various Quest projects, we decided to add Quest 2 support to our framework.
    • Quest 2 running 01_Transformations Quest 2 Running 01_Transformations

      Quest 2 running 09_ShadowPlayground Quest 2 Running 09_ShadowPlayground

    • At this moment the following unit tests do not work:
      • 07_Tessellation: Tesselation is not supported when using Multiview. Unit test has been removed from Quest solution file.
      • 10_ScreenSpaceReflections: Lots of artifacts.
      • 14_WaveIntrinsics: Wave intrinsics are not supported.
    • Apple M1 support - we are testing now on a M1 iMac and a M1 iPad Pro. Unfortunately we have crashes in one unit test and all the more complex examples and middleware.
    • iMac with M1 chip running at 3840x2160 resolution iMac with M1 Running 10_PerPixelProjectedReflections

      iPad with M1 chip running with 1024x1366 resolution iPad with M1 Running 10_PerPixelProjectedReflections

      It is astonishing how well the iPad with M1 chip perform. Due to -what we consider driver bugs- M1 hardware crashes in

      • Aura
      • 16_raytracing
      • Visibility Buffer
      • Ephemeris
    • UI / Fonts / Lua interface refactor
      • Moved Virtual Joystick to IInput.h / InputSystem.cpp
      • Pulled current Lua implementation out of AppUI and gave it its own interface (IScripting.h)
      • Pulled Fontstash implementation out of AppUI and gave it its own interface (IFont.h)
      • IFont and IScripting are now initialized on the OS Layer, with user customization functions available on the App Layer
      • Fonts and Lua can now be disabled via preprocessor defines and UI will still function (using default 'ProggyClean' font)
    • Zip unit test refactor to support encryption and writes into archive
    • For one of our customer projects we need password encryption, so we replaced our old zip library with

      minizip ng

    • Extended iOS Gesture / Android gesture support
    • For the same project we added more gesture support for mobile platforms.
    • Partial C99 rewrite of OS/Interfaces headers and implementation files
    • Our on-going effort to make TF easier to use is to rewrite parts in C99, so that teams can work with it more efficiently, the compile time goes down as well as the memory footprint is smaller.
    • OpenGL ES 2 - Unit test 17 is now working as well.
    • GitHub fixes:
      • Pull Request "Fix typo" #199
      • Pull Request "Fix iOS Xcode OpenGL ES Error breakpoint crash" #202
      • Pull Request "Reduce GL ES buffer allocation frequency" #204
      • Pull Request "Apple silicon m1 fixes" #208
    Source code(tar.gz)
    Source code(zip)
  • v1.48(May 25, 2021)

    This is our biggest update since we started this repository more than three years ago. This update is one of those "what we have learned from the last couple of projects that are using TF" updates and a few more things.

    • Aura - Dynamic Global Illumination - we developed this system in the 2010 / 2011 time frame. It is hard to believe it is 10 years ago now :-) ... it shipped in Agents of Mayhem at some point and was implemented and used in other games. We are just putting the "base" version without any game specific modifications in our commercial Middleware repository on GitHub. The games that used this system made specific modifications to the code base to align with their art asset and art style. In today's standards this system still fulfills the requirement of a stable rasterizer based Global Illumination system. It runs efficiently on the original XBOX One, that was the original target platform, but might require art asset modifications in a game level. It works with an unlimited number of light sources with minimal memory footprint. You can also cache the reflective shadow maps for directional, point and spotlights the same way you currently cache shadow maps. At some point we did a demo running on a second generation integrated Intel GPU with 256 lights that emitted direct and indirect light and had shadow maps in 2011 at GDC? :-) It is best to integrate that system in a custom game engine that can cache shadow maps in an intelligent way.

    Aura - Windows DirectX 12 Geforce 980TI 1080p Driver 466.47

    Aura on Windows DX12

    Aura - Windows Vulkan Geforce 980TI 1080p Driver 466.47

    Aura on Windows Vulkan

    Aura - Ubuntu Vulkan Geforce RTX 2080 1080p

    Aura on Ubuntu Vulkan

    Aura - PS4

    Aura on Ubuntu Vulkan

    Aura - XBOX One original

    Aura on Ubuntu Vulkan

    • Forge Shader Language (FSL) translator - after struggeling with writing a shader translator now for 1 1/2 years, we restarted from scratch. This time we developed everything in Python, because it is cross-platform. We also picked a really "low-tech keep it simple" approach. The idea is that a small game team can actually maintain the code base and write shaders efficiently. We wanted a shader translator that translates a FSL shader to the native shader language of each of the platforms. This way whatever shader compiler is used on that platform can take over the actual job of compiling the native code. The reason why we are doing this lies mostly in the unreliability of DXC and SPIR-V in general and also their lack of reliability if it comes to cross-platform translation.

      There is a Wiki entry that holds a FSL language primer and general information how this works here:

      https://github.com/ConfettiFX/The-Forge/wiki

    • Run-Time API Switching - we had some sort of run-time API switching in an early version of The Forge. At the time we were not expecting this to be very useful because most game teams do not switch APIs on the fly. In the meantime we found a usage case on Android, where we have to reach a large number of devices. So we came up with a better solution that is more consistent with the overall architecture and works on at least PC and Android platforms. On Windows PC one can switch between DX12, Vulkan and DX11 if all are supported. On Android one can switch between Vulkan and OpenGL ES 2.0. The later allows us to target a much larger group of devices for business application frameworks. We could extend this architecture to other platforms like consoles easily. This new API switching required us to change the rendering interfaces. So it is a breaking change to existing implementations but we think it is not much effort to upgrade and the resulting code is easier to read and maintain and overall improves the code base by being more consistent.

    • Device Reset - This was implemented together with API switching. Windows forces game developers to respond to a crashing device driver by resetting the device. We implemented the functionality already in the last update here on GitHub. This update integrates it better into the OS base layer. We also verified that the life cycle management for Windows in each application based on the IApp interface works now for device change, device reset and for API switching so that we can cover all cases of losing and recovering the device.

      The functions for API switching and device reload and reset are:

    void onRequestReload();
    void onDeviceLost();
    void onAPISwitch();
    
    • Variable Rate Shading (VRS) - we implemented VRS in a new unit test 35_VariableRateShading. It is only supported by DirectX 12 on Windows and XBOX Series S / X. In this demo, we demonstrate two main ways of setting the shading rate:

      • Per-tile Shading Rate: Generating a shading rate lookup texture on-the-fly. Used for drawing the color palette which makes up the background. The rate decreases the further the pixels are located from the center. We can see artifacts becoming visible at aggressive rates, such as 4X4. There is also a slider in the UI to modify the center of the circle.

    Per-tile Shading Rate

    • Per-draw Shading Rate: The cubes are drawn by a different shading rate. They are following the Per-draw rate, which can be changed via the dropdown menu in the UI. By using a combiner that overrides the screen rates, we ensure that cubes are drawn by an independent rate.

    Per-draw Shading Rate The cubes are using per-draw shading rate while the background is using per-tile shading rate.

    • Notes:

      • There is a debug view showing the shading rates and the tiles' size.
      • Per-tile method may not be available on certain GPUs even if they support the Per-draw method.
      • The tile size is enforced by the GPU and is readable, as shown in the example.
      • The shading rates available can vary based on the active GPU.
    • Multi-Sample Anti-Aliasing (MSAA) - we added a dynamic way of picking MSAA to unit test 9 and the Visibility Buffer example on all platforms.

    PC MSAA

    PS4 MSAA

    PS5 MSAA

    • Android & OpenGL ES 2 - the OpenGL ES 2 layer for Android is now more stable and tested and closer to production code. As mentioned above on an Android phone one can switch between Vulkan and OpenGL ES 2 dyanmically if both are supported. Now Android & OpenGL ES 2 support additionally unit test 17 - Entity Component System Test. In general we are testing many Android phones at the moment on the low and high end of the spectrum following the two Android projects we are currently working on, which are on both ends of the spectrum.

    • PVS Studio - we did another manual pass on the code base with PVS Studio -a static code analyzer- to increase code quality.

    Source code(tar.gz)
    Source code(zip)
  • v1.47(Dec 18, 2020)

    As the year winds slowly down, we finally found time to do another release. First of all, Happy Holidays and a happy new Year!

    Happy Holidays and a happy new Year!

    Most of us will take off over the Holiday season and spent time with their families. We should be back online in the middle of January 2021.

    • OpenGL ES 2.0: TF will run on probably several hundred million of mobile devices in the future. It will be the rendering layer of business application frameworks. For this usage case, we added OpenGL ES 2.0 support only for Android. The OpenGL ES 2.0 layer only supports unit tests 1, 5, 12 and 31 at the moment.
    • Device change / reset: we finally implemented all the code that can deal with device changes, device resets or device removed scenarios on all platforms. The underlying design was always there but it took us 3+ years to finally add the functionality :-) When you go into any of the *OSBase.* files you can find a snippet of code that looks like this:
    if (pApp->mSettings.mResetGraphics) 
    	{
    		pApp->Unload();
    		pApp->Load();
    		pApp->mSettings.mResetGraphics = false;
    	}
    
    • DRED / Breadcrumb support: to be able to better tell what the reason behind a removed device is, we implemented DRED support on PC with DirectX 12 and XBOX. We integrated this into the first functional test 01_Transformations. Here is a screenshot. Look for the "Simulate crash" button:

    Image of the Transformations Unit test

    Breadcrumb are user defined markers used to pinpoint which command has caused GPU to stall. In the Breadcrumb unit test, two markers get injected into the command list. Pressing the crash button would result in a GPU hang. In this situation, the first marker would be written before the draw command, but the second one would stall for the draw command to finish. Due to the infinite loop in the shader, the second marker won't be written, and we can reason that the draw command has caused the GPU to hang. We log the markers' information to verify this. Check out this link for more info: D3D12 Device Removed Extended Data (DRED)

    • More Lua Scripting support for all functional tests:
      • For the scripted testing of the Unit Tests, this layer provides automated function registration of the UI elements to Lua State.
      • Any UI elements added to the GUI will add a function or a pair of function(Getter/Setter) to the Lua state for using them in any script. Lua function name resolution will work like this:
      • UI Widget "label" name will be included in the function name as follows,
        • For Widget events: label name + "Event Name". e.g., Lua Function name for label - "Press", and event - OnEdited : "PressOnEdited"
        • For Widget modifiers such as ints / floats: "Set" and "Get" function pair will be added as a prefix to label name e.g., "X" variable will have "SetX" and "GetX" pair of functions.
    • After writing the scripts, you can let the layer know about the scripts using AddTestScripts() function call and run them on any frame by RunTestScript() defined in UIApp class. There are examples of these test scripts in most of the UTs showing how you can also add these scripts to UI and test them on runtime.

    Here is how the current Lua support in the functional tests might look like:

    Lua support

    • DX11 refactor: we re-wrote the DX11 run-time a few times. We ended up with the most straighforward version. This version only recently shipped in Hades along with the Vulkan run-time on PC.

    • YUV support: we have now YUV support for all our Vulkan API platforms PC, Linux, Android and Switch. There is a new functional test for YUV. It runs on all these platforms:

    YUV unit test

    • Audio: we removed the audio functional test. It was the only test that was released unfinished and didn't run on all our platforms. Our customers show love for FMOD ... would make more sense to show an integration of that.

    • GitHub issues fixed:

      • #188 - typo - lowercase L in first DepthStencilClearFlags constant "ClEAR_DEPTH"
      • #186 - Ubuntu: Examples fail to build
      • #182 - Flickering on master when vsync is off
      • #176 - [08_GlftViewer] Application crash on missing resource

    Numerous other fixes ...

    Source code(tar.gz)
    Source code(zip)
  • v1.46(Oct 2, 2020)

    • Supergiant's Hades we are working with Supergiant since 2014. One of the on-going challenges was that their run-time was written in C#. At the beginning of last year, we suggested to help them in building a new cross-platform game engine in C/C++ from scratch with The Forge. The project started in April 2019 and the first version of this new engine launched in May this year. Hades was then released for Microsoft Windows, macOS, and Nintendo Switch on September 17, 2020. The game can run on all platforms supported by The Forge.

    Here is a screenshot of Hades running on Switch:

    Supergiant Hades

    Here is an article by Forbes about Hades being at the top of the Nintendo Switch Charts. Hades is also a technology showcase for Intel's integrated GPUs on macOS and Windows. The target group of the game seems to often own those GPUs.

    • Windows management: there is a new functional test named 32_Window that demonstrates windows management on Windows, Linux and macOS.
      • The window layout, position, and size are now driven by the client dimensions, meaning that the values that the client demands are the exact values the client area will be represented with, regardless of the window style. This allows for much greater flexibility and consistency, especially when working with a fullscreen window.
      • Multi-monitor support has also been improved significantly, offering smooth consistent transitions between client displays and guaranteeing correct window behavior and data retention. Media layer functionality has been expanded, allowing the client to control mouse positioning, mouse visibility, and mouse visual representation.
      • It is now possible to create independent mouse cursors to further customize the application.

    Here are the screenshots:

    Windows: Windows Management for Windows

    macOS: Windows Management for macOS

    Linux: Windows Management for Linux

    • Screen-Space reflections: we renamed the functional test "10_PixelProjectedReflections" to 10_ScreenSpaceReflections. You have now two choices: you can pick either Pixel Projected Reflections or AMD's FX Stochastic Screen Space Reflection. We just made AMD's FX code cross-platform. It runs now on Windows, Linux, macOS, Switch, PS and XBOX.

    Here are the screenshots:

    Windows final scene: AMD FX Stochastic Screen Space Reflections

    Without denoising: AMD FX Stochastic Screen Space Reflections before denoise

    With denoising: AMD FX Stochastic Screen Space Reflections before denoise

    PS4: AMD FX Stochastic Screen Space Reflections on PS4

    macOS: AMD FX Stochastic Screen Space Reflections on macOS

    • Resolved GitHub issues:
      • Issue #183 - VERTEX_ATTRIB_RATE_INSTANCE ignored on macOS 10.12, iOS 10.0
    Source code(tar.gz)
    Source code(zip)
  • v1.44(Aug 13, 2020)

    • Mobile Devices: DPI scaling is properly handled now so we shouldn't see messed up UI anymore on mobile devices

    • Android: the following Unit-tests are now included for Android:

      • 03_MultiThread 03_MultiThread
      • 04_ExecuteIndirect 04_ExecuteIndirect
      • 07_Tesselation 07_Tesselation
      • 10_PixelProjectedReflections 10_PixelProjectedReflections
      • 12_ZipFileSystem 12_ZipFileSystem
      • 13_UserInterface 13_UserInterface
      • 14_WaveIntrinsics 14_WaveIntrinsics
      • 15_Transparency 15_Transparency
    • gamepad support: tested with PS4 controller

    • sample size reduction

    • proper closing of apps with the back button

    • proper handling of vSync

    • .zip filesystem handling

    • shader compile #include directive support

    • overall stability improvements

    • improved swapchain creation process and proper handling of current frame index

    • Linux:

      • Window management is improved
      • Borderless fullscreen is supported
      • Implemented full screen toggle (usually alt-enter)
      • Cursor position is now correct
      • Camera movement with mouse now works properly
      • Resources are freed properly
    Source code(tar.gz)
    Source code(zip)
  • v1.43(Aug 13, 2020)

    • Filesystem: it turns out the file system is still confusing and not intuitive. It mixes up several concepts but is not consistent and somehow favors Windows folder naming conventions, that do not exist in most of our target platforms. We did a slight first step with this release. We need to make a deeper change with the next release.
    • DirectX 11: the DirectX 11 run-time gets a lot of mileage now. For one game it went now successfully through a test center. This release holds a wide range of changes especially for multi-threaded rendering.
    • MTuner : we are making another attempt on integrating MTuner into the framework. We need it to tune memory usage in some game titles. The current version only reliably supports Windows but we try to extend it to more platforms.
      • Integrated Milos Tosic’s MTuner SDK into the Windows 10 runtime of The Forge. Combined with mmgr, this addition will provide the following features:
        • Automatic generation of .MTuner capture file alongside existing .memleaks file.
        • In-depth analysis of the generated file using MTuner’s user-friendly UI app.
        • Clear and efficient highlighting of memory leaks and usage hotspots.
      • Support for additional platforms coming soon!

    MTuner MTuner was integrated into the Windows 10 runtime of The Forge following a request for more in-depth memory profiling capabilities by one of the developers we support. It has been adapted to work closely with our framework and its existing memory tracking capabilities to provide a complete picture of a given application’s memory usage.

    To use The Forge’s MTuner functionality, simply drag and drop the .MTuner file generated alongside your application’s executable into the MTuner host app, and you can immediately begin analyzing your program’s memory usage. The intuitive interface and exhaustive supply of allocation info contained in a single capture file makes it easy to identify usage patterns and hotspots, as well as tracking memory leaks down to the file and line number. The full documentation of MTuner can be found [here](link: https://milostosic.github.io/MTuner/).

    Currently, this feature is only available on Windows 10, but support for additional platforms provided by The Forge is forthcoming. Here is a screenshot of an example capture done on our first Unit Test, 01_Transformations: MTuner

    • Multi-Threading system: especially for the Switch run-time we extended our multi-threading system to support a "preferred" core.
    • macOS / iOS run-time got another make over. This time we brought the overall architecture a bit closer to the rest of the rendering system and we are also working towards supporting lower end hardware like a 2015 MacBook Air and macOS 10.13.6. Those requirements were based on the Steam Hardware Survey.
    • there are now functions that help you calcuate the memory usage supported by all APIs: look for caculateMemoryUse / freeMemoryStats
    • Windows management got a bit more flexible by offering borderless windows and more style attributes
    • 17_EntityComponentSystem runs now better on AMD CPUs ... there were some inefficiencies in the unit test ...
    Source code(tar.gz)
    Source code(zip)
  • v1.42(Aug 13, 2020)

    Most of us are working from home now due to the Covid-19 outbreak. We are all trying to balance life and work in new ways. Since the last release we made a thorough pass through the macOS / iOS run-time, so that it is easier to make macOS your main development environment for games. Unit-tests fixes:

    • Fixed wrong project ordering in XCode
    • Fixed build-time macOS / iOS warnings.
    • Fixed 03_Multithread until test not showing the appropriate charts for all threads
    • Fixed warnings in 06_MaterialPlayground due to wrong GLTF validation
    • Fixed visual artifacts in 08_GLTFViewer not producing correct normals due to wrong Metal shader.
    • Added missing projects to macOS / iOS workspace and removed unnecessary ones.
    • Fixed unit test 14_WaveIntrinsics macOS on AMD iMac. Implemented workaround for AMD driver issue on macOS.

    Metal runtime fixes:

    • Fixed Metal issue handling barriers: scheduled barriers were being ignored, introducing visual artifacts due to read-write race condition.

    Closed Issues:

    • #168 - 04_ExecuteInDirect poor performance on MacPro 2019, AMD Vega II, Catalina 10.15.3
    • #156 - Benchmark support?
    Source code(tar.gz)
    Source code(zip)
  • v1.41(Aug 13, 2020)

    • Based on request we are providing a Path Tracing Benchmark in 16_RayTracing. It allows you to compare the performance of three platforms:

      • Windows with DirectX 12 DXR
      • Windows with Vulkan RTX
      • Linux with Vulkan RTX

      We believe that every benchmarking tool should be open-source, so that everyone can see what the source code is doing. We will extend this benchmark to the non-public platforms we support to compare the PC performance with console performance. The benchmark comes with batch files for all three platforms. Each run generates a HTML output file from the microprofiler that is integrated in TF. The default number of iterations is 64 but you can adjust that. There is a Readme file in the 16_RayTracing folder that describes the options.

    Windows DirectX 12 DXR, GeForce RTX 2070 Super, 3840x1600, NVIDIA Driver 441.99

    Windows DXR output of Ray Tracing Benchmark

    Windows Vulkan RTX, GeForce RTX 2070 Super, 3840x1600, NVIDIA Driver 441.99

    Windows RTX output of Ray Tracing Benchmark

    Linux Vulkan RTX, Geforce RTX 2060, 1920x1080, NVIDIA Driver 435.21

    Linux RTX output of Ray Tracing Benchmark

    We will adjust the output of the benchmark to what users request.

    • With this release we also aligned the whole renderer interface better to 64 byte CPU cache lines. We trimmed down all the structs substantially and removed many. This is a breaking change for the renderer interface and a major change to the whole code base.
    • DirectX 12
      • D3D12 Memory Allocator: we are using now AMD's D3D12 memory allocator for DirectX after having used the Vulkan equivalent for more than two years. We also extended it to support Multi-GPU.
      • We upgraded to the latest dxgi factory interface in DirectX 12
    • Microprofiler: because we need the microprofiler to offer the QA department help in reporting performance problems for some of the games that will be shipping with TF (and the benchmark mentioned above), we did another pass on its functionality and ease of use, especially on console platforms. The idea is that QA can quickly and easily store a screenshot or HTML file in a bug report. This is still work in progress and with every shipping game will probably be improved.
    • Now that GDC 2020 was postponed, we will also postpone our GDC related activities. The user meeting and our GDC talk will be postponed until the next GDC happens. If there is a need we can also do a user meeting in an online conference room or in Discord in a private area. Let us know.
    • Renamed CustomMiddleware to Custom-Middleware back ...
    Source code(tar.gz)
    Source code(zip)
  • v1.40(Aug 13, 2020)

    This release took much longer than expected ... :-)

    • We are going to give a talk at GDC during the GPU Summit day. It will cover our skydome system Ephemeris 2: GDC 2020 Ephemeris
    • We will also have a user group meeting during GDC: The Forge User Group
    • A new resource loader can now stream textures, buffers and additionally geometry (extracted from glTF) asynchronously. We replaced assimp with this loader to save compile time and space on GitHub. We still use assimp for our internal tools. Here are the underlying design principles of the resource loader:
      • Generally glTF is just a geometry container for us. We do not apply any of the underlying principles like material or mesh or scene management that it offers because they are not tailored to our needs. The resource loader only loads a glTF file, extract its geometry and stores this data (including hair and ozz animation system data) in a vertex and index buffer stream.
      • All texture loading and material loading is the responsibility of the app. Scene partitioning or material support is not used from glTF. Those remain on the App level. Each app has its own lighting and material models and it shouldn't be restricted to the very limiting architecture of glTF
      • There is no glTF code in any of the unit tests or app examples with the exception of the glTF viewer. The resource loader loads geometry just with a addResource call as it loads textures and buffers ... it can generate a vertex and index buffer stream with offset values for draw calls or for ExecuteIndirect ...
    • All model art assets were converted to glTF
    • libzip was replaced with zip because it is easier to maintain.
    • Console support: at the end of last year before our three week break, we made the PS4 and Switch run-times ready to ship games (we will see first games shipping this year). We also started on the PS5 and XBOX One Series X support. You need to be an acredited developer to receive the source code for any consoles. We will be asking the console owner for permission before we would provide you with any source code. That means you have to be part of their developer program.
    • Improved Windows 7 support: one of the games TF is launching with requires Windows 7 support. This means we are now testing the Windows 7 run-time more rigourously and committed fixes with this release
    • Math library: added missing vec2 functions
    • Updated copyright statement
    • Resolved issues on GitHub:
      • issue 162 - 13_UserInterface - Crash
      • issue 161 - 18_VirtualTexture breaks with dx and vk: only fairly decent cards support virtual textures. We added tracking support in the *.cfg system and throw an error message when the GPU doesn't support the feature.
      • issue 124 - Missing KeyKpAdd mapping
    Source code(tar.gz)
    Source code(zip)
  • v1.45(Aug 13, 2020)

    • TressFX: we upgraded TressFX a bit and retuned the lighting.

    Here are the screenshots: Black hair

    Blond hair

    Brown hair

    Red hair

    • File system: our old file system was designed more for tools or Windows applications than for games. It consumed more memory than the whole rendering system and used Windows file methods extensively. That is the opposite of what you want in a game. It took us now several months to correct the mistake and come up with a file system that is tailored towards games. That means that the interface changed substantially. Thanks to all those who pointed this out. Sometimes it takes a couple of iterations to land on a design that is efficient. If you look at the new interface there are still path related functions in there. They will be removed step-by-step. Please check out the new file system interface and let us know what you think.

    • Android Vulkan: validation layer is now supported

    Source code(tar.gz)
    Source code(zip)
  • v1.39(Dec 7, 2019)

    The Forge has now support for Sparse Virtual Textures on Windows and Linux with DirectX 12 / Vulkan. Sparse texture (also known as "virtual texture", “tiled texture”, or “mega-texture”) is a technique to load huge size (such as 16k x 16k or more) textures in GPU memory. It breaks an original texture down into small square or rectangular tiles to load only visible part of them.

    The unit test 18_Virtual_Texture is using 7 sparse textures:

    • Mercury: 8192 x 4096
    • Venus: 8192 x 4096
    • Earth: 8192 x 4096
    • Moon: 16384 x 8192
    • Mars: 8192 x 4096
    • Jupiter: 4096 x 2048
    • Saturn: 4096 x 4096

    There is a unit test that shows a solar system where you can approach planets with Sparse Virtual Textures attached and the resolution of the texture will increase when you approach.

    Linux 1080p NVIDIA RTX 2060 Vulkan Driver version 435

    Sparse Virtual Texture on Linux Vulkan

    Windows 10 1080p AMD RX550 DirectX 12 Driver number: Adrenaline software 19.10.1

    Sparse Virtual Texture on Windows 10 DirectX 12

    Windows 10 1080p NVIDIA 1080 Vulkan Driver number: 418.81

    Sparse Virtual Texture on Windows Vulkan

    Sparse Virtual Texture on Windows Vulkan

    Ephemeris 2 - the game Stormland from Insomniac was released. This game is using a custom version of Ephemeris 2. We worked for more than six months on this project.

    Stormland

    Stormland

    Stormland

    Stormland

    Stormland

    Stormland

    Stormland

    Head over to Custom Middleware to check out the source code.

    Source code(tar.gz)
    Source code(zip)
  • v1.38(Nov 19, 2019)

    • The new 16_Raytracing unit test shows a simple cross-platform path tracer. On iOS this path tracer requires A11 or higher. It is meant to be used in tools in the future and doesn't run in real-time. To support the new path tracer, the Metal raytracing backend has been overhauled to use a sort-and-dispatch based approach, enabling efficient support for multiple hit groups and miss shaders. The most significant limitation for raytracing on Metal is that only tail recursion is supported, which can be worked around using larger per-ray payloads and splitting up shaders into sub-shaders after each TraceRay call; see the Metal shaders used for 16_Raytracing for an example on how this can be done.

    macOS 1920x1080 AMD Pro Vega 64

    Path Tracer running on macOS

    iOS iPhone X 812x375

    Path Tracer running on macOS

    Windows 10 1080p NVIDIA RTX 2080 with DXR Driver version 441.12

    Path Tracer running on Windows DXR

    Windows 10 1080p NVIDIA RTX 2080 with RTX Driver version 441.12

    Path Tracer running on Windows RTX

    Linux 1080p NVIDIA RTX 2060 with RTX Driver version 435

    Path Tracer running on Linux RTX

    • File System: Fixed an issue wherein compiled shader binaries weren’t being saved to the RD_SHADER_BINARIES resource directory
    • GitHub issues fixed:
      • #150 - [Vulkan] Failed to extend descriptor pool
      • #151 - [Vulkan] rootcbv of detection is case sensitive
      • #152 - [Vulkan] updateDescriptorSet is different from the DirectX12
    Source code(tar.gz)
    Source code(zip)
  • v1.37(Oct 31, 2019)

    The Forge Interactive Inc., the company behind The Forge became a Khronos Associate member.

    • Ephemeris 2
      • New features
        • Add Earth radius: controls the radius of clouds' radius with scale factor. The clouds field will be flatter and the user can see further along the horizon if the radius increase
        • Add noise flow: controls the direction and intensity of clouds' noise flow
        • Add rotation: rotates clouds based on a certain pivot position.
        • Add the second layer: it is possible to generate the second cloud layer which can act, independently
        • Add FXAA
      • Improvement
        • Ray-marching: now, hard-edge artifact is significantly reduced
        • Silver-lining: improved its quality
        • God ray: improved its quality
      • Performance: up to 25% performance increased

    Click on the following image to see a video:

    Ephemeris 2 Head over to Custom Middleware to check out the source code.

    • macOS / iPad / iOS: ICB support for Metal renderer (draw; draw indexed; pipeline state switch with ICB; ICB optimization with BlitEncoder). The Visibility Buffer example now uses ICB features on MacOS
      • reduced memory consumption for argument buffers in Metal
      • fixes for Metal implementation of descriptor set
      • minor fixes and optimizations in Metal renderer
      • Due to bugs in the run-time for argument buffers we still can't run unit test 04, 06, and 10

    The Visibility Buffer example runs now faster on macOS macOS Visibility Buffer

    Source code(tar.gz)
    Source code(zip)
  • v1.36(Oct 31, 2019)

    • New cross-platform FileSystem C API, supporting disk-based files, memory streams, and files in zip archives. The API can be viewed in IFileSystem.h, and all of the example code has been updated to use the new API.
      • The API is based around Paths, where each Path represents an absolute, canonical path string on a particular file system. You can query information about the files at Paths, open files as FileStreams, and copy files between different Paths.
      • The concept of FileSystemRoots has been replaced by ResourceDirectorys. ResourceDirectorys are predefined directories where resources are expected to exist, and there are convenience functions to open files in resource directories. If your resources don’t exist within the default directory for a particular resource type, you can call fsSetPathForResourceDirectory to relocate the resource directory; see the unit tests for sample code on how to do this.
      • There's a new 12_FileSystem unit test that demonstrates how to read files from zip archives:

    File System Unit Test

    • Vulkan: Adaptive Order Independent Transparency with Raster Order Views is now supported when VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT is supported.
    Source code(tar.gz)
    Source code(zip)
  • v1.35(Oct 14, 2019)

    After only a bit more than one week we wanted to ship a quick update ...

    • Ozz Animation System: there is a new unit test added to The Forge.

    Ozz Inverse Kinematic: This unit test shows how to use Aim and Two bone IK solvers

    Ozz Aim IK

    Ozz Two Bone IK

    • Shader Translator:
      • Implicit cast fixes submitted for review
      • Added automated testing on mac via ssh from Windows - still requires integration in CI.
      • Argument buffer support
      • Fixed scalar swizzle in MSL
      • Fixed texture array output in MSL
      • Fixed indentation in MSL for compute shaders
      • Fixed redundant parenthesis in if statement warning in HLSL and MSL
      • Fixed texture object Load method output for MSL
    • Maintenance Update macOS / iOS:
      • Unified depth-stencil texture handling across macOS and iOS. To use a combined
      • The TEXTURE_CREATION_FLAG_ON_TILE flag now specifies that a render target attachment should neither be loaded or stored, in addition to ensuring that the attachment is memoryless on iOS
      • Added TEXTURE_CREATION_FLAG_ON_TILE to the depth buffers within many of the unit tests
      • Fixed a resource barrier issue in the Tessellation unit test on macOS and iOS
      • We still encounter many bugs especially on INTEL based devices. We have RADARs with Apple and we are hoping those will go away over time. Let us know if you need any help with the macOS / iOS run-time.

    If you want to join us in sunny Encinitas, CA, USA as a graphics programmer, we would like to hear from you. If you are interested in working in our offices world-wide please let us know as well. We are in Spain, Netherlands, Ukraine, India, New Zealand and other places.

    Source code(tar.gz)
    Source code(zip)
  • v1.34(Oct 14, 2019)

    • TinyImageFormat support: Deano Calver @DeanoC added his image format support library to The Forge. TinyImageFormat provides a query mechanism and encode/decode for many CPU and GPU image formats. Allowing you to use whatever pixel data is best whether its loading/saving or procedural generation.
    • Microprofiler: @zeuxcg this is the third rewrite of the Microprofiler. We replaced the proprietary UI with imGUI and simplified the usage. Now it is much more tightly and consistently integrated in our code base.

    Microprofiler

    Microprofiler

    Microprofiler

    Microprofiler

    Here are screenshots of the Microprofiler running a unit test on iOS:

    Microprofiler

    Microprofiler

    Microprofiler

    Check out the Wikipage for an explanation on how to use it.

    • Descriptor System: @gavkar this is at least the fourth rewrite of the descriptor system now with support for the brand new argument buffers on macOS / iOS. It requires latest OS and XCode versions. This is a major update to the macOS / iOS runtime and it comes with many implementation changes:

      • improved Metal resource usage with useHeaps and useResorces

      • Metal shader reflection system was refactored

      • fixes and optimizations for some unit tests on MacOS and iOS platforms

      • initial support for paramIndex

      • more informative debug labels for Metal resources

        This is probably the first engine integration of argument buffers, so there are issues with the following unit tests on iPadOS/iOS platforms:

      • 04_ExecuteIndirect_iOS: GPU hangs due to argument buffers corruption in latest iOS 13.1. The bug doesn't occur if validation layer is enabled!

      • 06_MaterialPlayground_iOS: Fails to compile shaders trying to write to Texture2DArray (iOS 13.1 beta 2 & 3)

      • 10_PixelProjectedReflections on iOS: iOS Metal shader compiler crashes

      Check out the Wikipage for a high-level view of the architecture.

    • Light & Shadow Playground: we cleaned up the code base of the Light & Shadow Playground and integrated missing pieces into The Forge Eco system.

    • Shader Translator: a lot of work went into the Shader Translator since the last release. Let us know how it works for you. There is a how-to on the Wiki page here:

      How to use the Shader Translator

    • Issues: fixed #129 "Metal backend buffer namespace collision"

    Source code(tar.gz)
    Source code(zip)
  • v1.33(Aug 31, 2019)

    • glTF model viewer - we build a simple cross-platform glTF model viewer by integrating Arseny Kapoulkine @zeuxcg excellent meshoptimizer and the same PBR as used in the Material Playground unit test.
      • It optimizes the geometry data set with all the features meshoptimizer offers
      • It will be extended in the future with more functionality, following some of our internal tools
      • Uses the cgltf reader from the same repository

    glTF model viewer running on iPad with 2048x1536 resolution

    glTF model viewer

    glTF model viewer

    glTF model viewer running on Samsung Galaxy S10 with Vulkan with 1995x945 resolution

    glTF model viewer

    glTF model viewer

    glTF model viewer running on Ubuntu AMD RX 480 with Vulkan with 1920x1080 resolution

    glTF model viewer

    glTF model viewer

    • Basis Universal Texture Support: TF now supports Binomials @richgel999 @google Basis Universal Texture Support as an option to load textures. Support was added to the Image class as a "new image format". So you can pick basis like you can pick DDS or KTX.

    • Shader Translator: since more than a year we are developing on and off a shader translator that allows us to define our own shader language. This shader language is an extension to HLSL and will in the future offer the opportunity to store more data for the various platforms. For example we will able to pre-compile pipelines with this setup. We are using it extensively to translate all the shaders you see in The Forge. You can find the source code in

      Common_3/ThirdParty/OpenSource/hlslparser

      The public version translates at the moment to HLSL, GLSL and Metal. Metal support is still work in progress. There is a test scenario where the shader translator translates most of the shaders of the unit tests and examples to HLSL and GLSL. It will be integrated into our Jenkins test system and it gets tested with every code change.

    • Input system: we re-architected the app level interface for our cross-platform input system based on gainput. Our previous interface somehow leaned toward PC input systems and we wanted to better focus on our main target platforms.

    • Ozz animation system: we cleaned up the code base. There was a lot of unused code because we wired up the system with all the "service providers" of The Forge. So Ozz like any other third party library is using the math, log, error, assert, file system, memory management and others sub-systems from The Forge. Previously, it had a lot of those implemented on its own.

    • Issues resolved:

      • 128 "The DepthStateDesc.mDepthTest is ignored on the Metal backend"
      • 130 "Vulkan and D3D12 backend set sampler maxLod to zero for nearest mipmap mode"
      • 131 "Vulkan sampler set the anistropy flag to false always."
    Source code(tar.gz)
    Source code(zip)
  • v1.32(Aug 17, 2019)

    • Ephemeris - Skydome System
      • Added Procedural Night Sky and Star-field - the night sky's nebula colors are now customizable
      • Added Glow effects on Sun and Moon
      • Fix the issue that Godrays can be drawn on unexpected area

    Click on the following screenshot to see a movie:

    Ephemeris 2

    • New Light and Shadow Playground: we rebuild the light and shadow playground by using the St. Miguel art assets and adding some new shadowing techniques:
      • Exponential Shadow Map - this is based on Marco Salvi's @marcosalvi papers. This technique filters out the edge of the shadow map by approximating the shadow test using exponential function that involves three subjects: the depth value rendered by the light source, the actual depth value that is being tested against, and the constant value defined by the user to control the softness of the shadow
      • Adaptive Shadow Map with Parallax Correction Cache - this is based on the article "Parallax-Corrected Cached Shadow Maps" by Pavlo Turchyn in GPU Zen 2. It adaptively chooses which light source view to be used when rendering a shadow map based on a hiearchical grid structure. The grid structure is constantly updated depending on the user's point of view and it uses caching system that only renders uncovered part of the scene. The algorithm greatly reduce shadow aliasing that is normally found in traditional shadow map due to insufficient resolution. Pavlo Turchyn's paper from GPU Pro 2 added an additional improvement by implementing multi resolution filtering, a technique that approximates larger size PCF kernel using multiple mipmaps to achieve cheap soft shadow. He also describes how he integrated a Parallax Correction Cache to Adaptive Shadow Map, an algorithm that approximates moving sun's shadow on static scene without rendering tiles of shadow map every frame. The algorithm is generally used in an open world game to approximate the simulation of day & night’s shadow cycle more realistically without too much CPU/GPU cost.
      • Signed Distance Field Soft Shadow - this is based on Daniel Wright's Siggraph 2015 @EpicShaders presentation. To achieve real time SDF shadow, we store the distance to the nearest surface for every unique Meshes to a 3D volume texture atlas. The Mesh SDF is generated offline using triangle ray tracing, and half precision float 3D volume texture atlas is accurate enough to represent 3D meshes with SDF. The current implementation only supports rigid meshes and uniform transformations (non-uniform scale is not supported). An approximate cone intersection can be achieved by measuring the closest distance of a passed ray to an occluder which gives us a cheap soft shadow when using SDF.

    To achieve high-performance, the playground runs on our signature rendering architecture called Triangle Visibility Buffer. The step that generates the SDF data also uses this architecture.

    Click on the following screenshot to see a movie:

    Signed Distance Field Soft Shadow Map

    The following PC screenshots are taken on Windows 10 with a AMD RX550 GPU (driver 19.7.1) with a resolution of 1920x1080.

    Exponential Shadow Maps:

    Light and Shadow Playground - Exponential Shadow Map

    Adaptive Shadow Map with Parallax Correction Cache

    Adaptive Shadow Map with Parallax Correction Cache

    Signed Distance Field Soft Shadow:

    Signed Distance Field Soft Shadow Map

    Signed Distance Field Soft Shadows - Debug Visualization

    Signed Distance Field Soft Shadow Map

    The following shots show Signed Distance Field Soft Shadows running on iMac with a AMD RADEON Pro 580

    Signed Distance Field Soft Shadow Map

    Signed Distance Field Soft Shadow Map

    The following shots show Signed Distance Field Soft Shadows running on XBOX One:

    Signed Distance Field Soft Shadow Map

    Signed Distance Field Soft Shadow Map

    Signed Distance Field Soft Shadow Map

    Readme for Signed Distance Field Soft Shadow Maps:

    To generate the SDF Mesh data you should select “Signed Distance Field” as the selected shadow type in the Light and Shadow Playground. There is a button called “Generate Missing SDF” and once its clicked, it shows a progress bar that represents the remaining SDF mesh objects utilized for SDF data generation. This process is multithreaded, so the user can still move around the scene while waiting for the SDF process to be finished. This is a long process and it could consume up to 8+ hours depending on your CPU specs. To check how many SDF objects there are presently in the scene, you can mark the checkbox "Visualize SDF Geometry On The Scene".

    • Android: we switched from AndroidStudio to Visual Studio, because the AndroidStudio environment didn't allow us to work effectively and integrating it into our Jenkins test system made the build time explode.
    • Vulkan:
      • support of GPU assisted validation
      • new Vulkan SDK 1.1.114 is supported
    • Art package: we updated the St. Miguel scene with colored flags for the future Aura Global Illumination example. Because it is used by several unit tests, you want to download the art package again. See the Install instructions below for how to do this.

    P.S: we have a new logo :-) The Forge Logo

    Source code(tar.gz)
    Source code(zip)
  • v1.31(Aug 17, 2019)

    • macOS / iOS - we are now supporting Metal 2.2 on those platforms. The macOS version of the Visibility Buffer now uses primitive_id argument that allows to use indexed geometry similar to the Vulkan and DirectX 12 versions. There is a significant increase in performance and reduction in memory consumption
      • Debug labels for buffers and textures now present in frame captures;
      • cmdSynchronizeResources for MacOS and iOS;
      • Minor fixes in GPU synchronization with memory barriers
      • Minor fixes in ArgumentBuffers implementation

    Please note that we use the early beta system and XCode versions for development. So there might some instabilities.

    Here is a screenshot: Macbook Pro 2017 with Radeon Pro 560 3360x2100 resolution Visibility Buffer with Metal 2.2

    • Android - we increased the number of unit tests support. With this release we additionally support on the devices mentioned below:

      • 06_MaterialPlayground
      • 18_Playback
      • 19_Blending
      • 20_JoinAttachment
      • 21_PartialBlending
      • 22_AdditiveBlending
      • 23_BakedPhysics
      • 24_MultiThread
      • 25_Skinning
      • 26_Audio
    • Vulkan:

      • Updated volk Metaloader for Vulkan to latest
      • The Forge supports now as the min spec for the Vulkan SDK 1.1.82.0 and as the max spec is 1.1.101.0
    • Discord: we offer now also support through a discord channel. Sign up here: Twitter Join the Discord channel at https://discord.gg/hJS54bz

    • User Group Meetings - there will be a user group meeting during GDC. In case you want to organize a user group meeting in your country / town at any other point in time, we would like to support this. We could send an engineer for a talk.

    • Support for Education - in case your School / College / University uses The Forge for education, we would like to support this as well. We could send an engineer or help create material. So far the following schools use The Forge for teaching:

    Breda University of Applied Sciences

            Contact:
            Jeremiah van Oosten 
            Monseigneur Hopmansstraat 1
            4817 JT Breda
    

    Ontario Tech University

            Contact:
            Andrew Hogue
            Ontario Tech University
            SIRC 4th floor
            2000 Simcoe St N
            Oshawa, ON, L1H 7K4
    
    • Writing Guidelines - For contributions to The Forge we apply the following writing guidelines:
      • We limit now all code to C++ 11 by setting the Clang and other compiler flags
      • We follow the [Orthodox C++ guidelines] (https://gist.github.com/bkaradzic/2e39896bc7d8c34e042b) minus C++ 14 support (see above)
    Source code(tar.gz)
    Source code(zip)
  • v1.30(Jul 12, 2019)

    • Ephemeris 2: this is a new volumetric skydome system developed for PS4 / XBOX One class of hardware. Click on the image to watch a video:

    Ephemeris 2

    For Ephemeris and the rest of our commercial custom middleware there is now a new GitHub repository here Custom-Middleware

    We also have a skydome system for mobile hardware called Ephemeris 1, that will be released on GitHub later.

    • Android: we are supporting now more and more unit tests in Android by improving the run-time support. Here are screenshots:

    01_Transformations 01_Transformations

    02_Compute 02_Compute

    05_FontRendering 05_FontRendering

    09_LightAndShadow 09_LightAndShadow

    13_imGUI 13_imGuI

    17_EntityComponentSystem 17_EntityComponentSystem

    We added the Samsung S10 Galaxy phone (Qualcomm Adreno 640 Graphics Card (Vulkan 1.1.87)) to the test devices for Android.

    • ENTT: we decided to remove ENTT and replace it with our own ECS system that we use internally for tools. ENTT in debug is too slow for practical usage because it decreases execution speed and increases compile times substantially. It appears that "modern C++ 17" and probably also "modern C++ 14" is not ready for usage in a team environment because it decreases productivity too much. We tried to remove C++ 17 and 14 features to make it run faster but it ended up too much work. We went from more than 200 ms with ENTT to 60 ms with our own ECS running a Debug build on a Intel Core i7-6700T 2.8GHz. In release our own system is in the moment not as fast as ENTT but we will fix that.

    • Audio: we did a first pass on integrating SoLoud for all our platforms. There is a new unit test:

    26_Audio

    • Linux: following STEAM, we are switching to the Mesa RADV driver in our test environment for AMD GPUs. For NVIDIA GPUs we are still using the NVIDIA driver.

    • Texture Asset pipeline: we did a first pass on a unified texture asset pipeline. On the app level only the name of the texture needs to be provided and then depending on the underlying platform it will attempt to load the "optimal compressed" texture, which in the moment is either KTX or dds. In the future there will be Google Basis support as well.

      • Removed support for various non-optimal texture file formats - png, jpg, tga, hdr, exr
      • Add ASTC support for iOS through KTX container
      • Add compressed textures for all unit test resources
      • Add BC6H signed and unsigned float variants

    Please make sure you download the art asset zip file again with the help of the batch file.

    • Issue list:
      • issue #109 "Texture updates broken" is fixed now
      • NVIDIA GTX 1660 bug: this card with the Vulkan run-time and driver 419.35 became unresponsive, while the DirectX 12 run-time works as expected. Any other NVIDIA GPU works fine ... this looks like a driver bug ...
    Source code(tar.gz)
    Source code(zip)
  • v1.29(Jun 11, 2019)

    • We replaced for all platforms TinySTL with EASTL for support of additional data structures and functionality. This was a major change and we still expect a few bugs to appear.
    • ARM based platforms (iOS/Android) can pick a new NEON intrinsics code path in our math library
    • Microprofiler
      • Multithreaded GPU Profiling is now supported
      • Microprofiler is now enabled on all the Unit-tests and togglable using UI checkbox.
      • Added new common interface, IProfiler.h
    • Issue fixed:
      • #105 - 04_ExecuteIndirect crash on macOS
    Source code(tar.gz)
    Source code(zip)
  • v1.28(Jun 11, 2019)

    We added a new section below the Examples to show screenshots and an explanation of some of the Tools that we integrated. We will fill this up over the next few releases.

    • We were helping James Webb with his level editor for 'Star Wars Galaxies' called SWB that now uses The Forge

    Here is a screenshot

    SWB Level Editor

    SWB is an editor for the 2003 game 'Star Wars Galaxies' that can edit terrains, scenes, particles and import/export models via FBX. The editor uses an engine called 'atlas' that will be made open source in the future. It focuses on making efficient use of the new graphics APIs (with help from The-Forge!), ease-of-use and terrain rendering.

    • Memory tracking:
      • Fluid memory tracker cross-platform for Windows, macOS and Linux
      • We used MTuner to remove many memory leaks and improve memory usage. MTuner might be integrated in the future.
    • Micro Profiler: our initial implementation of Microprofiler needed to be re-done from scratch. This time we wanted to do the integration right and also implemented the dedicated UI.

    Microprofiler in Visibility Buffer

    Microprofiler in Visibility Buffer

    To enable/disable profiling, go to file ProfileEnableMacro.h line 9 and set it to 0(disabled) or 1(enabled). It's supported on the following platforms:

    • Windows
    • Linux
    • macOS (GPU profiling is disabled)
    • iOS (GPU profiling is disabled)
    • Android(WIP will be enabled later on)

    We can find MicroProfile integrated in the follwing examples (more will follow):

    • Unit Test 02_Compute
    • VisibilityBuffer

    How to use it: MicroProfile has different display modes. The most useful one when running inside the application is Timers. We can change the display mode going to Mode and right clicking the one we want.

    If we are on Timer, we will be able to right click on the labels. This will enable a graph at the bottom left.

    If we wanted to just see some of the groups inside the profile display, go to Groups and select the ones you want.

    The other options are self explanatory.

    If the user wants to dump the profile to a file, we just need to go to dump, and right click on the amount of frames we want. This generates a html file in the executable folder. Open it with your prefered web browser to have a look.

    Dumping is useful, because we will be able to see the profile frame by frame, without it being updated every frame. This will be useful when displaying in Detailed mode.

    There is also a Help menu item.

    • Log system improvements:
      • Support for multiple log files
      • Easy to use log macros
      • Scoped logging
      • Multithreaded support
      • New log format: date, time, thread, file, line, log level and message
      • No need to declare global LogManager, it will be created on demand
    • Filesystem improvements: this is fed back from one of our game engine integrations of The Forge
      • file time functions now use time_t
      • added FileWatcher class for Windows/Linux/macOS
      • added CombinePaths function
    • macOS / iOS Metal:
      • added Barriers with memoryBarrierWithScope for Buffers,Textures and Render targets
      • added GPU sync with MTLFence as fallback (for cross encoder synchranization and BlitEncoder where memoryBarrier isn't available). Removed force fence on render targets change because it is no longer necessary. There might be a small performance improvements coming from this
      • support of Microprofiler see above
      • refactor of windows support code: replaced MTKView for iOS and macOS with a custom NSview and NSWindow implementation. We have more explicit control now over the window.
    • Issues fixed:
      • #112 - cmdBindDescriptors performance issue (DX12)
      • #110 - RenderDoc compatibility with SM6+
    Source code(tar.gz)
    Source code(zip)
  • v1.27(Jun 11, 2019)

    • DirectX
      • Improved our support for DXGI_FORMAT_BC6H_SF16, DXGI_FORMAT_BC7_UNORM
      • DirectX12 removed CPU wait on GPU only fences.
    • Windows - header include cleanup, resolved conflict with CALLTYPE enum in objidl.h
    • macOS / iOS - utilize packed_* data types more in shaders
    • Replaced some usages of GPURingBuffer with API Buffers, for reduced dependencies
    • Unit tests fixes
      • Fixed sky frag shaders in all unit tests
      • Fixed unit test debug vk crash from validation layer with AMD gpu (Vulkan SDK 1.1.101)
    • UI fixes + improvements
      • Added an example of how to use the texture previewer widget in the ui unit test (13_UserInterface)
      • App can now control the UI descriptor binder update freq
    • Improved ThreadedTask system and added helper texture loading code that uses the new async loading system in 06_MaterialPlayground and Visibility Buffer
    • Fixed issue #100 "About FBX resource import?"
    Source code(tar.gz)
    Source code(zip)
  • v1.26(Apr 4, 2019)

    • Ray Tracing with the Vulkan API (Vulkan SDK 1.1.101.0) is now working on Windows and Ubuntu through our unified Ray Tracing interface in IRay.h:

    PC Ubuntu Vulkan RTX, GeForce RTX 2070, Driver Version 418.56 1080p Ray Tracing on PC Ubuntu with Vulkan RTX

    PC Windows 10 RS5, DirectX12, GeForce RTX 2070, Driver version 418.81 1080p: Ray Tracing on PC With DXR

    Mac Mini with Intel Core i5 3GHz cpu with integrated graphics Intel UHD Graphics 630 (Part No. MRTT2RU/A) with resolution 3440x1440: Ray Tracing on macOS

    iPad 6th Generation iOS 12.1.3 (16D39) with a resolution of 2048x1536 Ray Tracing on iOS

    • New Descriptor Memory Management System: we did a second pass over that system and improved performance and memory consumption further. Now we can group individual descriptor bindors into a single one. A lot of bug and memory leak fixes were done as well.
    • Async / Sync Resource Loading system: instead of allocating additional memory, it uses now fixed size memory and splits resources for upload
    • Unified UniformRingBuffer and MeshRingBuffer into GPURingBuffer
    • Vulkan: we implemented now something close to the official recommendation how to convert "Vsync on/off" to Vulkan parameters (in pseudocode) (thanks to Adam Sawicki @Reg__):
    if mEnableVsync:
        Try to find among available present modes, in this order: FIFO_RELAXED, FIFO
    else:
        Try to find among available present modes, in this order: IMMEDIATE, MAILBOX, FIFO (we prefer here FIFO_RELAXED instead)
    
    if chosen mode == IMMEDIATE:
        imageCount = (Fullscreen ? 2 : 3)
    else if chosen mode == MAILBOX:
        imageCount = 3
    else if chosen mode == FIFO or FIFO_RELAXED:
        imageCount = 2
    imageCount = max(VkSurfaceCapabilitiesKHR::minImageCount, min(imageCount, VkSurfaceCapabilitiesKHR::maxImageCount))
    
    Source code(tar.gz)
    Source code(zip)
  • v1.25(Mar 17, 2019)

    • The purpose of the DescriptorBinder approach is to allocate all memory descriptor space at load time, instead of doing it on-demand at runtime, as it is commonly done. This is done in an effort to allow applications to have better control over memory footprint overhead, which is especially important on mobile targets, and to improve performance by avoiding runtime memory allocations. The system will use shader reflection to determine the appropriate descriptor layouts in combination with descriptor update frequency knowledge. This knowledge will come from the client domain or from content editor tools. With this information, we are able to allocate all necessary descriptor memory up-front, giving more control to the application about the memory footprint. This is one of the initiatives leading up to the new version of The Forge. Read more Descriptor Management

    • The input system was refactored and streamlined. This is mostly a rewrite of the code layer above gainput.

      • IOperatingSystem.h: getMousePosition, getKeyDown, getKeyUp, getJoystickButtonDown, getJoystickButtonUp were removed
      • InputSystem.h:
        • KeyMappingDescription - changed now every axis should be defined as separate entry
        • IsButtonPressed, IsButtonTriggered, IsButtonReleased, MapKey, SetActiveInputMap, GetButtonData, GetDisplayWidth, GetDisplayHeight, were removed
        • New functions GetBoolInput, GetFloatInput. KeyMappingDescription for new function require directly specifying intended action(released, pressed, triggered) via DEFINE_DEVICE_ACTION macro
        • For InputEventHandler old style definition is used
    Source code(tar.gz)
    Source code(zip)
  • v1.24(Mar 17, 2019)

    The Forge now allows to asynchronously load resources on all platforms. There are two ways to do this:

    • use addResource/updateResource with boolean parameter called batch set to true, and later wait for completion with waitBatchCompleted (used in 01_Transformations, 03_MultiThread, 06_MaterialPlayground, 09_LightShadowPlayground, 09a_HybridRaytracing, 12_RendererRumtimeSwitch, 15_Transparency)
    • use addResource with SyncToken parameter and check for completion with isTokenCompleted or wait for completion with waitTokenCompleted (used in 10_PixelProjectedReflections) addResource/updateResource with boolean parameter set to false are the old blocking versions. Let us know what you think of this system.
    • We integrated zeux's Micro Profiler into The Forge. So far it supports DirectX 11, 12 and Vulkan. We are still working on Metal and Android support.

    Chrome Micro Profiler in Chrome

    Visibility Buffer on PC Windows 10 Micro Profiler in Visibility Buffer

    Linux Ubuntu Micro Profiler Linux Ubuntu

    • Better integration of Ray Tracing into the renderer; still Vulkan RTX is work in progress
    • Fixed Vulkan instance extension bug: "InstanceLayers loop is wrong in CreateInstance" issue #92
    Source code(tar.gz)
    Source code(zip)
  • v1.23(Mar 17, 2019)

    Happy Valentines! Here is some love from The Forge team:

    • new cross-platform Ray Tracing interface in IRay.h, currently supporting DXR (Vulkan comes next) and Metal Ray Tracing on Windows, macOS and iOS. In other words you can now write Ray Tracing code that runs on Windows, macOS and iOS. You will need a RTX GPU to run this on Windows. On macOS / iOS only latest software update is needed.

    PC Windows 10 RS5, DirectX12, GeForce RTX 2070, Driver version 418.81 with resolution 3440x1440: Ray Tracing on PC With DXR

    Mac Mini with Intel Core i5 3GHz cpu with integrated graphics Intel UHD Graphics 630 (Part No. MRTT2RU/A) with resolution 3440x1440: Ray Tracing on macOS

    iPad 6th Generation iOS 12.1.3 (16D39) with a resolution of 2048x1536 Ray Tracing on iOS

    • Rewrote the Light & Shadow Playground from scratch, thanks to Mateusz Kielan:

    iMac with AMD RADEON 580 (Part No. MNED2xxA) with resolution of 5120x2880: Light & Shadow Playground

    iPhone 7 iOS 12.1.4 (16D57) with a resolution of 1334x750: Light & Shadow Playground

    Linux Ubuntu 18.04.1 LTS Vulkan 1.1.92 RADEON 480 Driver 18.30 with a resolution of 1920x1080: Light & Shadow Playground

    • macOS / iOS:

      • upgraded to
        • macOS Mojave 10.14.4 beta (18E174f)
        • iOS 12.2 beta (16E5181f)
        • Xcode 10.2 beta (10P82s)
      • a few months ago, we submitted a bug report for wave intrinsics to Apple and with the latest firmware beta (see above), wave intrinsics are working now in unit test 15
      • support PVR texture compression (V3 header) on iOS
    • Improvements for all Platforms:

      • 3D Texture mip maps for write
      • Unified texture subresource updates across all APIs
      • Memory optimizations: much less memory is used across all platforms
    • All the unit tests are now in one folder unit test and they are in one solution file

    Source code(tar.gz)
    Source code(zip)
  • v1.22(Jan 23, 2019)

    This is the first release in 2019 and The Forge GitHub repository is today exactly one year old, with the first release on the same day last year :-) In 2018 we made 22 releases and we improved The Forge in many areas. If you followed us so far ... why not just join us? We are looking for more graphics programmer joining our teams. We have offices in Encinitas, CA USA (Main) / Mumbai, India / Shanghai, China / Breda, Netherlands / St. Petersburg, Russia and in Lviv, Ukraine.

    Now back to release notes: many years ago in 2012 / 2013, we helped AMD and Crystal Dynamics with the development of TressFX for Tomb Raider. We also wrote an article about the implementation in GPU Pro 5 and gave a few joint presentations on conferences like FMX. At the end of last year we revisited TressFX. We took the current code in the GitHub repository, changed it a bit and ported it to The Forge. It now runs on PC with DirectX 12 / Vulkan, macOS and iOS with Metal 2 and on the XBOX One. We also created a few new hair assets so that we can showcase it. Here are screenshots of our programmers art:

    PC Windows DirectX 12 GTX 950 Driver 416.81:

    Hair on PC

    iPad (Model A1803):

    Hair on iOS

    The current implementation is overall too slow to be used on some of our platforms but we are going to improve performance over time. We are also going to improve on the hair art assets. Apart from Hair, the Material Playground now also has improved versions of Metal and a new material category Wood:

    Metal:

    Material Playground Metal on PC

    Wood:

    Material Playground Wood on PC

    • Entity component system (ECS) for all platforms: we've chosen to integrate ENTT (https://github.com/skypjack/entt) into The Forge. The initial implementation was contributed by Amer Koleci @AmerKoleci:

    Image of the Entity Component System unit test in The Forge

    • Lua Scripting System for all platforms: the Lua scripting integration allows to register functions to lua contexts so these functions will be available via scripts. Functions can be static or lambda. In latter case you can store some state information within lambda. Scripts are executed using LuaManager::RunScript() or LuaManager::AddAsyncScript() methods. In second case scripts are still executed in synchronous way. Async execution implementation is planned. Also there is "updateable" script. It is loaded (at this point script main body is executed), then it can be "updated" - update() function from script is invoked. Script can invoke any registered function and can store state information which will be available from update to update. The script can be reloaded - can be useful for fast iterations when you just modify script and don't even need to restart application. If that script contains exit() function then it will be executed when script is reloaded or closed. Checkout unit test 06_MaterialPlayground for an example on how to use it. In this unit tests it executes three scripts to load models and textures and animate the camera.
    Source code(tar.gz)
    Source code(zip)
  • v1.21(Jan 23, 2019)

    The team will soon go into winter hybernation mode ... which means many Confetti people will fly home over the holiday season to spend time with their loved ones. We will be back with more releases next year, probably in February.

    To send you season greetings, we extended our Ozz implementation by adding a new Skinning unit test:

    PC Windows 10 DirectX 12 GeForce 950 Driver 411.63 with a resolution of 1080p PC Windows 10 skinning unit test

    Linux Ubuntu 18.04.1 LTS Vulkan 1.1.92 RADEON 480 Driver 18.30 with a resolution of 1920x1080 Ubuntu skinning unit test

    iMac with AMD RADEON 580 (Part No. MNED2xx/A) with resolution of 1920x1080 macOS skinning unit test

    iPhone 7 iOS 12.0.1 (16A404) with a resolution of 1334x750 iOS skinning unit test

    XBOX One XBOX One skinning unit test

    • Vulkan:
      • all three Vulkan platforms (Windows, Linux, Android) use now the same Vulkan shaders
      • Upgraded Linux and Windows SDK to 1.1.92.1
    • The math library now supports more integer data types
    • Updated assimp to use latest master + added projects instead of shipping binaries
    • macOS / iOS
      • Added support for iOS Gestures (Not currently in use in the unit-tests)
      • Improved pixel projected reflections on Metal Platforms
      • Upgraded all the XCode projects to target Xcode 10.1 (10B61) and iOS Version 12.0.1 (16A404)
      • Started Testing additionally on A12 Devices Phone Xs Max (Model MT5D2LL/A)
    • Numerous shader translator updates. Head over to Confetti Shader Translator check them out :-) It is getting more and more stable.
    Source code(tar.gz)
    Source code(zip)
Owner
The Forge / Confetti
The Forge Interactive / Confetti Interactive
The Forge / Confetti
GPU ray tracing framework using NVIDIA OptiX 7

GPU ray tracing framework using NVIDIA OptiX 7

Shunji Kiuchi 22 Jun 11, 2022
A Cross-Platform(Web, Android, iOS) app to Generate Faces of People (These people don't actually exist) made using Flutter.

?? ?? Flutter Random Face Generator A flutter app to generate random faces. The Generated faces do not actually exist in real life (in other words you

Aditya 69 Aug 9, 2022
Mixed reality VR laser tag using Oculus Quest 2 and OAK-D depth cameras. First prize winner for North America region in OpenCV AI Competition 2021.

Mixed Reality Laser Tag Copyright 2021 Bart Trzynadlowski Overview This is the source code to my Mixed Reality Laser Tag project, which won first priz

null 34 Jun 3, 2022
App update framework for Windows, inspired by Sparkle for macOS

About WinSparkle is a plug-and-forget software update library for Windows applications. It is heavily inspired by the Sparkle framework for OS X writt

Václav Slavík 1.1k Aug 2, 2022
RealSR-NCNN-Android is a simple Android application that based on Realsr-NCNN & Real-ESRGAN.

RealSR-NCNN-Android Real-ESRGAN is a Practical Algorithms for General Image Restoration. RealSR-NCNN-Android is a simple Android application that base

null 151 Aug 8, 2022
An open source iOS framework for GPU-based image and video processing

GPUImage Brad Larson http://www.sunsetlakesoftware.com @bradlarson [email protected] Overview The GPUImage framework is a BSD-licensed iO

Brad Larson 20k Aug 11, 2022
Radeon Rays is ray intersection acceleration library for hardware and software multiplatforms using CPU and GPU

RadeonRays 4.1 Summary RadeonRays is a ray intersection acceleration library. AMD developed RadeonRays to help developers make the most of GPU and to

GPUOpen Libraries & SDKs 965 Aug 8, 2022
A CM4 gaming handheld, designed with the Switch Lite aesthetics in mind

A CM4 gaming handheld, designed with the Switch Lite aesthetics in mind. Contains all STL files and code to build your own landscape retro handheld system. Co-project with Dmcke5.

StonedEdge 96 Aug 9, 2022
A lightweight 2D Pose model can be deployed on Linux/Window/Android, supports CPU/GPU inference acceleration, and can be detected in real time on ordinary mobile phones.

A lightweight 2D Pose model can be deployed on Linux/Window/Android, supports CPU/GPU inference acceleration, and can be detected in real time on ordinary mobile phones.

JinquanPan 49 Aug 1, 2022
MediaPipe offers cross-platform, customizable ML solutions for live and streaming media.

Cross-platform, customizable ML solutions for live and streaming media.

Google 18.3k Aug 7, 2022
ONNX Runtime: cross-platform, high performance ML inferencing and training accelerator

ONNX Runtime is a cross-platform inference and training machine-learning accelerator compatible with deep learning frameworks, PyTorch and TensorFlow/Keras, as well as classical machine learning libraries such as scikit-learn, and more.

Microsoft 7.3k Aug 6, 2022
A Cross platform implement of Wenet ASR. It's based on ONNXRuntime and Wenet. We provide a set of easier APIs to call wenet models.

RapidASR: a new member of RapidAI family. Our visio is to offer an out-of-box engineering implementation for ASR. A cpp implementation of recognize-on

RapidAI-NG 80 Aug 11, 2022
RapidOCR - A cross platform OCR Library based on PaddleOCR & OnnxRuntime

RapidOCR (捷智OCR) 简体中文 | English 目录 RapidOCR (捷智OCR) 简介 近期更新 ?? 2021-12-18 update 2021-11-28 update 2021-11-13 update 2021-10-27 update 2021-09-13 upda

RapidAI-NG 522 Aug 5, 2022
ClanLib is a cross platform C++ toolkit library.

ClanLib ClanLib is a cross platform toolkit library with a primary focus on game creation. The library is Open Source and free for commercial use, und

Kenneth Gangstø 303 Aug 5, 2022
Insight Toolkit (ITK) is an open-source, cross-platform toolkit for N-dimensional scientific image processing, segmentation, and registration

ITK: The Insight Toolkit C++ Python Linux macOS Windows Linux (Code coverage) Links Homepage Download Discussion Software Guide Help Examples Issue tr

Insight Software Consortium 1.1k Aug 8, 2022
Gesture Recognition Toolkit (GRT) is a cross-platform, open-source, C++ machine learning library designed for real-time gesture recognition.

Gesture Recognition Toolkit (GRT) The Gesture Recognition Toolkit (GRT) is a cross-platform, open-source, C++ machine learning library designed for re

Nicholas Gillian 780 Aug 5, 2022
ADOP: Approximate Differentiable One-Pixel Point Rendering

ADOP: Approximate Differentiable One-Pixel Point Rendering

Darius Rückert 1.8k Aug 6, 2022
OptimizedMetaBall - 🔮GPU-based real-time raytracing rendering of transparent metaball

Optimized Raytracing MetaBall: Acceleration and Transparent ?? GPU-based real-time raytracing rendering of transparent metaball. (Project for CS337 Co

Hangyu Ye 3 Mar 9, 2022
Fast Volume Rendering with Spatiotemporal Reservoir Resampling (Volumetric ReSTIR)

Fast Volume Rendering with Spatiotemporal Reservoir Resampling (Volumetric ReSTIR) Introduction This repo includes the source code for the SIGGRAPH As

Lin Daqi 117 Aug 6, 2022