Shader Bridge

Skava in Rendering


Shader Bridge — Documentation

Version: 1.2.4
Compatibility: Blender 4.2 and later (checked on 4.2.9, 5.1.0, 5.2.0) · Unity URP checked on Unity 6000.4 (Shader Graph 17.4); older Unity versions not tested · Unreal: the .t3d file was not verified in Unreal


1. Installation

  1. Download shader_bridge_v1_2_4.zip (do not unpack).
  2. In Blender open Edit → Preferences → Add-ons.
  3. Click Install..., pick the ZIP, and tick the ShaderBridge entry to enable it.
  4. Press N in the 3D Viewport. Sidebar tab: ShaderBridge.

No external Python packages or DLLs are required.


2. Quick start

  1. Select the object and make the material you want to convert its active slot.
  2. Open Sidebar → ShaderBridge.
  3. Pick a target engine:
    • Unity URP → .shadergraph file (Universal Lit target; Universal Unlit for Emission shaders, a colour wired straight into Surface, and baked toon)
    • Unity HDRP (not supported, URP graph) → HDRP is not supported yet. This option writes the same URP graph, which an HDRP project does not render; the export says so.
    • Unity Built-in → .shader file (ShaderLab surface shader) — not verified in Unity
    • Unreal Engine → .t3d text file — not verified in Unreal (section 7)
  4. Set the export folder.
  5. (Optional) toggle Bake Procedurals if your material uses Noise / Voronoi / Wave / Musgrave or any node the engine has no equivalent for.
  6. (Optional) toggle Include Textures to copy any referenced Image Texture files alongside the shader.
  7. Click Export Material.

The exported file lands in the chosen folder, named after the Blender material.


3. Supported root shaders

Shader Bridge auto-detects the master surface — whatever sits at the Material Output's Surface input. The following Blender shader types are accepted as a root:

Blender shader How it maps to engine
Principled BSDF Direct one-to-one conversion. All standard inputs (Base Color, Metallic, Roughness, Normal, Emission Color/Strength, IOR, Alpha, Coat, Transmission, Subsurface) are preserved.
Emission Shader Blender does not light an Emission shader, so for Unity it becomes an Unlit Shader Graph whose colour is Emission Color × Strength (a texture into Color is connected; a Strength other than 1 on a texture is reported, not carried). A colour wired straight into Surface is treated the same way, because that is how Blender renders it. For Unreal it maps to Principled with emission_color / emission_strength.
Diffuse BSDF → Principled with metallic = 0, specular = 0, roughness from the Diffuse roughness input.
Glossy BSDF → Principled with metallic = 1, roughness preserved.
Glass BSDF → Principled with transmission = 1, IOR copied, metallic = 0.
Transparent BSDF → Principled with alpha = 0, transmission = 1, roughness = 0.

Reroute nodes are walked through transparently — they don't need any pre-cleanup.


4. Mix Shader / Add Shader

Both are walked transparently to find the dominant branch:

  • Mix Shader — the Fac value selects which branch is the master:
    • Fac < 0.5 → Shader 1 input becomes the master
    • Fac >= 0.5 → Shader 2 input becomes the master
    • Default if Fac is unconnected: 0.5 → Shader 2
  • Add Shader — the first connected branch becomes the master.

The non-master branch is not exported.


5. NodeGroups

Custom node groups are entered automatically. Shader Bridge looks at the group's internal GROUP_OUTPUT node and follows the connection on the requested output socket back to the real BSDF inside.

This means materials from BlenderKit, Poliigon, Quixel Bridge, and any other asset library that wraps its guts in a custom group convert correctly without you having to ungroup them first.

The only requirement: the group's GROUP_OUTPUT must have a Shader-typed output wired to a real BSDF (or to a Mix Shader / Add Shader / nested group that eventually leads to a BSDF).


6. Procedural baking

Toggle Bake Procedurals in the export panel. Shader Bridge will:

  1. Identify nodes the target engine has no native equivalent for (Noise / Voronoi / Wave / Musgrave / unsupported BSDFs), and any Shader To RGB toon chain (section 10).
  2. Use Cycles to bake each into an Image Texture at the resolution set in the Bake panel. Only the active mesh is baked; other selected objects (a camera, a light) are ignored. The object needs a UV map.
  3. Reference the baked PNG from the exported shader.
  4. Restore your material, selection, active object, mode and render settings exactly as they were — whether the bake succeeded or not.

