For those who don’t know the tool: Material Maker builds procedural textures and painted looks with node graphs, runs on Godot Engine, and exports materials for engines while you keep your DCC doing DCC things.

1.6 focuses on speed, sanity, and shipping

Material Maker 1.6 lands as a practical release: faster interaction on heavy graphs, new nodes aimed at controlled variation workflows, and a longer list of fixes that smooth daily use. The update keeps the core loop intact. You build textures and materials in a node graph, preview the result, and push assets downstream.

The release moves the app to Godot Engine 4.5.1. That base change pairs with performance work across graph rendering and several parameter editors. Graph rendering now optimizes zoomed-out views, and editor changes target responsiveness in places artists touch all day.

Controlled Variations aims for repeatable variety

1.6 introduces Controlled Variations and related nodes. The release frames this as a system for generating variants of a material look with more control than pure randomness.

Variant workflows matter when you need a family of surfaces that stay consistent across a set, a biome, or a prop library. In day-to-day terms, controlled variation can reduce duplicated graphs and the temptation to fork a graph into ten nearly identical versions you never want to touch again.

Aperture nodes cut the spaghetti

1.6 adds Aperture nodes to keep graphs readable. In and Out nodes connect through a shared identifier that appears as a label on the node. You edit the identifier by double-clicking the label or using keyboard shortcuts, and you can change label color with a key command while the node stays selected.

That feature targets the real enemy of node workflows: scaling up. A small graph stays understandable through wires. A production graph turns into a plate of noodles. Aperture nodes let you route signals cleanly without dragging cables across half the canvas.

Portal nodes and a growing node toolbox

1.6 adds portal nodes, plus a variadic Color Pick node. It also updates multiple existing nodes and editors. The changelog mentions changes around text handling, warp inputs, pixel tools, gradient options, and improved curve and polygon parameter editors. Comment nodes and remote links also receive attention, alongside drag-and-drop improvements for remote and iOS parameters.

glTF export takes a first step

1.6 adds a basic exporter for static PBR materials in the glTF format. The feature targets straightforward export rather than full dynamic graph translation. That still helps in real pipelines, where “get me the baked result in a common format” solves more problems than a perfect one-click pipeline dream. Several export-related fixes also land, including fixes tied to Godot 4 export behavior, missing ORM textures, and improvements to the Dynamic PBR preview and Godot 4 export paths.

Availability, licensing, and Steam plans

Material Maker distributes builds for Windows, macOS, and Linux via itch.io with name-your-own-price, including free. Source code lives on GitHub under the MIT License.

A Steam listing shows a planned release date of July 2026 and lists system requirements. Windows requires Windows 10, an x86_64 CPU with SSE4.2, and graphics support for Vulkan 1.2 or DirectX 12. macOS lists macOS 10.13 with Metal support. Linux lists Vulkan 1.2 support.

https://rodzilla.itch.io/material-maker/devlog/1491329/material-maker-16

https://github.com/RodZill4/material-maker

https://www.materialmaker.org/

https://store.steampowered.com/app/4110830/Material_Maker/

The post Material Maker 1.6 tunes graphs and exports first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Universal Animation Library is a generic humanoid animation set from Quaternius, built for quick drop-in use across common engines including Unity, Unreal Engine, and Godot, with source files authored in Blender. It sits squarely between placeholder motion and final gameplay animation, where schedules go to die.

What was released

Artist and asset publisher Quaternius has released Universal Animation Library 2, an expanded humanoid animation pack containing over 130 animation clips. The library is designed around a single universal humanoid rig intended to be compatible with a wide range of characters.

The animations cover a broad set of actions. These include locomotion, melee combat, weapon handling, parkour-style movement, civilian activities such as farming, drinking and fishing, and exaggerated zombie-like motion. The intention, as stated, is breadth rather than stylistic specificity. The pack is positioned as a general-purpose animation resource for game developers and realtime projects. No claims are made regarding cinematic realism, motion capture fidelity, or biomechanical accuracy. This restraint is refreshing and possibly accidental.

Universal Animation Library 2 is out! Godot compatible with 40+ free animations
byu/QuaterniusDev ingodot

What is actually included

Two versions of the library are offered. The standard version is free and includes approximately 70 percent of the total animation set. The source version includes the full library along with the original Blender .blend file, including the rig and animation data. This distinction is important for teams that need to retarget, modify, or debug animation data rather than treat it as a black box.

Engine compatibility claims

Exported versions of the animations have reportedly been tested in Unity, Unreal Engine, and Godot. No guarantees are made about drop-in compatibility with engine-specific humanoid systems such as Unity Mecanim or Unreal’s default mannequin. Any such assumptions would be optimistic bordering on reckless.

Blender source files

The inclusion of Blender source files in the paid source version is one of the more practically useful aspects of the release. Access to the original rig allows studios to inspect constraints, animation layers, naming conventions, and coordinate systems before committing the data to a pipeline.

Free, but not careless

The animations are stated to be free to use in commercial projects (CC0). This continues Quaternius’s long-running approach of distributing no-cost assets with permissive licensing, which has made the site a frequent stop for prototypes, game jams, and suspiciously polished student projects.

That said, free does not mean finished. These animations are clearly intended as a starting point or mid-production solution rather than final hero animation. Weighting, timing, and contact precision will almost certainly need adjustment for production use. This is not a flaw. It is the entire point

Why this matters

For small teams and solo devleopers, a broad and legally safe animation library can remove weeks of work from early production. Universal Animation Library 2 appears aimed squarely at this phase, where function matters more than flair and nobody wants to animate fishing for the fifth time this year.

For larger studios, the value is lower but not zero. The source files may be useful for blocking, previs, prototyping, or testing gameplay systems before bespoke animation arrives. Or before the animation budget does.

Pricing and availability

The standard version of Universal Animation Library 2 is free. But as a Patreon you get extra Stuff – check out his page here.

As always, new tools and animation assets should be tested thoroughly before being introduced into any production pipeline.

The post 130 animations, one rig, zero drama first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Export Helper Pro is a Blender add-on sitting at the very end of asset creation, handling outbound exports to game engines like Unity, Unreal and Godot, with presets that reduce clicks and regret. It lives alongside Blender’s native exporters and does not replace them.

A familiar itch

A newly released free Blender add-on called Export Helper Pro aims to remove friction from one of the least glamorous but most repeated tasks in realtime asset production: exporting meshes out of Blender and into a game engine. The tool is authored by Michael Bridges and distributed via Gumroad as a free download. According to the author, the current version is rebuilt for Blender 5 and is open for public testing.

The add-on has attracted attention partly because of its origin story. Bridges references an abandoned internal Blender plug-in originally developed by Embark Studios, the studio behind Arc Raiders. That internal tool has not been updated for over six years. After examining its code, Bridges revisited their own earlier export tool and rebuilt it with a broader scope.

This context matters mainly as motivation. Export Helper Pro is not a continuation of Embark’s tool, nor is it affiliated with the studio. It is a separate project, written independently, and positioned as a general-purpose utility rather than a studio-specific pipeline component.

What the add-on actually does

Export Helper Pro adds a dedicated Export tab to Blender’s right-hand N-panel in the 3D Viewport. From there, users can export assets using a small set of clearly scoped options without navigating Blender’s standard export dialogs each time.

