The Machinery Goes Open Beta

Hey Friends,

We had a very productive Closed Beta period and we can now safely move into The Machinery Open Beta Launch!

Starting today, The Machinery is open for everybody to check out and play with from our download page. When you first run it, you will need to log in with an Our Machinery account, which you can sign up for here.

What does this mean if you are already a Closed Beta developer? You can continue to work with The Machinery as before, but to run the October release, you need to set up an Our Machinery account here. Note that the Our Machinery account is separate from your Forum account.

The sign-up form has an optional questionnaire and it would be so helpful to us if you could participate in answering.

Thank you to the 2,000+ developers that helped get the closed beta open. We appreciate your hard work! Our hope is to drive more developers into the Open Beta to help make The Machinery the best possible solution for creating 3D experiences. We will announce our licensing model in a few months. In the meantime, we look forward to seeing your creations, hearing your concerns, and conversing with you about The Machinery.

If you run into any problems or have requests for specific features, post them to our issue tracker. For more general discussions and help getting started, we have a forum. You can also chat with us on our Discord server. You will find us there every now and then, but we’ll pay special attention on Thursdays.

Now onto The Machinery and what’s new in this Release.

Once More With Feeling: What is The Machinery?

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

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

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

Some of the features currently available in The Machinery are:

• Asset import. Import of GLTF, FBX, and many other 3D formats through Open Asset Importer.
• Creation graphs. Create materials, visual effects, textures, buffers, and more — all within the same graph.
• Rendering. A data-driven and powerful rendering architecture running on top of Vulkan.
• Physics. Physics simulation through Nvidia PhysX.
• Animation. Hierarchical state machines for layered animations.
• Audio. Software-based 3D audio mixer with surround sound support.
• Entity system. Data-oriented entity system that can be extended with custom components and simulations.
• Visual scripting. As a complement to C programming.
• Immediate mode UI toolkit. Can be used to extend the editor with custom tools or build stand-alone apps.
• Collaborative editing. Team up with fellow creators and join them in collaborative editing sessions, working on the same project in real-time.
• Profiling and statistics. Dig into the performance of your project.

October 2020 Release Notes (2020.10)

For those of you that are already in our closed beta, the main changes since the September release are:

• Post Processing Stack — apply post-processing effects.
• New Job Sleeping Mechanism — better multicore performance.
• New Truth ID Type — better type safety.
• Creation Graph Sample — shows how to utilize the power of Creation Graphs.

And as usual, we have a number of smaller updates.

Post-Processing Stack

This version includes the first version of our post-processing stack with support for:

• Exposure control (manual or automatic).
• Bloom effect.
• Local overrides of post-processor settings, using the new Volume component.

New Job Sleeping Mechanism

The job sleeping mechanism has been improved with a new algorithm that reduces contention when a machine has many logical cores. The job system will now make use of all available logical cores, instead of being capped at 8.

New Truth ID Type

We’ve introduced a new type for IDs in The Truth. Instead of using uint64_t, we know use tm_tt_id_t which is just an uint64_t wrapped in a struct.

We did this change for two reasons:

• To provide better documentation of what parameters our API functions except.
• To provide type safety against passing some other uint64_t object to a function that expects a Truth ID.

Note that if you have written a plugin that deals with Truth objects, you will have to make some changes so that it uses tm_tt_id_t instead of uint64_t.

We plan to introduce similar “wrapped types” in some other parts of the engine too, to make it easier to work with and get more error checking from the compiler.

Creation Graph Sample

Our sample projects now include a Creation Graph Sample. This sample shows off some of the things you can do with creation graphs, such as particle systems, sky rendering, billboards, and sprite sheets.

Editor

• Fix for a crash when importing multiple items.
• Fixed an issue with “Propagate to Prototype” moving objects in the scene when applied.
• Added license system: To run the engine, you now need an ourmachinery.com account.
• The Window > Zoom > Zoom Out menu option now works.
• The main menu and all context menus now support arrow key navigation.
• Fix for a crash when deleting the Scene Component.
• Fix for an editor freeze if the user tries to quit the editor while a modal dialog is being displayed. The editor will now focus the window with the modal dialog instead of quitting.
• The window border is no longer displayed when the editor is maximized.
• The Scene Tab now has buttons for going back and forth in the tab history.
• Fixed a bug where dragging-and-dropping assets from the OS into the Asset Browser did not work correctly with Windows DPI scaling.
• The contrast of the Dark and Light themes have been improved.
• Double-clicking an entity in the Entity Tree View now frames it in the Scene view.
• The load time for projects has been improved.

Graph

• Graph connections can now be aborted with the Escape key.
• Creation Graph nodes that run on the GPU now have a “GPU” watermark in the upper left corner to distinguish them from CPU nodes.

Rendering

• We now display GPU Timings per Render Graph Module.
• Fix for occasional crash when capturing cubemaps.
• The Render Graph now correctly handles NULL resources.
• TAA now works correctly for pixels outputted using the unlit shader node.
• Image creation graphs can now be drag-and-dropped directly into the Scene Tab.

Sound

• Fix for crash when running without a sound card.

Code and Build System

• premake now expands the TM_LIB_DIR environment variable when generating project files. This makes it possible to build from Visual Studio without having TM_LIB_DIR set.
• A the_machinery_shared plugin has been introduced for code and interfaces shared between The Machinery, the Runner application, and various plugins. It includes the viewer interface, for drawing viewports into the UI, rendering component interface, camera management, and frustum culling.
• Support for generic, type-safe hashes has been added in hash.inl. We are in the progress of switching all our hashes over to using this implementation and deprecating chash.inl.
• Hash tables are now approximately 10x times faster and use 1/10th of the memory.
• The temporary allocators (temp_allocator.h )now support the end-of-page debugging mode to detect bad memory writes.
• slab.inl adds a new “Slab” data type to our collection classes. This is a good default option for bulk data storage.
• tm_logger_api->printf() no longer has a text length limit.

2020.10.a hotfixes

• Fix for null event names on GPUSim nodes.
• Fix missing line break after PhysX error messages.
• Fix for crash when importing multiple assets simultaneously.
• Support for letting plugins enable Vulkan instance and device extensions.
• Fix for assimp meshes with vertex colors not being imported correctly.
• Added help menu.