If a bake cannot run (no UV map, the active object is not a mesh, Cycles reports an error), nothing is exported and the error names the reason. Your material is left exactly as it was, and Export Shader / Bake Procedural Textures can also be undone with Ctrl+Z.

Textures in Unity. Next to every PNG in the export folder Shader Bridge writes a .meta file, and the texture property in the graph uses that texture as its default. Copy the PNG together with its .meta into your project and a material made from the graph already has its texture. If a .meta is already there (you export into a Unity project, or export again), it is reused and never overwritten.


7. What reaches each engine

Unity URP Shader Graph — verified by compiling and rendering in Unity 6000.4:

  • Arrives: the surface shader's own values — Base Color, Metallic, Roughness (as Smoothness = 1 − Roughness), Alpha, Emission Color × Strength — as material properties with your values as defaults, and an Image Texture wired directly into one of those inputs, as a texture property with the PNG pre-assigned.
  • Baked to a texture (Bake Procedurals on): Noise, Voronoi, Wave, Musgrave, Color Ramp, Shader To RGB toon chains, node types Shader Bridge does not know.
  • Not carried yet: Math, Mix / MixRGB, Fresnel, Normal Map, Bump, Mapping, Texture Coordinate, Separate / Combine, Clamp, Invert, Vector Math, and anything that reaches the surface only through them. A texture's Mapping / UV transform is not applied (UV0 is used); normal maps and bump do not reach the Normal input.

Unity HDRP — not supported yet (see section 2).

Unity Built-in ShaderLab — a surface shader template filled with your values and textures; not verified in Unity.

Unreal T3D — not verified in Unreal. The file lists expressions for Image Textures, constants, Math, Mix, Fresnel, Normal Map, Invert, Clamp and Texture Coordinate; only expressions wired directly into a material pin are connected (links between expressions are not written). Baked textures are saved next to the .t3d but not referenced in it.

Channel packing is not produced: the baker writes colour maps only, so there is no metallic / roughness / AO map to pack. The Auto Channel-Pack toggle is hidden since v1.2.4.


8. Diagnostic Conversion Report

Every export returns a Conversion Report with these fields:

  • success — boolean
  • file_path — absolute path to the exported shader file
  • supported — number of nodes whose type the target's table knows. For Unity URP this does not mean they reach the graph — see section 7
  • unsupported — number of nodes that fell back to baked-texture placeholders or are unsupported by the target
  • root_kind — PRINCIPLED / EMISSION / DIFFUSE / GLOSSY / GLASS / TRANSPARENT / ADD_SHADER — tells you which path the converter took
  • baked_maps — paths of any textures baked during this export
  • warnings — human-readable messages about anything noteworthy (toon patterns detected, baked maps, copy results, errors)

If the material can't be converted at all (e.g. Use Nodes disabled, no Material Output, Surface input not connected), the warnings list contains a specific error with a concrete fix — no more Supported: 0 / Unsupported: 0 mystery.


9. Viewport approximation

A one-click button that nudges EEVEE and color management toward the engine's look so you can preview shaders without leaving Blender.

  • Auto-detects EEVEE Next on Blender 4.2+; properties that don't exist (e.g. the old bloom controls) are skipped silently.
  • Settings tuned per engine: Unity uses Filmic, Unreal uses an ACES-like high-contrast view transform.

Click Deactivate Preview to restore your original render / color-management settings — Shader Bridge stores them in a scene custom property and restores them exactly.


10. Toon (Shader To RGB)

Shader To RGB is an EEVEE node, and Unity has nothing like it. With Bake Procedurals on, Shader Bridge carries the toon look over as a texture:

  1. The shader feeding Shader To RGB is baked lit by your scene's lights (what Shader To RGB returns in EEVEE).
  2. That lit colour is run through your Color Ramp and everything after it (Mix, Multiply…).
  3. What reaches the surface is baked into one texture: <Material>_Toon.png.

If the ramp feeds an Emission shader, or goes straight into Surface, the Unity graph is Unlit and shows the texture as it is. If the ramp feeds the Base Color of a Principled BSDF, the graph stays Lit and Unity lights it on top, as Blender does.