The core function is batch-style exporting based on context. Users can export all objects in a scene, only selected objects, or one or more named collections. This is intended for modular asset workflows where collections represent discrete export units.

Supported export formats include FBX, glTF and OBJ. FBX is positioned for Unity and Unreal workflows, while glTF is intended for Godot. OBJ is included as a fallback for maximum compatibility, though the author notes it exposes fewer options than the other formats.

Export Helper Pro does not introduce a new file format or a custom exporter. It wraps Blender’s existing exporters and exposes commonly used settings in a single panel. As such, the quality and limitations of the output are those of Blender’s native export code.

Selection, collections and intent

One of the add-on’s central features is collection-based export. Instead of exporting an entire scene or manually selecting objects each time, users can designate a collection and export it directly. This allows assets to be structured semantically in Blender and exported accordingly.

In a demonstrated example, a helicopter asset consisting of 52 objects is exported as a single FBX file by selecting its parent collection. The resulting file contains all objects merged into a single export operation. This behaviour is consistent with Blender’s standard FBX exporter and does not automatically instance repeated meshes.

The author explicitly notes that this is not a substitute for proper instancing or asset optimisation. Export Helper Pro does not analyse meshes for duplication or attempt to restructure assets. It simply automates the act of exporting what the user has already organised.

Origin handling and viewport colour conversion

Among the exposed options is the ability to centre object origins before export. This can be useful when assets need consistent pivots for placement in an engine. The centring operation is applied at export time and does not permanently modify the Blender scene, based on the information provided.

Another option is conevrsion of viewport colours to exportable colour data. This is intended for workflows where meshes are coloured directly in the viewport rather than via materials. When enabled, these colours are baked into the export so they remain visible in the target engine.

Armatures, textures and embedded data

Export Helper Pro includes toggles to include armatures when exporting animated rigs. This aligns with standard FBX and glTF export options in Blender and does not introduce custom rig handling. The add-on also exposes options to embed textures directly into FBX or glTF files. Embedded textures can simplify handoff at the cost of larger file sizes and reduced flexibility. As with other options, this relies on Blender’s built-in exporters and inherits their constraints.

Installation and availability

The add-on is distributed via Gumroad here. It is currently free to download. Installation follows standard Blender practice. Users download the add-on archive, open Blender Preferences, choose to install from disk, and enable the add-on. Once installed, the Export tab appears in the 3D Viewport sidebar.

The author states that the tool has not been tested in every scenario and invites users to report bugs or suggest improvements. This positions the release clearly as an open testing phase rather than a finished commercial product.

Engines and expectations

The add-on explicitly targets Unity, Unreal and Godot. These targets are defined by export format rather than deep engine integration. There is no engine-side plugin, no automated import configuration, and no engine metadata generation. For Unreal and Unity, FBX is the intended format. For Godot, glTF is recommended. This reflects common practice rather than bespoke support.

What it is not

Export Helper Pro does not claim to be a pipeline manager, asset tracker, or versioning system. It does not replace Blender’s exporters, and it does not attempt to standardise asset naming or directory structures. It also does not attempt to solve instancing, LOD generation, collision mesh creation, or any of the other problems often bundled into export tools by marketing departments.

Its stated goal is narrower: reduce repetitive UI actions and make exports faster and more predictable.

Sensible expectations

For asset artists working solo or in small teams, Export Helper Pro offers a way to shave time off repetitive exports without introducing heavy infrastructure. For larger studios with established pipelines, it is unlikely to replace custom tooling. Its value lies in being small, direct and honest about its scope. It does one thing, and it does it in front of you, in a panel you can see.

As always, new tools and workflow changes should be tested carefully before being introduced into production environments.

// Export Helper Pro Gumroad page
// https://michaelbridges.gumroad.com/l/ExportHelperPro

The post One click exports and zero patience for menus from Blender to Unreal, Unity and more. first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

or those who don’t know the tool: Material Maker is an open-source procedural material authoring and 3D texture painting tool based on the Godot engine that lets artists create node-based PBR texture maps for engines like Godot, Unity and Unreal via visual graphs and export templates.

Material Maker 1.5: What’s New

Material Maker 1.5 has been released by developer Rod Zilla with upgrades focused on file format support, workflow improvements and additional nodes. The update introduces support for DDS image loading, a texture format widely used in game pipelines, and FBX mesh loading for previewing and working with 3D models directly inside the authoring environment.

A command-line interface (CLI) has been reinstated, allowing for scripted or batch export of materials without the GUI, which benefits automated pipelines and bulk processing. Workflow has been improved in the node graph editor with lasso selection and additional keyboard shortcuts, and there are updates to the Library and Reference panels, including a clipboard paste option for reference images. The release also adds 10 new nodes, including seven signed distance field (SDF) nodes, expanding procedural texturing capabilities.

Position in Production Toolchain

Material Maker remains positioned as a free alternative to subscription tools like Substance 3D Designer, targeting texture authors in games and VFX who prefer open-source, node-based workflows. It supports Windows, macOS and Linux and is licensed under MIT, allowing integration into both hobby and professional projects without licensing costs.

What It Means for Artists

Support for DDS and FBX aligns the tool with industry standards for game and real-time asset pipelines. The return of a CLI enables light automation and bulk tasks that were harder to do in earlier versions. New nodes broaden procedural control, though Material Maker remains primarily geared toward texture creation and export, not a full shader authoring suite. Users should evaluate the interface and output quality before integrating it into production workflows.

Official Material Maker devlog on itch.io
// https://rodzilla.itch.io/material-maker/devlog/1312764/material-maker-15

Material Maker official site description
// https://www.materialmaker.org/

The post Material Maker 1.5 adds DDS, FBX, CLI, 10 new nodes first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Godot users can now experience the drama of a boss fight while typing. Ridiculous Coding, a free editor extension by developer John Watson (aka jotson), adds real-time chaos to the script editor: screenshake, fireworks, progress XP bars, and visual effects every time you hit Enter.

The plugin’s only purpose is to make coding “less boring”. When you write code, it rewards progress with particle bursts and celebratory effects. Syntax errors might not yet trigger explosions, but judging from the developer’s sense of humour, it feels inevitable. Watson is also developing The Mailroom, a “cozy horror job simulator” built in Godot, where you process infernal paperwork in a small regional office of Hell, located in Modesto, California. Ridiculous Coding is available now in the Godot Asset Library. As with any experimental editor plugin, artists and developers should test stability before adding it to production pipelines.

Anyone curious how serious Godot development actually works might want to visit Helge Maus on Patreon. His in-depth courses and project breakdowns show Godot at work, without the fireworks.

The post Godot Now Shakes When You Code Badly first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The open-source engine Godot hits a new development milestone with its 4.6-dev5 snapshot. As the project moves toward feature freeze (scheduled for 3 December 2025), this build bundles a wide set of changes across rendering, export workflows, patching and editor usability.

Use D3D12 by default on Windows

For Windows users the default rendering backend now switches from Vulkan (or older defaults) to Direct3D 12 (D3D12). This reflects long-standing concerns about Vulkan stability on Windows, particularly around GPU driver reliability. The change only affects new projects created in 4.6-dev5 or later. For existing 4.5 projects you must manually set rendering/rendering_device/driver.windows = d3d12.

Delta-encoded PCK patching

