Overview

A powerful editor tool for converting materials between Unity's three render pipelines, now bundled as Texture Studio & Material Converter with built-in texture generation helpers:

• Built-in Render Pipeline

• Universal Render Pipeline (URP)

• High Definition Render Pipeline (HDRP)

Supports bidirectional conversion between any combination of these pipelines, intelligently mapping compatible properties and gracefully skipping incompatible ones.

Features

✅ Supported Conversions

All bidirectional conversions:

• Built-in ↔ URP

• Built-in ↔ HDRP

• URP ↔ HDRP

✅ Supported Shaders

Built-in:

• Standard

• Standard (Specular setup)

• Unlit/Texture

• Unlit/Color

• Unlit/Transparent

URP:

• Universal Render Pipeline/Lit

• Universal Render Pipeline/Simple Lit

• Universal Render Pipeline/Unlit

• Universal Render Pipeline/Baked Lit

• Universal Render Pipeline/Terrain/Lit

HDRP:

• HDRP/Lit

• HDRP/LitTessellation

• HDRP/Unlit

• HDRP/TerrainLit

✅ Property Mapping

The tool automatically maps compatible properties:

Textures:

• Base Color / Albedo / MainTex

• Normal Maps

• Emission Maps

• Metallic/Smoothness Maps

• Occlusion Maps

• Detail Maps

Colors:

• Base Color / Tint

• Emission Color

Properties:

• Metallic

• Smoothness / Glossiness

• Normal Scale / Bump Scale

• Occlusion Strength

• Alpha Cutoff

Render Settings:

• Surface Type (Opaque/Transparent)

• Render Queue (optional preservation)

✅ Smart Handling

• Skips incompatible properties - If target shader doesn't have equivalent, property is safely skipped

• Preserves texture scale/offset - Tiling and offset values maintained

• Optional backup creation - Creates .backup.mat files before conversion

• Batch processing - Convert hundreds of materials at once

• Detailed logging - Optional verbose output for debugging

• Texture generation helpers - Generate missing/optional maps from base textures (normal, height, occlusion, metallic/mask, emission, coat mask, bent normal, detail) with pipeline-aware packing and safe assignment

• Inspector utilities - Per-material generator and Hue Adjust with live preview/apply (feather slider only shown when Mask Only is on)

Installation

1. Keep the editor scripts under Assets/Arawn/TextureStudio/Editor/

2. Unity will automatically compile the editor scripts

3. Access via menu: Tools → Arawn → Texture Studio & Material Converter

4. (Optional) Configure custom shader property aliases in Project Settings → Texture Studio to auto-assign generated textures for non-standard shaders.

Usage

Basic Workflow

1. Open the tool: Tools → Arawn → Texture Studio & Material Converter

2. Select Source Pipeline: Choose current render pipeline (Built-in, URP, or HDRP)

3. Select Target Pipeline: Choose desired render pipeline

4. Choose Conversion Mode:

   • Selected Materials - Convert currently selected materials in Project window

   • Materials in Folder - Convert all materials in a specific folder (recursive)

   • All Project Materials - Convert every material in the project (⚠️ use cautiously)

5. Configure Options (optional):

   • Enable backup creation

   • Preserve render queue

   • Enable detailed logging

6. Click "Convert Shaders"

7. Review results in console

Example: Built-in to URP

1. Select source: Built-in
2. Select target: URP
3. Select materials in Project window
4. Click "Refresh Selection" to see selected materials
5. Enable "Create Backup" for safety
6. Click "Convert Shaders"
7. ✓ Materials now use URP/Lit shader with properties transferred

Example: Folder Conversion

1. Choose "Materials in Folder" mode
2. Drag a folder from Project window to "Target Folder" field
3. Tool shows count of materials found
4. Click "Convert Shaders"
5. ✓ All materials in folder (and subfolders) converted

Property Mapping Details

Texture Generation (Material Inspector)

Custom Shader Mappings (Project Settings)

• Open Project Settings → Texture Studio to define substring matches for your custom shaders and list the texture property names they use.

• Enter comma-separated names for each slot: Base, Normal, Height/Parallax, Metallic/Mask, Occlusion, Emission, Bent Normal (HDRP), Detail (HDRP), Coat Mask (HDRP).

• Use the provided presets (URP Lit, HDRP Lit) as a starting point, then adjust to your custom property names.

• Coat Mask: saves a separate coat texture and also updates Mask B when present.

• Bent Normal: bends normals toward occlusion; uses base gradients plus AO.

• Detail: DoG-style high-pass to keep only meaningful micro detail.

• Emission: chroma + luminance detection; Mask Only supports feather (slider shown only when Mask Only is on).

• Hue Adjust: live preview, Apply writes a new base texture next to the source; auto-assigns to all base map slots.

Built-in → URP

Built-in Property	URP Property	Notes
_MainTex	_BaseMap	Base color texture
_Color	_BaseColor	Tint color
_BumpMap	_BumpMap	Normal map (same)
_MetallicGlossMap	_MetallicGlossMap	Same encoding
_EmissionMap	_EmissionMap	Emission texture
_Glossiness	_Smoothness	Inverted in some cases
_Mode	_Surface	Surface type

