u/FlamingoSad9210

I created this video to demonstrate the different depth techniques available in Procedural Material Layers:

• Parallax Occlusion Mapping
• Triplanar POM
• Pixel Depth
• Silhouette Parallax Occlusion Mapping

Procedural Material Layers (PML) is a modular material system for Unreal Engine 5 that helps to combine, blend, paint, and customize materials using reusable layers and procedural masks.

PML on Fab:
https://fab.com/s/0a26f21e3f35

You can find more PML tutorials and feature demonstrations on my YouTube channel.
https://www.youtube.com/playlist?list=PLhqUhIN0Uwzn-UajaMykxkk97-RrXWw9h

I’d be happy to hear your feedback or answer any questions.

Hi everyone,

I’ve released a major update for Procedural Material Layers, my non-destructive material layering system for Unreal Engine 5.

The update includes:

• Nanite vertex painting, Mesh Paint, and texture painting https://youtu.be/YM-JprQ8H3s
• Procedural puddles using noise masks and height blending https://youtu.be/JvBqxV-uvLo
• Rain effects with wet surfaces, raindrops, and ripples
• https://youtube.com/shorts/H0_sKx5snbo?feature=share
• A customizable Decal Generator
• Parallax Occlusion Mapping (POM) https://youtu.be/20r6UkmsoBE
• Pixel Depth Offset
• Silhouette Parallax Occlusion Mapping (SPOM)
• Performance optimizations, fixes, and workflow improvements
• Support for Unreal Engine 5.8

The system is designed to help environment artists build detailed PBR surfaces while keeping every layer editable and non-destructive.

You can find the updated version on Fab: https://fab.com/s/0a26f21e3f35

Check out the latest Video on YT:
https://www.youtube.com/playlist?list=PLhqUhIN0Uwzn-UajaMykxkk97-RrXWw9h

I’d really appreciate your feedback!

SPA Materials Baker is now 30% off, and Procedural Material Layers is 50% off for a limited time.

If you work with Unreal Engine materials, baking, procedural masks, vertex paint, or layered material workflows, this is a good time to check them out.

https://www.fab.com/portal/listings

#UnrealEngine #FabMarketplace #GameDev #TechnicalArt #UE5 #MaterialEditor

Turn layered Photoshop UI designs into clean, structured Unreal Engine UMG layouts in minutes. Perfect for menus, settings screens, HUDs, mobile UI, and any production-ready game interface

🔗 Get UI Widget Builder on Fab: https://fab.com/portal/listings

📖 Documentation: https://sepinood.github.io/UIWidgetBuilder/

Video Demonstration: https://youtu.be/OUc7Mwuv9XA

Every UI-heavy project I've worked on had the same bottleneck: an artist designs the menu in Photoshop, and then someone has to manually recreate that entire layer hierarchy in UMG — naming widgets, setting anchors, wiring up buttons, redoing it every time the design changes. It's slow and it eats hours that should go toward actual gameplay work.

So I built UI Widget Builder, an Unreal Engine editor plugin that automates PSD-to-UMG conversion.

How it works:

1. Design your UI in Photoshop using a set of layer naming prefixes
2. Run the included Photoshop JSX exporter — it spits out a layout.json + Textures folder
3. Import that into Unreal Engine (Tools → UI Widget Builder)
4. It auto-generates the widget hierarchy, root screens, textures, and layout structure

It also has optional Blueprint logic generation for the boring stuff — button interactions, WidgetSwitcher tab logic, close-on-escape, slider/checkbox helpers, sound hookups, etc — so you're not starting from a totally blank graph either.

Some other things it handles: portrait/landscape support, SafeZone/ScaleBox/SizeBox wrappers, a preset manager so you're not redoing import settings every time, and a clean re-import option when the design changes.

Happy to answer questions about the workflow or how the exporter handles layer naming — this came out of solving my own pain point, so curious if it'd be useful for other people's pipelines too.

Get UI Widget Builder on Fab: https://fab.com/s/9d5dec9c53ca

Video Demonstration https://youtu.be/OUc7Mwuv9XA

Documentation https://sepinood.github.io/UIWidgetBuilder/

Every UI-heavy project I've worked on had the same bottleneck: an artist designs the menu in Photoshop, and then someone has to manually recreate that entire layer hierarchy in UMG — naming widgets, setting anchors, wiring up buttons, redoing it every time the design changes. It's slow and it eats hours that should go toward actual gameplay work.