Content patching sees a major enhancement. Previously, patch exports compared files at a per-file level — meaning even a single-character change in a large localisation file triggered a full export of that file.
Now, the engine supports delta encoding (binary diffing) when exporting patches. Only the modified bytes are stored, potentially turning megabyte-sized patches into lightweight, byte-level edits. This must be explicitly enabled in the Patching tab of the export dialog. Note: applying such patches comes with a small runtime cost (a few milliseconds worst case).

Native Android Gradle builds via companion app

Exporting to Android gets more robust. Previously, Godot allowed injecting game data into a pre-built APK — quick but limited. Now, thanks to a companion build app providing a Linux-like build environment on Android, Godot can run full Gradle builds on-device. This enables easier use of Android plugins (for example billing, XR, ads) and closer parity with native Android builds. The companion app is planned for release via Google Play and other stores before Godot 4.6 stable ships.

OpenXR 1.1 support and improved XR export

Godot now supports OpenXR 1.1. On devices with 1.1 support, the engine will automatically enable the newer API features. Loader logic for AOSP (Android Open Source Project) platforms has been moved from a vendor-specific plugin into Godot’s core. That means games targeting generic Android distributions can now export one APK that runs across many XR headsets without separate vendor plugins. The existing first-party OpenXR vendor plugin remains available for vendor-specific extensions and permission management.

2D renderer overhaul: major performance gains

The 2D renderer, especially for scenes benefiting from batching, gets substantial optimisations. Previous automatic 2D batching already reduced CPU usage by combining similar draw calls. In 4.6-dev5 the GPU cost of batching has been reworked. Tests show that on GPU-bound scenarios performance improved between 1.1× and 7× compared to prior versions.

Editor and engine usability upgrades

This snapshot also introduces many smaller but meaningful improvements across the editor, scripting, and core engine: rotating scene tiles in TileMapLayer, improved timeline resizing for animations, better GDScript debugging, extended GUI layout options, improved file attribute support under operating systems, and more.

What, if anything, to watch out for

As with any pre-release build, 4.6-dev5 is not a stable release. The official download page warns users to keep backups or use version control to avoid data loss or regressions. Depending on your project, some changes, like the switch to D3D12 or the use of delta-encoded patches, might require manual configuration or testing before relying on them.

This build is part of a broader push toward the stable 4.6 release. With feature freeze scheduled for 3 December 2025, this dev snapshot likely represents the last major feature add before the engine enters polish-only mode. Developers should test these changes thoroughly before upgrading production projects.

Try the Webversion in your Browser!

And read more about this Release here: https://godotengine.org/article/dev-snapshot-godot-4-6-dev-5/

The post Godot 4.6-dev5 lands: D3D12 default, Delta Patching, Android Gradle, 2D boosts first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Jules Neghnagh Chenavas has released GodotARKit, an open-source plug-in that enables real-time facial motion capture inside Godot 4. The plug-in streams facial tracking data from Apple’s ARKit via UDP and is designed to work directly with Apple’s Live Link Face mobile app.

The system uses ARKit’s full set of facial blendshapes (52 standard expressions plus head and eye rotations) and feeds them straight into Godot, eliminating the need for intermediate DCC software. The data is handled in-game, which makes the plug-in suitable for live performance capture, real-time animation previews, or in-engine cutscenes.

Godot meets ARKit: Facial mocap addon using phone camera!
byu/Miralupia_ ingodot

Live Link Face Integration

According to the README, users set up Live Link Face to send data to their local network’s IP and port, which GodotARKit then receives and visualises through an integrated editor panel. The interface displays connected devices, current blendshape values, packet frame info, and error messages in real time. The plug-in acts as an autoload singleton, meaning all blendshape data are accessible globally from scripts. The developer provides a working demo script in the repository that shows how to map blendshapes and head rotations to a character rig in a few lines of GDScript.

Under the Hood

The plug-in architecture includes a UDP server, packet decoder, and ARKitSubject class for device management. Each connected iOS device becomes a “subject” broadcasting ARKit blendshape frames. Users can monitor connection status and debug data within Godot’s bottom panel without leaving the editor. A weak reference and signal-based communication structure prevents memory leaks and redundant object references, a common issue in real-time networked systems. The developer explicitly mentions using this method to avoid referencing the ARKitSingleton directly.

Example Implementation

The example provided shows how to animate a MeshInstance3D by looping through blendshapes in the incoming data packet. Head and eye rotations are handled separately, with blendshape values converted into rotation quaternions for neck and eye bones. The demo also includes a note that both eyes currently share identical rotation behaviour—a known limitation marked for future refinement.

Licensing and Contributions

GodotARKit is distributed under the MIT license, meaning both commercial and non-commercial use are permitted. The developer encourages community contributions and openly admits limited testing with multiple devices and UI elements. As of the latest commit (last week), the plug-in is at version 1.0 and has updated documentation and icons. The repository shows regular activity and version control discipline, indicating ongoing maintenance.

Compatibility

The plug-in targets Godot 4 and uses standard UDP communication, so it does not require proprietary middleware or additional network libraries. Compatibility with ARKit implies it will function with any iPhone or iPad supporting Apple’s facial tracking API, though the author does not specify minimum device requirements.

Summary

For Godot developers seeking a real-time facial capture solution without switching to Unreal or Unity, GodotARKit provides a minimal and open-source option. It leverages existing ARKit infrastructure and Apple’s Live Link Face app to feed high-fidelity facial data into Godot with minimal setup. As with any new open-source tool, users should test stability and latency performance before deploying it in production environments.

The post Godot ARKit: Facial Mocap Without the Detour first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The World Creator (by BiteTheBytes) has issued version 2025.3 of its real-time GPU-based terrain-generation tool. The release adds significant pipeline and export enhancements.

ORBX export enables OctaneRender workflows

Version 2025.3 introduces support for exporting terrain in ORBX format — the scene format used by OctaneRender. This makes it possible to take terrains created in World Creator directly into any DCC (digital-content creation) application that has an OctaneRender plugin, such as Blender, Maya, Cinema 4D, 3ds Max or Nuke. This provides a more streamlined route for pushing terrain through professional rendering pipelines.

Godot bridge plugin extends engine support

The update adds an official bridge plugin for Godot (open-source game engine), allowing direct export of terrain to Godot. With this, Godot joins the list of engines and DCCs supported by World Creator, alongside Blender, Cinema 4D, Houdini, Unity and Unreal Engine.

Paint-holes and cave/tunnel masks for terrain design

A new “paint holes” feature enables artists to carve holes directly into terrain for caves, tunnels or dungeons. The position of those holes can be exported as a mask for use in game engines or DCC apps, giving more control over subterranean or cut-away geometry. In addition, World Creator 2025.3 allows exporting relief maps for terrain. Relief maps emphasise elevation variation and can be used for topographic visualisations or stylised designs.

What this means for studios and creators

For studios and artists working in game development, VFX, environment art or realtime rendering, the ORBX export plus Godot integration expands pipeline flexibility. You can now build terrain in World Creator and send it directly into OctaneRender or Godot, without manual format conversions. Cave and tunnel masking adds value for level design. That said, as always: test these new features thoroughly before integrating them in a production pipeline, especially for complex terrains or engine builds.