Built-in → HDRP

Built-in Property	HDRP Property	Notes
_MainTex	_BaseColorMap	Base color texture
_Color	_BaseColor	Tint color
_BumpMap	_NormalMap	Different name
_MetallicGlossMap	_MaskMap	Different encoding!
_EmissionMap	_EmissiveColorMap	Emission texture
_Glossiness	_Smoothness	Property name

URP ↔ HDRP

Similar mapping as above, with appropriate conversions for:

• Base maps

• Normal maps

• Mask maps (R=Metallic, G=AO, B=Detail, A=Smoothness)

• Emission maps

Advanced Options

Create Backup

When enabled, creates .backup.mat copies of materials before conversion. Useful for:

• Testing conversions safely

• Reverting if needed

• Keeping original configurations

Preserve Render Queue

Maintains custom render queue values after shader conversion. Important for:

• Custom render order

• Transparency sorting

• Special rendering effects

Log Conversion Details

Enables verbose console logging showing:

• Each material converted

• Properties transferred

• Skipped properties

• Warnings and errors

Limitations & Known Issues

Property Encoding Differences

HDRP Mask Map:

• HDRP uses _MaskMap with R=Metallic, G=AO, B=Detail, A=Smoothness

• Built-in/URP use separate maps

• Automatic conversion is not perfect - may need manual adjustment

Smoothness/Glossiness:

• Different value ranges in some cases

• May need manual tweaking after conversion

Unsupported Properties

Properties without equivalents are automatically skipped:

• HDRP-specific: Anisotropy, Coat, Iridescence, Subsurface Scattering

• URP-specific: Some mobile optimizations

• Built-in-specific: Legacy parallax

Shader Variants

The tool converts to basic shader variants. If you need:

• Tessellation

• Special blending modes

• Advanced features

You may need to manually select correct shader variant after conversion.

Troubleshooting

"No equivalent shader found"

• Cause: Target render pipeline not installed

• Solution: Install URP/HDRP package via Package Manager

"Textures look wrong after conversion"

• Cause: Different texture encoding (especially HDRP mask maps)

• Solution: Manually reassign textures or adjust in material inspector

"Materials are pink after conversion"

• Cause: Shader not found or compile error

• Solution:

  • Ensure target pipeline package installed

  • Check for shader compilation errors

  • Reimport shaders if needed

"Properties not transferred correctly"

• Cause: Property name mismatch or incompatible types

• Solution:

  • Check console for warnings

  • Manually adjust properties

  • Enable "Log Conversion Details" to see what was skipped

Best Practices

Before Converting

1. ✅ Create a backup - Enable backup option or use version control

2. ✅ Test on few materials first - Don't convert entire project immediately

3. ✅ Verify target pipeline installed - Install URP/HDRP packages first

4. ✅ Decide optional HDRP maps - Height/Occlusion/Emission/Bent/Coat/Detail are utilities; enable only if your shader uses them

5. ✅ Check shader variants - Know which shaders you're using

During Conversion

1. ✅ Enable logging - Monitor what's happening

2. ✅ Convert in batches - Easier to verify results

3. ✅ Preserve render queue - Unless you want defaults

After Converting

1. ✅ Verify visuals - Check materials in Scene view

2. ✅ Check console - Review warnings

3. ✅ Adjust as needed - Some properties may need manual tweaking; generate optional maps only where useful

4. ✅ Test in play mode - Ensure runtime behavior correct

Script Extension

Adding Custom Shader Mappings

Edit GetTargetShaderName() method to add custom shader conversions:

// Example: Custom shader conversion
if (sourceShaderName.Contains("MyCustomShader"))
    return "MyTargetPipeline/MyCustomShader";

Adding Custom Property Mappings

Add to PropertyMaps class:

public static readonly Dictionary<string, string> MyCustomMap = new Dictionary<string, string>
{
    { "_CustomProperty", "_TargetProperty" },
    // ... more mappings
};

Technical Details

How It Works

1. Shader Mapping: Identifies equivalent shader in target pipeline

2. Property Extraction: Reads all properties from source material

3. Property Mapping: Maps source properties to target equivalents

4. Shader Assignment: Assigns new shader to material

5. Property Transfer: Sets mapped properties on new shader

6. Cleanup: Preserves render queue, marks dirty, saves

Property Type Support

• ✅ Colors (Color)

• ✅ Vectors (Vector4)

• ✅ Floats (Float, Range)

• ✅ Textures (Texture2D)

• ✅ Texture Scale/Offset

Performance

• Processes ~100 materials per second (typical)

• Progress bar shows conversion progress

• Asynchronous not needed for typical projects

Support

For issues or feature requests:

1. Check console for detailed error messages

2. Verify target pipeline installed correctly

3. Test with backup enabled first

4. Review property mapping tables above

E-Mail: [e-mail]

Discord: https://discord.gg/MPhMKtSMUZ