So I built UI Widget Builder, an Unreal Engine editor plugin that automates PSD-to-UMG conversion.

How it works:

1. Design your UI in Photoshop using a set of layer naming prefixes
2. Run the included Photoshop JSX exporter — it spits out a layout.json + Textures folder
3. Import that into Unreal Engine (Tools → UI Widget Builder)
4. It auto-generates the widget hierarchy, root screens, textures, and layout structure

It also has optional Blueprint logic generation for the boring stuff — button interactions, WidgetSwitcher tab logic, close-on-escape, slider/checkbox helpers, sound hookups, etc — so you're not starting from a totally blank graph either.

Some other things it handles: portrait/landscape support, SafeZone/ScaleBox/SizeBox wrappers, a preset manager so you're not redoing import settings every time, and a clean re-import option when the design changes.

To be clear about limitations: it's editor-only, generated widgets are meant to be treated as generated output (manual edits can get wiped on clean re-import), and project-specific stuff like save systems, localization, and gameplay logic still needs manual work. It's a UI generation tool, not a magic wand.

Video demo | Docs

It's up on Fab if anyone wants to check it out: [UIWidgetBuilder]

Happy to answer questions about the workflow or how the exporter handles layer naming — this came out of solving my own pain point, so curious if it'd be useful for other people's pipelines too.

Hey fellas.
Working on an UE editor plugin called UIWidgetBuilderEditor.

The goal is building a fully automated UI pipeline between designers and Unreal Engine. Instead of rebuilding everything manually in UMG, the system imports PSD/JSON layouts and automatically generates:
UMG widget hierarchies
Blueprint logic
panel/screen workflows
modal systems
DPI/platform setup
layout wrappers (SafeZone / ScaleBox)
visibility & interaction helpers

The important part:
A UI designer can test and iterate layouts directly inside Unreal Engine with very little engine knowledge.

The workflow is based on a structured naming convention from the design side.
Example naming roles:
GRP_ → UI Groups / Screens
PNL_ → Panels
BTN_ → Buttons
TXT_ → Text widgets
IMG_ → Images
ModalBG_ → Modal overlays
The importer reads those naming rules and automatically builds the proper runtime hierarchy and Blueprint logic.

Example:
You can build a full Settings UI in Photoshop/Figma, export JSON, and automatically generate:
settings panels
navigation logic
modal backgrounds
visibility switching
input/cursor handling
runtime widget hierarchy
without manually rebuilding the entire UI in UMG.

Current pipeline already supports:
✅ JSON hierarchy reconstruction
✅ automatic UMG generation
✅ generated Blueprint logic
✅ per-panel usage settings
✅ modal background generation
✅ screen-type detection from layout groups
✅ visibility logic generation
✅ platform/DPI setup
✅ SafeZone + ScaleBox wrapper generation

Goal is turning this:
PSD / Figma / JSON
→ automated Unreal UI generation
→ production-ready UI scaffolding

instead of spending hours rebuilding layouts manually.
Currently exploring:
runtime screen managers
UI state machines
animation generation
automatic navigation
responsive layouts
design-to-runtime workflows
CommonUI integration

Curious what other UE UI developers/designers would want from a tool like this.

What features would save the most production time in your UI workflow?

Hey everyone,

I’ve been working on a material baking tool for Unreal, and just released Version 2 on FAB.

This started as something I built for my own workflow — mainly to deal with converting complex materials (layered, procedural, world-aligned, etc.) into clean texture maps.

V2 is a pretty big upgrade over the first version:
• Added proper batch baking workflows
• Automatic material + instance creation
• Support for skeletal meshes (characters)
• Better handling of tiled / UDIM-style UVs
• Improved overall workflow (less manual setup)

The goal is basically:
👉 Take any material → bake it → get clean PBR textures + ready-to-use material

If you want to check it out:

🎬 Demo:
https://www.youtube.com/playlist?list=PLhqUhIN0UwzmjTkehp6K2BppBabcJlAAS

📘 Full feature documentation:
https://docs.google.com/document/d/1ioXa8aAXfeB8HRpXTOPkRaT4ZdU9VIVl/edit

🛒 FAB page:
https://fab.com/s/4baa5507c1e8

If you tried V1 before, I’d really love to hear what you think about the changes in V2.

And if you’re dealing with similar workflows, happy to answer any questions 👍