The post World Creator 2025.3 adds ORBX , Godot bridge and caves first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Lost Marble’s Moho 14.4 update, charmingly titled “Side Quest,” arrives as a free upgrade for all Moho 14 owners. It’s more than a maintenance patch, it’s an expansion that connects 2D animation workflows to 3D pipelines and game engines via native glTF/GLB export.

The new exporter allows animators to bring Moho rigs, skeletons, and animation directly into Unreal Engine, Unity, or Godot, as well as 3D applications such as Blender. For production artists juggling both dimensions, this means Moho’s bone-based 2D animation can now live inside fully interactive environments without tedious conversion work.

The glTF Portal

At the centre of the Side Quest update lies the new glTF/GLB exporter. It preserves key rigging data such as bones, mainline animation, Smart Bones, Dynamic Bones, and Actions and transforms them into reusable animation clips ready for playback inside real-time engines. Each Action created in Moho, such as walk, jump or idle, is saved into the glTF file as independent animation data, making it possible to drive game character behaviour through player input.

Smart Bones, Moho’s custom rigging controls that manipulate complex deformations, now translate into Morph Targets (also known as Shape Keys) on export. This mapping ensures expressive deformations, like mouth shapes or limb warps, survive the jump into 3D software. Lost Marble notes that while not all Moho features are supported by glTF, the exporter retains the most essential rigging and animation data for cross-environment use.

Smart Bones Go 360°

Beyond the export layer, Moho 14.4 introduces a new 360° Smart Bone type. If a bone rotation reaches exactly 360 degrees, Moho automatically identifies it as a full-rotation Smart Bone, enabling artists to control the appearance of artwork at any viewing angle. That means animators can now smoothly rotate limbs, faces, or even entire character poses around a full turn, which is ideal for complex movements such as spins or walk cycles that require full rotational control.

Particles Behaving Better

Particle simulation sees a notable upgrade. Particles can now follow curve-based source layers, creating organic arrangements such as hair strands, tentacles, or tails. A new playback offset lets artists stagger particle timing to produce natural wave-like motion. Distribution has been improved to eliminate uneven gaps, and Moho now allows particle interpolation at variable frame intervals (1s, 2s, 3s, or custom) supporting both traditional and stylised timing.

Workflow Polishing and Quality-of-Life Fixes

The Side Quest update doesn’t stop at headline features. Lost Marble has tweaked dozens of small but significant details that make day-to-day work smoother. Freehand strokes are now more stable and visually consistent, with an improved smoothing algorithm and consolidated undo steps for pen input. Layer caching has been refined, reducing redraw lag when editing complex scenes. Vector layers now cache even when influenced by bones, and timeline zoom levels persist between sessions. Layer selection, particle rendering on macOS, and PSD import behaviour have all been cleaned up. Undo behaviour, motion blur logic, and bone visibility in Vitruvian rigs have been refined, while Moho’s scripting API gains new Lua functions for developers. New device presets have also been added for TourBox and Xencelabs Quick Keys, expanding the software’s hardware compatibility out of the box.

Styling, Simplified

A small but welcome improvement: users can now create a new Style directly from an existing shape. Instead of defining styles before drawing, artists can select any shape and automatically group others sharing its visual properties like fill, line, width, and brush. This makes it trivial to recolour or globally adjust line attributes across entire characters, without manual layer-hunting.

A Long List of Fixes, and a Few Quiet Triumphs

The update also addresses long-standing quirks such as accidental timeline drags, over-sensitive pen inputs, and incorrect particle rendering on macOS. Multi-threaded rendering now supports higher resolutions, and Liquid Shapes gain an obscure but potentially life-saving correction script.

These aren’t glamorous additions, but for working animators, stability improvements often matter more than new toys and Lost Marble’s changelog reads like a response to real production feedback.

Pricing and Availability

Moho Pro 14 retails for USD $399.99, and Moho Debut 14 for USD $59.99. The Side Quest 14.4 update is free for all Moho 14 owners, available now through the Lost Marble website or via Moho’s in-app update check. As always, users should verify compatibility within their specific production pipelines before deploying it in live projects.

Lost Marble Official Announcement: Moho 14.4 Side Quest

The post Moho 14.4 Goes on a Side Quest: 2D Meets Game Engines first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

What’s Material Maker and why this matters

Material Maker is an open-source, node-based procedural texturing tool built on the Godot engine. It enables artists to create PBR texture graphs, paint directly onto 3D meshes, and export materials for engines such as Unity, Unreal, or Godot itself. The software has long served as a free alternative to commercial node-based texturing tools, offering a lightweight and extensible workflow.

Version 1.4 represents a substantial technical milestone. The entire tool has been ported from Godot 3 to Godot 4, involving a near-complete rewrite of shader generation, UI layout, and core rendering systems. Because this migration changes the internal architecture, older graphs and projects may not behave identically after conversion.

Godot 4 port and shader engine rewrite

The move to Godot 4 is the heart of this release. Developer RodZilla notes that he “seriously underestimated” the scale of the migration effort. The new engine required rewriting many components from scratch, including the shader generation logic. Unused functions are now pruned automatically, and generated code includes node references for improved debugging. The output is smaller, cleaner, and executes more efficiently inside Godot 4’s rendering pipeline.

The switch to the new rendering backend also made compute shaders more reliable. This stability, in turn, allowed the introduction of new parameter types such as Splines, Pixels, and Lattice, as well as distortion controls that were previously impossible or unstable on Godot 3.

32-bit precision textures

With version 1.4, Material Maker gains support for rendering textures at 32 bits per channel. This improves numerical precision in generated maps, reducing banding and quantisation artefacts. The improvement is particularly relevant for heightfields and normal maps, where small gradients often reveal rounding errors when limited to lower bit depths.

Artists can now choose 32-bit buffers in the rendering pipeline. This is the first time Material Maker achieves such precision, made possible entirely by the Godot 4 backend.

MeshMap node and smarter Smart Materials

The release also introduces the new MeshMap node, designed to bake and manage mesh-dependent textures directly within a material graph. It automatically generates per-mesh maps such as position, normal, tangent, curvature, occlusion, and thickness. When a user switches to a different mesh in the 3D preview, the node rebakes all associated maps automatically.

This capability strengthens the Smart Materials workflow, allowing procedural materials to react intelligently to the model’s geometry without leaving Material Maker.

RodZilla remarks that the painting tool has been partially re-implemented in this release, now using compute shaders to handle all channels in a single pass. He acknowledges, however, that this is an experimental solution and may evolve in future versions. The developer is considering a more layer-based UI for texturing workflows, where graphs could be abstracted into a simplified stack view.

UI overhaul and preview improvements

Material Maker’s user interface has been extensively redesigned. Panels can now be undocked, rearranged, and saved as custom layouts. Two default configurations are provided: one for material authoring and one for mesh painting. A new “Modern” theme has been added, and theme switching is now handled dynamically.

The 3D preview gains AgX tonemapping, along with controls for exposure and white balance. Shader errors are displayed in a dedicated console, and clicking an error message highlights the offending node directly in the graph. Additional refinements include a searchable “Add Node” popup and expanded Find/Replace functionality in the shader editor.

Overall, the UI changes make Material Maker less monolithic and more comfortable for artists accustomed to complex, multi-panel environments.

Expanded node library and parameters

Version 1.4 adds numerous new nodes and parameter types. Spline and Pixel parameters have been introduced, along with associated nodes for smooth pixel operations and curve-based modulation. The new Lattice parameter provides a grid-based deformation system for procedural distortions.