Limitation — the bands are baked. They stay where the Blender light put them when you exported; rotating the light or the object in Unity will not move them. Toon shading that reacts to Unity's own lights needs a toon shader written for Unity (a lighting ramp inside the Unity shader). Shader Bridge does not generate one. Blender's view transform (AgX / Filmic) is not part of the texture: Unity shows the ramp colours themselves, as Blender does with the Standard view transform.

Unreal: the baked texture is written next to the .t3d, but the .t3d does not connect it — plug it into Emissive Color of an Unlit material yourself.

Checked in Unity 6000.4 URP on five setups (Diffuse or Principled → Shader To RGB → Color Ramp → Emission / × colour / Base Color / straight into Surface, and with an inverted-hull outline): 99.8–99.9 % of the sphere's pixels land on the same band in Unity as in Blender (average colour difference 0.5–1.1 of 255); the Base Color variant, which Unity lights on top, differs by 3.2 of 255 on average.


11. Troubleshooting

"Conversion Report shows Supported: 0 / Unsupported: 0"
Fixed in v1.1. Used to happen on Emission-only and Mix-Shader-rooted materials because the converter couldn't pick a master surface. v1.1 accepts six common BSDFs as roots and walks through Mix / Add Shader and NodeGroup containers automatically.

"Material has no surface shader connected"
Pre-flight diagnostic. The error message tells you the exact issue:

  • Use Nodes disabled → enable it in the Material panel and reconnect a shader.
  • No Material Output node → add one (Add → Output → Material Output) and connect your shader.
  • Surface input not connected → wire your shader (Principled BSDF / Emission / Mix Shader) into Surface.
  • Surface connected to something Shader Bridge can't use as master → 5 concrete fixes are listed.

"Procedural baker leaves my material broken" / "toon material turned black after export"
Fixed in v1.2.4. Up to v1.2.3 a failed bake (for example with a camera selected together with the mesh) left the material rewired while the export reported success. The material, selection and render settings are now restored in every case, and a failed bake stops the export with the reason.

"Reroute or NodeGroup crashes the export"
Fixed: the traverser walks through REROUTE and GROUP nodes transparently and skips dangling from_socket = None links.

"EEVEE preview throws AttributeError on use_bloom / use_ssr"
Fixed in v1.0.0: each EEVEE attribute is probed with hasattr before write, so the same code works on legacy EEVEE (3.x) and EEVEE Next (4.2+).

"Exported shader has empty values"
Fixed in v1.0.0: emitters now read IRInput.default_value and params instead of non-existent attributes.


12. Limitations

  • Multi-output Material (Surface + Displacement + Volume) — only the Surface socket is consumed; Displacement and Volume are ignored. This is the right behaviour for game-engine target materials.
  • Multiple Material Output nodes — the first one with is_active_output = True wins; if none is active, the first found is used. If you have separate Cycles and EEVEE outputs, mark the one you want for export as active.
  • Hair / Velvet / Anisotropic / SSS-only / Translucent BSDFs — currently fall back to baked-texture placeholders. Mix them with a Principled BSDF if you need them as upstream contributors; otherwise, the procedural baker flattens them to a usable texture.

13. Changelog

v1.2.4 — HDRP was never supported (the file has always been a URP graph): the option is now labelled so, the export says it, and these texts no longer promise an HDRP Lit target, packed maps or Unity 2022.3. toon materials now reach Unity with their bands. Cycles does not evaluate Shader To RGB, so the old bake produced one flat colour and a toon sphere rendered black in Unity; the lit colour is now baked first and run through your ramp, into one texture and an unlit graph (in Unity 6000.4 URP 99.8–99.9 % of the pixels land on the same band as in Blender). The bands are baked and do not follow Unity lights (section 10). An emission texture was written into the graph and connected to nothing; Emission shaders and a colour wired straight into Surface now export as Unity Unlit graphs. A failed bake left the material rewired and still reported success; everything is now restored, only the active mesh is baked, the export stops with the reason, and Undo works. Textures are pre-assigned in Unity through a .meta next to each PNG. A stray metallic_smoothness_engine.png is no longer written when nothing was packed.

