FT SIMULATION - BUY ON FAB

CURRENT VERSION, BETA 4. March 2026.

FT (foliage tools) Simulation is a tool that allows for asset placement through physical interaction.
It is part of a larger group of tools I personally use for game development. As such, it will receive updates based on intense testing, requirements and performance measuring.

Origin of the tool comes from needing to break down photogrammetry terrain pieces into smaller components. The Fuerteventura rock landscape made this instantly clear.
Large areas and meshes require high texture sizes and geometry detail are hard to manage. It is impossible to get good pixel density and sharp geometry results.
The answer is to not capture an area but everything in it. This gives full 360 components that can be infinitely rearranged into new formations with little memory usage.
This way, a small amount of rocks could form an entire terrain, but the tool for all this did not exist.

The focus is functionality. The tools visuals are what they are, as time is extremely limited. This also means as the complexity grows some things are held together with ductape for now.

Quick feature overview for BETA 4 release.

Recording new videos now, this is an overview video for BETA 3.




FT Simulation

Use physical simulation as a placement tool, paint and brush instances into your scene and let them settle naturally.
It is aimed at increasing environmental quality through controlled layering and bringing attention to detail.
A tool focused on hand crafted scenes, a fun and easy way of adding that little extra to elevate the art that is game development.

Built as a hybrid between C++ and Editor Utility Widget, it provides Blueprint flexibility while C++ handles performance critical operations natively.

How it works

Instance transforms are stored as int16 positions and int8 rotations, lowering the memory cost of standard transforms. At runtime these compressed offsets reconstruct into Hierarchical Instanced Static Mesh Components, giving you density with minimal memory footprint. Additionally, other Per instance custom data can be stored for different ranges of behavior.

Key Features

Physics based placement,  push, pull and whirl instances at runtime with mass normalized forces
Sleep and disable timers,  actors manage their own physics lifecycle automatically
int16/int8 transform compression,  significantly reduced memory footprint versus standard HISM
Per instance custom data,  Array driven material variation, lighting, paint channels and custom floats
Re Simulate,  adjust parameters and run again without losing your data
Re Instance,  re uses position data from other simulations to reconstruct, storing only the actor as additional cost for thousands of instances
Re Compress,  re bake instance data into compressed format after edits
Per instance Cast Shadow calculation,  automatically disable shadows on occluded instances
Merge Runtime Actors,  combine multiple simulation actors into one
Magnet,  used to draw instances to a location
Distance to Center,  per instance distance value driving material falloff and variation
Culling Radius,  remove instances after specified distance
Convert to Static Mesh and back,  full flexibility to move your instances between workflows
Convert to Niagara,  feed instance data directly into Niagara systems for runtime interaction
Packed Level Actor support,  convert to static mesh, pack and use in PCG
Component Settings,  full control to optimize hism components
Sample Scene Lighting,  capture ambient light intensity per instance (will likely deprecate this in favor of ray based AO)
Sample Scene Color,  capture environment color per instance and drive material tint


The focus now is on "interaction nodes", providing out of the box presets to explode and perform abilities that manipulate instances by moving data between the hism components and niagara. The paint tool will be a powerful contribution to this, painting instances with masks and values that can be used for blending any sort of behavior in materials or Niagara.

Roadmap

Paint Tool,  brush gradients and masks directly onto instances, stored in custom data channels, used for blending and gameplay
Interaction nodes,  Blueprint presets that can be used for gameplay interaction
Tiling Simulation,  create tiling textures and matching instance data
Area Manager,  zone based instance management to reduce uobject,component count
Height calculations for Re Instance,  follow new terrain surface
Runtime LOD generation,  automatic low poly replacement mesh at distance or for shadow proxy
Starter content


Demo level Plugin Content > FT_Simulation_Examples > Maps > FT_Simulation_Overview
Support: support@foliagetools.com Twitter https://x.com/artbyrens