Signed Distance Function (SDF) workflows have been significantly expanded with new 2D and 3D SDF primitives and operations. The EasySDF editor now supports more shapes and axis parameters in Extrude and Revolution nodes. The Blend node gains additional blend modes for hue, saturation, colour, and value operations.

Material Maker now also supports Unity’s Universal Render Pipeline for static material export, improving compatibility for game developers.

These new options collectively make procedural authoring in Material Maker considerably more expressive. Artists can create more organic or structured materials without resorting to external maps or sculpted geometry.

Miscellaneous and platform updates

Material Maker 1.4 targets Godot 4.4.1 and includes optimisations across all supported systems. macOS packaging has been simplified for easier installation. The splash screen now features user-made materials or shaders from the community. A startup option allows deletion of unsaved “rescued” projects, reducing clutter for long-time users.

Under the hood, numerous fixes have been applied to library handling, export logic, environment editing, and popup placement. Shader exports for Unity, Unreal, and Godot have been refined, particularly in handling dynamic arrays and HLSL code generation.

Availability and stability

Material Maker 1.4 is available now for Windows, macOS, and Linux, distributed as open source under the MIT licence. The developer warns that despite months of testing, the Godot 4 port introduces major internal changes. Artists are encouraged to test thoroughly before deploying it in production.

RodZilla describes the painting workflow as experimental and continues to regard version 1.3 as the safest option for mission-critical work. Users should verify compatibility of existing graphs, node libraries, and shader exports before full migration.

Implications for production pipelines

For texture artists and look-dev specialists, the shift to 32-bit channel precision delivers measurable benefits in map quality. The MeshMap node shortens the path between procedural generation and mesh-aware baking, reducing dependency on third-party tools. The flexible UI layout accommodates multi-screen workflows common in larger studios.

At the same time, the deep architectural changes mean that conversion of existing node graphs may not be straightforward. Production users should test carefully before committing to version 1.4 in live pipelines. As always, no software, particularly one built on a new rendering core, should be adopted without validation in the specific studio environment.

The post Material Maker 1.4: Godot 4 port, flexible UI, 32-bit baking first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

If you are used to grabbing shader freebies for Unreal, here is something refreshingly different: MatMADNESS, a 3D artist, has released a shader pack for Godot Engine aimed squarely at realistic human rendering. It runs in Godot 4.5 and is expected to work in 4.4 as well. The package contains a skin shader, an eye shader, and a separate shader for eye wetness. To make life easier, it comes bundled with sample models and a simple viewer. Everything is released under MIT and CC BY 4.0 licences. That means you can experiment, adapt, or build on it without licensing headaches. Get more info on itch.io and download everythign from Github.

My Skin and Eye Shaders are Available for FREE on GitHub! DEMO on Itch.io
byu/MatMADNESSart ingodot

The developer does note that the project is a work in progress and not actively maintained. Updates may or may not happen, so treat this more as a starting point than a polished, long-term solution.

Why Human Shaders Are Rare in Free Packs

Human shaders are not the kind of thing you find in every community repository. Stylised outlines, terrain shaders, toon materials, or procedural noise are much more common. Realistic human rendering requires a mix of subsurface scattering, multiple specular layers, and detail maps for pores and imperfections. Eyes introduce another level of complexity, since you need convincing refraction in the cornea, depth in the iris, accurate shading of the sclera, and at least a hint of wetness.

Performance is another issue. These features are costly, and free assets are often designed to run on modest hardware. Realistic skin shaders can demand a lot from the GPU, which makes them less attractive for free-to-use packs. On top of that, human shaders are rarely “one size fits all.” A good skin shader often needs tuning per character, with different maps for colour, normal, roughness, or subdermal scattering. Add the burden of keeping complex shader code maintained across engine updates, and it becomes clear why few artists release them publicly. That makes this pack from MatMADNESS unusual and valuable.

When to Use It

These shaders can serve multiple practical purposes. In previsualisation or prototyping, they let you set up a believable human quickly, just to test how lighting and mood work. In indie or student projects, they offer a way to achieve realism without writing custom shader code from scratch. For training and education, they provide a reference on how to implement skin shading, subsurface effects, and layered transparency in Godot. Research and VR projects can also benefit, since avatars and human-computer interaction studies often demand realistic digital humans. Even if your final product does not aim for realism, shaders like this are useful in internal tools or look-development scenes where you want assets to look more convincing.

Loading and Handling Shaders in Godot

Integrating the shaders into Godot follows a straightforward workflow. After downloading the pack, place the files into your project folder. Each shader file can be loaded as a Shader resource. You then create a ShaderMaterial and assign the shader to it, before applying the material to a mesh. Godot will expose uniforms defined in the shader, which means you can set textures, colour controls, or numerical parameters directly in the editor. This is where you would plug in detail maps for the skin or adjust the strength of the wetness effect on the eyes.

Lighting plays a significant role. Godot’s renderer can be set to forward+ or clustered, and results may differ depending on the choice. High-dynamic-range lighting, shadow settings, and environment probes all influence how convincing the shader looks. On top of this, the shaders should be performance-tested on the platforms you intend to ship on, as complex effects can hit framerate hard. The pack’s included model viewer is useful for testing, but before integrating into a production character pipeline, it is strongly recommended to iterate under the same lighting and hardware constraints you plan to target.

The State of Play

The shader pack is confirmed to run in Godot 4.5, and the licence makes it safe to experiment with in both personal and commercial projects. The fact that it comes with sample models and a simple viewer makes first tests easy, without needing to drag in your own rigged assets immediately. Given the “work in progress” status, developers should expect to tweak and maintain the shaders themselves if they want to rely on them for long-term projects.

Final Thoughts: Long Live Godot’s Human-Face Ambitions

It is refreshing to see a shader release like this in the Godot community. The engine is often associated with stylised indie games, so a public set of shaders that lean toward realism is a welcome surprise. For those wanting to go deeper into the engine, Digital Production author Helge Moos is running a comprehensive training programme at Pixeltrain where he develops a full game in Godot from scratch. These shaders can be dropped into such a project as test assets or even as a starting point for production work.

The post Skin Deep & Code Clean: Free Human Shaders for Godot (Yes, Godot, Not Unreal) first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Godot Engine has shipped version 4.5 as the latest long-term stable release. This update follows the 4.x cycle that started in early 2023 and adds new rendering capabilities, accessibility features, animation tools, and scripting improvements. It also contains hundreds of smaller bug fixes and workflow refinements.

A Stencil Buffer, at Last

The most visible rendering addition is the stencil buffer, which enables masking, outlining, and selective rendering passes. This feature has been requested since early 4.x releases and is now officially implemented. With stencil operations in place, developers can precisely control which pixels are written to the frame buffer and which are discarded. This makes it possible to create effects such as portals, mirrors, and selective cutouts without resorting to costly workarounds.

The stencil buffer is supported across both Forward+ and Compatibility renderers. It also integrates with Vulkan backends, making the feature consistent across the most widely used pipelines.

Screen Reader Support

Godot 4.5 also introduces experimental screen reader support in its editor. The feature provides text-to-speech navigation for menus, property fields, and dialogs. Although currently limited, this represents a meaningful step toward accessibility in professional tools.

