Unity For TAs

The Concept Map

Render Pipelines: The First Question On Any Unity Project

Unity has three render pipelines, and everything visual depends on which one the project uses - shaders, materials, and half the tutorials on the internet are pipeline-specific. URP (Universal) is the modern default: scales from mobile to PC, where most new projects live. HDRP is the high-end path - closest to Unreal's out-of-box look, PC/console only. Built-in is the legacy pipeline still running many live games; its materials don't port forward automatically. First thing you do on joining any Unity project: find out the pipeline, because a shader authored for the wrong one renders magenta - Unity's version of a compile error, and your first debugging classic.

Scripting: C# Instead Of Python

The honest adjustment: Unity's automation language is C#, not Python. The good news - editor tooling in C# is less ceremony than you fear, and your pipeline instincts port directly. The batch-renamer, in Unity dialect:

using UnityEditor;
using UnityEngine;

public static class BatchRename
{
 [MenuItem("TA Tools/Rename Selected To Convention")]
 static void Run()
 {
 foreach (var obj in Selection.objects)
 {
 string path = AssetDatabase.GetAssetPath(obj);
 string name = obj.name.Replace(" ", "_");
 if (!name.StartsWith("SM_")) name = "SM_" + name;
 AssetDatabase.RenameAsset(path, name); // refs update, like UE
 }
 Debug.Log($"renamed {Selection.objects.Length} assets");
 }
}

Drop that in any folder named Editor/ and a menu item appears - no build step, no plugin registration. That folder-name-is-behaviour convention is very Unity: learn the magic folders (Editor, Resources, StreamingAssets) early. Python does exist via packages for offline pipeline work, but in-editor, C# is the language of the land. Start with one small editor task and compare it with the Python equivalent you already know.

Use AssetPostprocessor For Shared Import Rules

Unity's import pipeline is scriptable per-event: hooks that run on every asset import, project-wide. This is where naming conventions, texture settings, and metadata get enforced automatically - the pattern our whole pipeline philosophy points at:

using UnityEditor;

class TAImportRules : AssetPostprocessor
{
 void OnPreprocessTexture()
 {
 var importer = (TextureImporter)assetImporter;
 string name = System.IO.Path.GetFileName(assetPath);

 if (name.Contains("_N")) // normal maps: by convention
 importer.textureType = TextureImporterType.NormalMap;
 if (name.Contains("_ORM") || name.Contains("_Mask"))
 importer.sRGBTexture = false; // data is linear. always.
 }

 void OnPreprocessModel()
 {
 var importer = (ModelImporter)assetImporter;
 importer.useFileScale = true; // trust the FBX units
 importer.importCameras = importer.importLights = false;
 }
}

Every texture named *_ORM imports linear, forever, for everyone, with no human remembering anything. If you write one piece of C# as a Unity TA, write this one.

Things To Check When Moving From Unreal

• Y is up and the handedness differs. Unity: Y-up, left-handed, metres. Full conversion table on Units & Axes - your Blender export preset needs a Unity variant, not a copy.
• .meta files preserve asset identity. Every asset has a sidecar .meta carrying its GUID - references point at the GUID, not the path. Move a file without its .meta (in Explorer instead of the editor) and every reference to it dies. Commit .meta files to version control, always; this is the Unity equivalent of redirectors, except less forgiving.
• Linear vs gamma colour space is a project setting (older mobile projects sometimes still gamma). All the sRGB debugging knowledge applies, with one extra "which mode is this project in" question on top.
• No material instances hierarchy. Coming from UE's master/instance discipline, Unity's flat materials feel loose - the equivalent structure is fewer shaders with well-designed properties, plus Material Variants (newer Unity) for the override chain.
• The frame debugger is your shader-complexity view. Window -> Analysis -> Frame Debugger steps through draw calls one by one; RenderDoc integrates cleanly for the deep dives.