v1.2.3 — the shader now arrives usable, not just compiling. Every texture property was declared as a normal map, so Unity showed “This texture is not marked as a normal map — Fix Now” on a plain colour texture; the type now follows what the texture is, calibrated against 253 texture properties in Unity's own shipped graphs. Texture properties were named after the Blender node rather than the image — all of them were “Image Texture”, so the exported PNG could not be matched to its slot and the shader came up with no texture applied; they now carry the image name. And the material had no controls at all: Base Color, Metallic, Smoothness and Alpha are now exposed as properties with your Blender values as defaults. Verified end to end — the graph is imported into a real Unity editor, a material is built, the textures are bound and the result is rendered and compared with the colour it should show.

v1.2.2 — the material you built is now the material that arrives. Only connected inputs used to be exported; values typed as numbers were dropped and replaced by defaults, so a metal with Metallic 1.0 and Roughness 0.2 reached Unity as Metallic 0.0 and Smoothness 0.5 and reached Unreal as an empty material — four of seven test materials had not a single expression in the file. Roughness is now converted to smoothness rather than renamed (0.2 becomes 0.8); without that a mirror metal arrived matte. On the Unreal side: every material was named M_Material and now carries its own name; a texture node with no image was written with an empty reference and wired to Normal, and a normal map now takes the image from the texture feeding it; an unconnected Normal is left alone instead of being pinned to a degenerate constant. Measured on seven materials: empty Unreal materials 4 → 0, wrong names 7 → 0, dead texture references 1 → 0.

v1.2.1 — every exported graph imported into Unity and then failed to compile, so every material was pink: invalid subscript 'TangentSpaceNormal' in the vertex program. The vertex Normal block was being written in tangent space because the exporter took the coordinate space from the slot class instead of from the block; the vertex block is object space and only the surface Normal block is tangent space. Measured on seven materials: 18 of 22 compiled stages failed before, 22 of 22 compile after, on Unity 6000.4 with URP. Re-export your materials — existing files need re-exporting, not repairing. The exported graphs are now compiled inside a real Unity editor on every build, pass by pass, which is what the previous check never did.

v1.2.0 — Unity files are now written in the format Unity actually reads. Earlier versions wrote a single JSON object with the nodes nested inside it. A real .shadergraph is a stream of separate objects that reference each other by id, the surface is described by blocks rather than by a master node, and the render pipeline is named by a target object. Files produced before this version were not importable by URP; re-export your materials and the new files will open.

Nodes this engine has no equivalent for are now baked to a texture instead of being dropped into the graph as a note. This matters most for toon setups: Shader To RGB is an EEVEE-only trick with nothing like it in Unity, so a toon material used to arrive as an empty graph with a comment. It now arrives as a baked map wired into Base Color.

Two crashes fixed on the way: channel packing raised an error as soon as there was anything to pack, and baking failed with an empty path when the .blend file had never been saved.

v1.1.1 — export refusals now name their cause. With no export folder chosen and an unsaved .blend file there is nowhere to write the shader; the add-on used to answer "Export failed. Check warnings above." and now says to choose a folder or save the file, and the panel warns before you press. Objects with several material slots: the active material is exported, as before, and the add-on now says so and names the number of slots.

v1.1.0

  • Stylised root shaders supported: Emission, Diffuse, Glossy, Glass, Transparent.
  • Mix Shader / Add Shader passthrough with dominant-branch selection.
  • NodeGroup auto-traversal via GROUP_OUTPUT — works with assets from BlenderKit / Poliigon / Quixel.
  • Diagnostic Conversion Report — accurate supported / unsupported counts plus a root_kind indicator.
  • Plain-English error messages with concrete fixes for Use Nodes disabled, missing Material Output, unconnected Surface.

v1.0.0

  • Initial release. Principled BSDF → Unity URP / HDRP / ShaderLab + Unreal T3D. Procedural baker, channel packing, viewport approximation, toon detector.

14. Support

For questions, bug reports, or feature requests please contact the seller through the marketplace messaging where you bought this add-on.


15. License

GPL-3.0. Standard for Blender add-ons. The license applies to the add-on code only — the shaders you generate with it are yours to ship in any commercial project.

$9.99

Have questions about this product?
Login to message

Details
Sales 20+
Rating
1 ratings
Published 7 months ago
Blender Version 4.2 - 5.2
Extension Type N/A
Render Engine Used Cycles, Eevee
License GPL