The team has confirmed that support is still platform-dependent and may vary between operating systems. Developers who rely on accessibility tools should test their setup carefully to determine whether the implementation is stable enough for daily use.

Shader Baker

A further highlight is the arrival of the shader baker. This tool allows artists and developers to precompute shader results into textures, reducing runtime computation and improving performance. For instance, complex lighting calculations can be baked into static assets, or high-frequency surface details can be preserved in textures without the overhead of live shader evaluation.

The utility is particularly useful in workflows that involve environment precomputation, texture-based optimisations, or light baking. In practice, this reduces GPU load in real-time contexts and makes it easier to achieve stable frame rates on lower-powered hardware.

Animation Overhaul

The animation system has received a series of technical improvements designed to make playback and blending more predictable. Blending between animation states is now smoother and more controllable, reducing visible artefacts when characters or objects transition between motion clips. Memory handling has been optimised, which benefits large projects with many animation tracks.

New APIs expose finer control over state transitions, giving technical artists more precise tools for synchronising movement and timing. These adjustments aim to make animation systems more dependable in both gameplay-driven and cinematic contexts.

Physics: More Predictable Behaviour

The physics backend has also been refined. Character controller movement is now more accurate, which reduces sliding and unintentional jitter when navigating complex geometry. Tilemap collisions have been stabilised through chunk-based calculations, which means large maps behave more consistently. Meanwhile, soft body and joint behaviours have been corrected to avoid unpredictable artefacts.

The focus in this release is on reducing irregular behaviour that could cause projects to break under different frame rates or physics steps. Artists and technical directors should still test simulations in their own conditions, but the general direction is toward predictability and stability.

Scripting and API Additions

On the scripting side, several practical additions make daily work easier. The new duplicate_deep method allows developers to copy objects along with all their subresources, solving a long-standing issue where references could be lost during duplication. Signals handling has been adjusted to behave more consistently, reducing subtle bugs in event-driven systems.

C# bindings have also been aligned across more platforms, narrowing the gap between GDScript and C# development. These changes may seem incremental, but they add up to a more reliable foundation for complex projects.

Editor Quality-of-Life

The editor itself benefits from numerous workflow refinements. The property inspector has been made more responsive, which speeds up interaction in large scenes with many nodes. Scene loading is now faster in projects with heavy hierarchies, saving valuable time when opening or switching between levels. Dock management has been stabilised, and layouts are less prone to accidental resets.

Multi-window setups, which were previously inconsistent between Linux, macOS, and Windows, have been improved. This means artists working with multiple monitors or custom layouts should see fewer quirks across operating systems.

Rendering Fixes and Refinements

In addition to the stencil buffer, rendering has received smaller but still significant corrections. Light culling in Forward+ has been tuned for greater accuracy, reducing unexpected lighting artefacts. Decal rendering has been adjusted to behave more consistently across different materials and geometries. Volumetric fog has been made more stable, with fewer sudden changes in density under dynamic conditions.

GPU memory leaks that previously occurred with specific driver configurations have also been addressed. macOS builds in particular benefit from improved Metal backend stability, which had been a source of crashes in earlier 4.x versions.

Platform Support

Godot 4.5 broadens its platform stability as well. Android export templates are now more reliable and produce fewer runtime crashes. Web exports have gained fixes for audio playback and shader compatibility, which should improve consistency in browser-based deployment. On macOS, the Metal backend has been improved further, reducing editor freezes and improving rendering consistency.

These platform refinements are not headline features, but they are essential for developers who build across multiple targets.

Testing Before Use

As always with Godot, the development team stresses that new features should be thoroughly tested before they are integrated into production pipelines. Even with hundreds of fixes in 4.5, edge cases and platform-specific issues are inevitable. The best practice remains to evaluate updates in controlled environments before rolling them into client projects or studio pipelines.

The post Godot 4.5: New Buffers, Better Access, More Control first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Jude Janitha’s Godot Pixel Renderer, published just last week, is a free and open-source toolkit designed for Godot Engine 4.4 and above. It enables real‑time conversion of 3D models and animations into retro-style pixel art. Both the source and a compiled version are available: the GitHub version under an MIT license, and a “name‑your‑own‑price” packaged version on Itch.io

FREE & OPEN SOURCE Pixel Renderer is now online!
byu/Longjumping_Guard726 ingodot

Pixelization & Palette Control

Users can set pixelization from tiny 8-pixel blocks up to 800px resolution. The tool also supports color quantization between 2 to 32 colors, including a fixed 8‑color palette option.

Shader Packs & Post Processing

It ships with advanced shader-based effects such as edge detection (Sobel), dithering (Bayer), sharpening, and outline rendering. Users can also tweak HSV, contrast, gamma, and brightness settings.

Animation & Export Capabilities

The toolkit processes animated GLB/GLTF files, enables frame‑by‑frame export as PNG sequences, and includes progress tracking with configurable FPS settings between 1 and 120. Export can also be tailored by frame range, resolution scaling, naming conventions, and batch output options.

Interface & Workflow

The interface offers model loading, orthographic camera controls (orbit, pan, zoom), lighting adjustments, loading presets, real-time preview, console logging, and auto‑refresh on GLB/GLTF reimports . Requirements are Godot 4.4+, OpenGL 3.3+ GPU, and minimum 4 GB of RAM .

Licensing & Support

Under the MIT license on GitHub. Itch.io offers the compiled build at “name‑your‑own‑price”—Windows and Linux versions are available, priced at ≥ $4.99 USD for the binary.

The post Godot Pixel Renderer: Get a Free 3D‑to‑Pixel Art Export Toolkit first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Luke Stilson, known as sharpened, has released OpenVAT, a Blender add‑on that encodes vertex animation textures (VATs) directly from animated geometry via Geometry Nodes. VATs store per‑frame vertex positions—and optionally normals—in textures for real‑time playback in game engines.

What Are VATs?

Vertex Animation Textures (VATs) are a technique for encoding the animation of 3D mesh geometry directly into 2D image textures. In a typical VAT workflow, every vertex’s position for each animation frame is packed into a texture, with the red, green, and blue channels usually representing the X, Y, and Z coordinates. At runtime, a custom shader reads the texture and moves each vertex to its stored position for the current frame—completely on the GPU. This approach bypasses traditional CPU-based animation systems, enabling high-efficiency playback even for scenes with complex geometry or dense vertex counts.

VATs are particularly valuable in real-time engines like Unity, Unreal Engine, or Godot, where conventional skeletal or rig-based animation can be too heavy, or simply not applicable—such as with fluid simulations, procedural destruction, or crowds, where vertex movement doesn’t follow bones. By storing both position and, optionally, normal vectors in textures, VATs allow highly detailed, non-rigged animations to play back smoothly in real time, using only shaders. This workflow does require custom export tools and compatible shaders for interpretation, so it’s best suited to technical artists and studios familiar with shader-based animation pipelines.

VAT Export for Real‑Time Engines

OpenVAT supports exporting VATs for Unity, Unreal Engine, and Godot. It offers both packed normals (combined position + normal maps) and separate normal textures. Frame‑based capture from Geometry Nodes is supported, with arbitrary attribute encoding via custom RGB plus optional scalar channels.

Output Formats & Workflow

Output formats include high‑quality 16‑bit PNG or half‑float EXR, and mesh exports in FBX or glTF/.glb. Users can auto‑generate a preview scene inside Blender and select whether transforms are baked in world or object space. A proxy “bind pose” object is used to calculate deltas.