Disclaimer/Additional Notes: This product is currently in BETA with reduced price.
Once complete the price will go up, Q4 2026, to 125USD for personal and 600USD for Professional use.

AI was used to locate engine variables and source references, clean up and validate code, peer review implementations and catch vulnerabilities.
All architecture, functionality, structure and design decisions are my own.

INSTALL AND ENABLE PLUGIN

SETTINGS OVERVIEW

STARTER CONTENT TO BE INCLUDED IN NEXT UPDATES

    20 various rocks          (processing)
    20 various branches       (processing)
    10 river rocks            (later time)
    10 concrete pieces        (processing)
    10 asphalt pieces         (processing)
    20 generic trash          (planned)
    20 various ground leaves  (processing)

TECHNICAL OVERVIEW

In the coming days will be breaking the tool down into how it exactly works and all the extra functionality around each action (there is a lot to cover..).
Some early placeholder info:

The spawn information from the Data Asset gets used by the Utility Widget to pass to FT_Simulation_Actor.h which is added once to the level while simulating as manager.
From here the actor spawns FT_Simulation_Physics.h blueprint actors that are holding the information needed for merging.
The Utility widget then gathers all data from the spawned Physics actors and sorts them based on similar static mesh and or similar materials.
They then are stored on a UObject associated with each FT_Simulation_Runtime.h actor.
Offloading the data provides an massive speed increase when selecting and editing the actors in the level, as array data is not directly on the actor and there is no instance data stored on the hism component (gathering data on this now for presentation).
FT_Simulation_Runtime.h actor then rebuilds all components on construct, only in Editor.
When packaging the game, all UObjects and extra data is stripped from the actor, and instance data is moved into a variable for read back on Begin Play.
(This later will get added functionality where it only recreates when required, say player is within distance, so we avoid creating components if we dont need to)

// DATA FLOW
// ------------------------------------------------------------------------------------
// data asset,          DataAsset.h ->               user settings for spawning
// mesh spawn params,   FMeshSpawnParams ->          used by the spawn function
// spawn ->
// mesh instance data,  FMeshInstanceData ->         assigned to spawned physics BPs
// bake instance data,  FInstanceDataEditor ->       used by the editor
// convert to runtime,  FInstanceDataRuntime ->      used by packaged game
// ------------------------------------------------------------------------------------

Normal Compression as default

// Normal Compression: int16 location, int16 rotation (pitch/yaw/roll), int8 scale
USTRUCT(BlueprintType)
struct FInstanceNormalCompressedRuntime
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
    int16 X = 0;
    UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
    int16 Y = 0;
    UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
    int16 Z = 0;
    UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
    int16 Pitch = 0;
    UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
    int16 Yaw = 0;
    UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
    int16 Roll = 0;
    UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
    uint8 Scale = 0;
};

Heavy compression for very fine detail

// Heavy Compression: int16 location, random XY rotation, int8 scale
USTRUCT(BlueprintType)
struct FInstanceHeavyCompressedRuntime
{
	GENERATED_BODY()

	UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
	int16 X = 0;
	UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
	int16 Y = 0;
	UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
	int16 Z = 0;
	UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
	uint8 Yaw = 0;    // 0-255 maps to 0-360 degrees, XY randomly generated
	UPROPERTY(EditAnywhere, Category = "FT Simulation Compression")
	uint8 Scale = 0;  // 0-255, RECOMMENDED SIZE IS 0 TO 2.55 X SCALE
};

UObject, each actor holds and instance

UCLASS(BlueprintType)
class FT_SIMULATION_RUNTIME_API USimulationDataRuntime : public UObject
{
	GENERATED_BODY()
public:

	// Data the actor holds in editor, uncompressed
	// CHANGING NAME NOW WILL BREAK ALREADY SIMULATED ACTORS!
	UPROPERTY()
	TArray MeshInstances;

	// Data the actor uses in editor to preview compression
	UPROPERTY()
	TArray CompressedInstances;
};