Engine Integrations

Unity users can install the OpenVAT Unity package, point to the VAT folder, and use the custom panel under Tools > OpenVAT. For Unreal Engine 5, the add-on works in non‑forward rendering mode, but requires RGB16 compression, proper edge‑splitting on mesh, and a drop‑in of the VAT tools into the project Content. Godot support is provided via starter scripts, though manual assignment of min/max metadata to shaders is necessary.

Recent Updates & User Feedback

Version 1.0.3, released April 29, 2025, added EXR export, custom frame‐range, world/object space selection, GLTF export, attribute stripping, collection combining, and edge splitting for normal safety. Users on Blender Extensions report smooth texture usage and active development.

Utility & Production Notes

OpenVAT is aimed at technical artists, shader developers, and studios wanting to bake procedural, simulation, or destruction animation into VATs for engine playback. It can reduce reliance on heavy Alembic caches and enable shader-driven VFX. However, as always: test new tools in your own pipeline before using in live production environments—especially for stability with normals and world‑space outputs.

OpenVAT is free, GPL‑licensed, and available on Blender Extensions and GitHub.

---

// OpenVAT on Blender Extensions
// OpenVAT on Github

The post OpenVAT Adds VAT Encoding to Blender—Real-Time Asset Ready first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Godot 4.5 Dev 5 introduces native support for Apple’s visionOS, marking the first officially-supported platform integration in about a decade. This addition, contributed by Ricardo Sanchez-Saez from Apple’s visionOS engineering team, enables developers to build applications for Apple’s XR environment directly within Godot.

GDScript: Abstract Classes

GDScript now supports abstract classes, allowing developers to define classes that cannot be instantiated directly but serve as a base for other classes. This feature, implemented by Aaron Franke, introduces the abstract keyword, enabling a more structured and object-oriented approach to scripting in Godot.

Shader Baker

The new shader baker feature, developed by Darío Samo and Pedro J. Estébanez, allows for exporting precompiled shaders to significantly reduce shader compilation times, especially on Apple devices and D3D12. While this feature can decrease load times by over 20× in certain demos, it comes with trade-offs, including increased export times and larger build sizes. Additionally, support for the Forward+ renderer on Intel Macs is no longer guaranteed due to the removal of certain MoltenVK bug workarounds.

WebAssembly SIMD Support

Godot 4.5 Dev 5 integrates WebAssembly SIMD support, enhancing performance for web builds by leveraging Single Instruction, Multiple Data (SIMD) capabilities across major browsers. This implementation, led by Adam Scott, provides an alternative to multi-threaded web support, which had been reverted in previous versions.

Inline Color Pickers

A new quality-of-life feature adds inline color pickers within the script editor, allowing developers to view and select colors directly in their code. This enhancement, contributed by Koliur Rahman, improves the intuitiveness of color assignments without the need to expose variables.

Rendering Enhancements

Several rendering improvements have been introduced:

• SMAA 1x anti-aliasing has been integrated into the engine, thanks to Raymond DiDonato.
• Bent normal maps, contributed by Capry, enhance specular occlusion and indirect lighting.
• The Compatibility backend now uses a fragment shader copy instead of a blit copy, addressing sample rate issues on mobile devices, as implemented by Clay John.

These updates aim to improve visual fidelity and performance across various platforms.

Community Contributions and Bug Fixes

The development snapshot includes numerous fixes and enhancements contributed by the community, addressing various issues and enhancing the engine’s stability. As the feature freeze approaches, developers are encouraged to test the new features and report any bugs to ensure a smooth beta period. For more details and to download the latest development snapshot, visit the official Godot Engine website: godotengine.org

The post Godot 4.5 Dev 5: Shaders, Colors & Abstracts Galore first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Blender Studio has unveiled Dogwalk, a micro-game developed using the Godot Engine, now available in early access. This project serves as a practical exploration of integrating Blender with Godot, aiming to refine the asset and level creation workflow between the two platforms.

Time to go for a walk in the snow! Cooperate with Pinda or run freely? Your game, your choice!
[Limited release for studio subscribers, wider release to come.]#b3d #godot #BlenderStudio #DogWalk #videogamehttps://t.co/Og36TVhnSQ pic.twitter.com/wgKuWBz89F

— Blender Studio (@BlenderStudio_) May 20, 2025

Gameplay Mechanics and Design

Dogwalk offers a concise, interactive storytelling experience characterized by a papercraft aesthetic. Designed for a single sitting, the game centers around a primary mechanic that emphasizes player expression and replayability. Players control a large dog named Chocomel, accompanied by their child owner, Pinda, as they navigate a snow-covered forest in search of items to decorate a snowman. The dynamic between the robust dog and the easily-dragged child introduces humorous challenges and fosters a sense of relationship-building through gameplay.

Animation and Rigging Nuances

The development team implemented ten distinct petting animations to depict interactions between Chocomel and Pinda. These animations accommodate various states and transitions, ensuring a seamless and engaging experience. (Blender Studio) Given Godot’s limitations with certain Blender features, such as bendy bones, the team introduced specific “Godot bones” to facilitate necessary movements, like the swiveling of Pinda’s arm when the leash is pulled. These bones are hidden from animators and remain unanimated within Blender, serving solely for in-game adjustments within Godot.

Current Status and Accessibility

While Dogwalk is feature-complete, it remains in early access, with known bugs and performance issues. Blender Studio plans to collect user feedback, address significant issues, enhance performance for broader hardware compatibility, and resolve various bugs to improve the overall experience. The game is currently exclusive to Blender Studio subscribers, with plans for a free public release upon completion. Interested users can access the game and its source code via the official Blender Studio website.

Final Thoughts

Dogwalk exemplifies Blender Studio’s commitment to exploring and refining the integration between Blender and Godot. By focusing on a manageable project scope and embracing a unique art style, the team provides valuable insights into the practicalities of cross-platform development. As the game progresses towards its full release, it stands as a testament to the potential of open-source tools in creating engaging interactive experiences. For more information and to follow the project’s development, visit the Blender Studio project page.

The post Dogwalk: Blender’s Papercraft Pooch Takes Godot for a Spin first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Launched by Cory Petkovsek in 2023, Terrain3D has steadily evolved, culminating in the release of version 1.0 for Godot Engine 4.4. This update encompasses 132 commits aimed at refining landscape creation within the engine.

Enhanced 3D Projection

One standout feature is the improved 3D projection, allowing textures to map accurately onto vertical surfaces, such as cliff faces, even when vertices are stretched. This advancement ensures more realistic and visually appealing terrains.

https://twitter.com/TokisanGames/status/1906349226562621830

Dynamic Collision Mode

The introduction of Dynamic Collision mode is a game-changer. By generating collisions only around the player, it conserves several gigabytes of memory and facilitates runtime terrain modification. This optimization enhances performance without compromising on interactivity.

Level of Detail (LOD) Support

The instancer now accommodates up to 10 LODs for foliage instances, improving rendering efficiency. MMIs (Multiresolution Mesh Instances) are generated in a 32×32 meter grid, swapping one cell at a time. While this approach may lack the precision of per-instance generation, it offers superior performance. With closely matching LODs, most users will notice no discernible difference.

LODs are now circular and employ geomorphing between levels, ensuring seamless transitions and reducing visual popping artifacts. This enhancement contributes to a more immersive experience.

Ambient Occlusion (AO) is now derived from height textures. Additionally, AO, roughness, and normal maps are exposed, allowing adjustments without altering the original texture files. Height blending between textures has also seen significant improvements, offering greater control over terrain appearance.

The update includes a compatibility renderer, enhancing support for WebGL platforms. This improvement ensures that projects utilizing Terrain3D can reach a broader audience across various devices and browsers.

Users now have access to additional texture options, accompanied by improved blending techniques. These enhancements provide greater flexibility and control over the visual aspects of terrain, allowing for more detailed and realistic environments.

Terrain3D 1.0 provides full control through a well-documented API, accompanied by a demo to guide users through its features. This resource empowers developers to harness the tool’s full potential effectively. For a detailed overview of all changes and enhancements, refer to the release notes.

The post Terrain3D 1.0: Godot’s Landscape Tool Levels Up first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The Godot Engine community has unveiled the first development snapshot of Godot 4.5, signaling the end of the feature freeze and the introduction of several noteworthy enhancements.

“Mute Game” Toggle: Silence is Golden

Previously, developers had to rely on operating system tools or pause their work to mute audio during in-editor testing. Thanks to Malcolm Anderson’s contribution, a new “Mute Game” toggle has been integrated directly into the Game view. This allows developers to halt or restore audio output with a single click, streamlining the testing process.

Universal UID Support: Drag and Drop Simplified

With the introduction of UID (Unique Identifier) support in Godot 4.4, the engine began optimizing core components. However, preloaded resources lacked the ability to be loaded as UIDs when dragged. Tomasz Chabora addressed this limitation, enabling preloaded resources to be dropped as UIDs, further enhancing the engine’s flexibility.

Bug Fixes: Squashing Over 400 Issues

This snapshot isn’t just about new features; it also focuses on stability. The release addresses a substantial number of bug fixes, with over 400 issues resolved. This reflects the team’s commitment to providing a stable and reliable development environment.

As with any development snapshot, it’s advisable to thoroughly test these new features in your specific project environments before integrating them into production pipelines. For a comprehensive overview and to download the snapshot, visit the official announcement on the Godot Engine website.

Note: Always ensure that new features are compatible with your current projects before full integration.

The post Godot 4.5 Dev 1: The Feature Freeze Thaw Begins first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

First up, Godot 4.4 integrates the Jolt Physics engine directly into its core. Previously available as an extension, Jolt has been the go-to physics engine for many users since late 2022. While this feature is rigorously tested, it’s currently labeled “experimental.” Developers can enable it in the project settings after consulting the documentation to ensure compatibility with their specific use cases.

Embedded Game Windows

Gone are the days of juggling multiple windows like a circus performer. Godot 4.4 introduces embedded game windows, allowing developers to run the game seamlessly within the editor. This feature is currently supported on Linux, Windows, and Android platforms, with macOS support in the pipeline.

Interactive In-Game Editing

Ever wished you could tweak your game on the fly? Now you can. Godot 4.4’s interactive in-game editing lets developers modify game elements in real-time, even while the game is running or paused. This enhancement streamlines the development process, making it more intuitive and efficient.

Ubershaders

Shader compilation stutter got you down? Enter Ubershaders. These pre-compiled shaders act as fallbacks, eliminating the need to wait for specialized shader pipelines to compile during gameplay. The result? A smoother gaming experience without those pesky pauses.

AgX Tone Mapping

For those striving for a cinematic look, Godot 4.4 introduces AgX tone mapping. Adapted from Blender’s recent adoption of the AgX algorithm, this implementation provides a more filmic rendering, especially effective in handling bright scenes.

Performance Improvements

Under the hood, Godot 4.4 boasts faster load times, reduced stuttering, and streamlined processes. These quality-of-life improvements enhance the overall development experience, making the engine more responsive and efficient.

Before migrating existing projects to Godot 4.4, developers are advised to consult the migration guide to understand any breaking changes.

The post Godot 4.4: The Engine That Could (and Did) first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

With the new version 4.3 of the Godot Engine, the developers have integrated numerous improvements and new functions that are specifically tailored to the needs of CG artists. The focus is on optimising and expanding existing tools to make complex digital projects more efficient and flexible.

Volumetric fog: more realism in the visualisation

The introduction of “Volumetric Fog” in Godot 4.3 offers you an improved representation of fog and smoke in real time. The engine now supports the simulation of light scattering within fog volumes, which makes for more realistic and atmospheric environments. Especially for scenes that require a dynamic atmosphere, such as in film production or real-time visualisations, this is a welcome enhancement.

The new fog function is fully integrated into the pipeline and works efficiently with the existing lighting and shading engine. However, the complex calculation of the light interactions within the fog can require high computing power, depending on the scene and project. Users should therefore test the new functions thoroughly before integrating them into production projects.

Meshlet rendering: Efficient rendering of complex geometries

Meshlet rendering is another important new feature in Godot 4.3. This technology makes it possible to divide large and complex models into smaller parts, so-called meshlets. This leads to more efficient processing and visualisation of geometries, as only the visible parts of the model need to be rendered. For VFX artists working with highly detailed scenes, this is a significant relief as it can considerably reduce render times. Especially in real-time applications, such as games or interactive visualisations, meshlet rendering can help to optimise performance on different hardware configurations. Here too, however, it is advisable to evaluate the technology in detail before using it in production.

Improved animation tools: Precision and flexibility

The animation toolset has also been revised with Godot 4.3. The new functions offer you as a user more precision when creating and customising animations. The “Animation Retargeting” feature allows you to easily transfer animations to different characters, which greatly simplifies the workflow for projects with multiple characters.

The integration of Animation Trees has also been improved, allowing you to manage and customise complex animations more efficiently. These new features are particularly useful for artists working on projects with many animated characters or objects. Improved control over timing and transitions allows for more realistic motion sequences, which is important in VFX and game production.

Extended file format support: More flexibility at work

Godot 4.3 extends support for different file formats, giving you greater flexibility when importing and exporting your projects. The engine now supports a wider range of 3D file formats, including FBX and OBJ, and improves integration with external tools such as Blender. This expanded format support facilitates the exchange of assets between different software solutions and enables smoother collaboration in mixed production environments. Although the new formats have been extensively tested, artists should ensure that all imports are correct and lossless before using them in current projects.

Further optimisations: Improved performance and stability

In addition to the major features, Godot 4.3 offers a number of smaller optimisations that have a positive effect on the general performance and stability of the engine. These include improvements to the rendering backend, which increase the general frame rate and responsiveness of the engine.

The developers have also worked on the user interface to further improve the workflow. This particularly affects the scripting and debugging areas, where new tools and options have been added. These changes are aimed at providing you as a user with an even more pleasant and productive working environment.

Licence model and availability

Godot 4.3, like the previous versions, remains available under the MIT licence, which means that the engine can be used free of charge. This openness makes Godot particularly attractive for indie developers and small studios who want to benefit from the professional features without having to pay high licence costs.

For more information and detailed instructions on how to use the new features, you can consult the official documentation. Information on downloading and installing the latest version can be found directly on the manufacturer’s website.

The post New functions in Godot 4.3 for CG Artists first appeared on DIGITAL PRODUCTION and was written by Jürgen Firsching.