Texture issue after save

2025-09-19 15:32 UTC gpt-5-thinking Open in ChatGPT ↗

I have this script that creates a texture from Gradient and passed on to a Texture2D property in material created in shadergraph. It seems to work just fine. Except that everytime i save the scene everything turns white. Could there be an issue with the way the texture is passed on to shadergraph and if yes how can i fix it?

using System.Collections; using System.Collections.Generic; using UnityEngine; using System;

public class GradientMapper : MonoBehaviour { [Header(“Gradient map parameters”)] public string mapperName; public Vector2Int gradientMapDimensions = new Vector2Int(128, 32); [GradientUsage(true)] public Gradient gradient;

[Header("Material parameters")]
private SpriteRenderer spriteRenderer;
public Material mat;
public string texture_name;

//[HideInInspector]
public Texture2D texture;

private void Start()
{

    texture = new Texture2D(gradientMapDimensions.x, gradientMapDimensions.y);
    texture.wrapMode = TextureWrapMode.Clamp;
    texture.filterMode = FilterMode.Point;
    for (int x = 0; x < gradientMapDimensions.x; x++)
    {
        Color color = gradient.Evaluate((float)x / (float)gradientMapDimensions.x);
        for (int y = 0; y < gradientMapDimensions.y; y++)
        {
            texture.SetPixel(x, y, color);
        }
    }
    texture.Apply();
    if (mat.HasProperty(texture_name))
    {
        mat.SetTexture(texture_name, texture);
    }
}


private void OnValidate()
{
    Debug.Log("-------------VALIDATE-----------");
    if(texture_name == String.Empty) /*|| mat ==null)*/ return;
    if (gradient.colorSpace != ColorSpace.Linear) gradient.colorSpace = ColorSpace.Linear;

    if (texture == null)
    {
        texture = new Texture2D(gradientMapDimensions.x, gradientMapDimensions.y, TextureFormat.RGBA32, false)
        {
            wrapMode = TextureWrapMode.Clamp,

        };


    }

    for (int x = 0; x < gradientMapDimensions.x; x++)
    {
        Color color = gradient.Evaluate((float)x / (float)gradientMapDimensions.x);

        for (int y = 0; y < gradientMapDimensions.y; y++)
        {
            texture.SetPixel(x, y, color);
        }
    }
    texture.Apply();

    if (mat == null) return;
    if (mat.HasProperty(texture_name))
    {
        mat.SetTexture(texture_name, texture);
    }
}

}

Yep — this is a classic “white after save” gotcha.
What’s happening:

You’re creating a runtime Texture2D (not an asset).
You then assign it directly to a Material asset (mat.SetTexture(...)).
When you save the scene, Unity serializes assets. A Material asset isn’t allowed to keep a reference to a non-asset (your in-memory Texture2D), so that reference is cleared. Your shader’s texture property becomes null → Shader Graph falls back to its default white texture.

There are two good fixes. Pick one.

Fix A — Set the texture on the renderer, not on the material asset (recommended)

Use a MaterialPropertyBlock (or a duplicated instance material) so you never touch the project Material asset. This keeps everything stable across saves and play mode.

using UnityEngine;

[ExecuteAlways]
public class GradientMapper : MonoBehaviour
{
    [Header("Gradient map parameters")]
    public Vector2Int gradientMapDimensions = new Vector2Int(128, 32);
    [GradientUsage(true)] public Gradient gradient;

    [Header("Shader property")]
    public string textureName = "_GradientTex";

    [HideInInspector] public Texture2D texture;

    Renderer _renderer;
    MaterialPropertyBlock _mpb;
    int _propId;

    void OnEnable()
    {
        _renderer = GetComponent<Renderer>();
        if (_renderer == null) return;

        _mpb = _mpb ?? new MaterialPropertyBlock();
        _propId = Shader.PropertyToID(string.IsNullOrEmpty(textureName) ? "_MainTex" : textureName);

        EnsureTexture();
        UpdateTexturePixels();
        PushToRenderer();
    }

    void OnValidate()
    {
        if (!Application.isPlaying && _renderer == null)
            _renderer = GetComponent<Renderer>();

        _propId = Shader.PropertyToID(string.IsNullOrEmpty(textureName) ? "_MainTex" : textureName);

        EnsureTexture();
        UpdateTexturePixels();
        PushToRenderer();
    }

    void EnsureTexture()
    {
        if (texture == null || texture.width != gradientMapDimensions.x || texture.height != gradientMapDimensions.y)
        {
            // In linear projects you may want linear = true
            texture = new Texture2D(gradientMapDimensions.x, gradientMapDimensions.y, TextureFormat.RGBA32, false, true);
            texture.wrapMode = TextureWrapMode.Clamp;
            texture.filterMode = FilterMode.Point;
            texture.name = "GradientRuntimeTex";
        }
    }

    void UpdateTexturePixels()
    {
        var w = gradientMapDimensions.x;
        var h = gradientMapDimensions.y;
        var pixels = new Color[w * h];

        for (int x = 0; x < w; x++)
        {
            var c = gradient.Evaluate((float)x / (w - 1));
            for (int y = 0; y < h; y++)
                pixels[y * w + x] = c;
        }

        texture.SetPixels(pixels);
        texture.Apply(false); // keep readable in editor; set true in builds if you want to free CPU copy
    }

    void PushToRenderer()
    {
        if (_renderer == null || texture == null) return;
        _renderer.GetPropertyBlock(_mpb);
        _mpb.SetTexture(_propId, texture);
        _renderer.SetPropertyBlock(_mpb);
    }
}

Why this works: a MaterialPropertyBlock lives on the renderer and is not serialized as an asset reference to your in-memory texture, so saving the scene won’t wipe it.

Alternative: instead of MPB, you can do renderer.material = Instantiate(renderer.sharedMaterial); and set the texture on that instance. Just don’t modify the project asset.

Fix B — Make the generated Texture2D a real asset (so the Material asset can keep it)

If you do want the Material asset to hold the texture permanently, save the texture into the Asset Database (Editor-only code):

#if UNITY_EDITOR
using UnityEditor;
#endif
...
void SaveTextureAsSubAssetOfMaterial(Material mat, Texture2D tex)
{
#if UNITY_EDITOR
    if (mat == null || tex == null) return;
    string matPath = AssetDatabase.GetAssetPath(mat);
    if (string.IsNullOrEmpty(matPath)) return;

    // Add once as a sub-asset of the material (or save to a dedicated path)
    if (!AssetDatabase.Contains(tex))
    {
        tex.name = $"{mat.name}_Gradient";
        AssetDatabase.AddObjectToAsset(tex, mat);
    }

    EditorUtility.SetDirty(tex);
    EditorUtility.SetDirty(mat);
    AssetDatabase.SaveAssets();
#endif
}

Then call SaveTextureAsSubAssetOfMaterial(mat, texture); after generating it, and keep using mat.SetTexture(...). Because the texture is now an actual asset, the reference survives saves.

Small additional notes

Use string.IsNullOrEmpty(texture_name) instead of texture_name == String.Empty.
Consider the linear parameter in the Texture2D ctor to match your project color space (new Texture2D(w,h,RGBA32,false, true) for linear).
Fill pixels with SetPixels (as above) rather than SetPixel in nested loops for speed.
If you stick with MPB, you don’t need to keep a Material mat field at all.

If you switch to either Fix A or Fix B, the “turns white when I save” issue should disappear.

Short answer: yes—if you turn the generated Texture2D into a real asset, you can keep updating that same asset whenever the gradient changes. It won’t turn white on save. And you can avoid clutter by storing it as a sub-asset of the material (so nothing new shows up in the Project window as a separate file).

Here’s a compact, drop-in pattern for Option B that (1) reuses the same asset every time and (2) keeps it tucked under the material:

#if UNITY_EDITOR
using UnityEditor;
#endif
using UnityEngine;

[ExecuteAlways]
public class GradientMapper : MonoBehaviour
{
    public string mapperName = "Gradient";
    public Vector2Int size = new Vector2Int(128, 32);
    [GradientUsage(true)] public Gradient gradient;

    [Header("Material + ShaderGraph")]
    public Material mat;
    public string textureName = "_GradientTex";

    Texture2D texture;
    int _propId;

    void OnEnable()
    {
        _propId = Shader.PropertyToID(string.IsNullOrEmpty(textureName) ? "_MainTex" : textureName);
        EnsureTextureAsset();
        RebuildPixels();
        PushToMaterial();
    }

    void OnValidate()
    {
        _propId = Shader.PropertyToID(string.IsNullOrEmpty(textureName) ? "_MainTex" : textureName);
        EnsureTextureAsset();
        RebuildPixels();
        PushToMaterial();
    }

    void RebuildPixels()
    {
        if (texture == null) return;

        // Resize if dimensions changed (Unity 2021+ has Reinitialize; otherwise use Resize)
#if UNITY_2021_2_OR_NEWER
        if (texture.width != size.x || texture.height != size.y)
            texture.Reinitialize(size.x, size.y);
#else
        if (texture.width != size.x || texture.height != size.y)
            texture.Resize(size.x, size.y);
#endif
        var w = size.x; var h = size.y;
        var pixels = new Color[w * h];
        for (int x = 0; x < w; x++)
        {
            var c = gradient.Evaluate((float)x / (w - 1));
            for (int y = 0; y < h; y++) pixels[y * w + x] = c;
        }
        texture.SetPixels(pixels);
        texture.wrapMode = TextureWrapMode.Clamp;
        texture.filterMode = FilterMode.Point;
        texture.Apply(false, false);

#if UNITY_EDITOR
        EditorUtility.SetDirty(texture);
#endif
    }

    void PushToMaterial()
    {
        if (mat == null || texture == null) return;
        if (mat.HasProperty(_propId)) mat.SetTexture(_propId, texture);
#if UNITY_EDITOR
        EditorUtility.SetDirty(mat);
        AssetDatabase.SaveAssets();
#endif
    }

    void EnsureTextureAsset()
    {
        if (mat == null) return;

#if UNITY_EDITOR
        // 1) Look for an existing sub-asset under the material
        var matPath = AssetDatabase.GetAssetPath(mat);
        if (!string.IsNullOrEmpty(matPath))
        {
            var wantedName = string.IsNullOrEmpty(mapperName) ? $"{mat.name}_Gradient" : mapperName;
            foreach (var o in AssetDatabase.LoadAllAssetsAtPath(matPath))
                if (o is Texture2D t && t.name == wantedName) { texture = t; return; }

            // 2) Not found → create once as a sub-asset of the material (no Project clutter)
            texture = new Texture2D(size.x, size.y, TextureFormat.RGBA32, false, true)
            {
                name = wantedName,
                wrapMode = TextureWrapMode.Clamp,
                filterMode = FilterMode.Point
            };
            AssetDatabase.AddObjectToAsset(texture, mat);
            EditorUtility.SetDirty(mat);
            AssetDatabase.SaveAssets();
        }
#else
        // In player builds you cannot create assets; consider Option A (MaterialPropertyBlock) at runtime.
        if (texture == null)
            texture = new Texture2D(size.x, size.y, TextureFormat.RGBA32, false, true);
#endif
    }
}

Why this solves both concerns

Persists & updates: You always retrieve the same sub-asset by name and write new pixels to it. The material keeps its reference, so saving the scene won’t wipe it.
No clutter: Because it’s a sub-asset of the material, you won’t see extra loose files in your Project. If you select the material, you’ll see the texture listed under it.

Notes

Editor-only asset creation: this works in the Editor. In builds you can’t write assets; if you need runtime generation there, use Option A (MaterialPropertyBlock or an instantiated renderer material).
If multiple GradientMappers target the same material/property, give each a unique mapperName (or intentionally reuse one to share a single texture).
Keep using the property reference name from Shader Graph (e.g. _GradientTex), not the display name.

You can do that—have the editor re-apply all gradients right after a save—but think of it as a band-aid. It won’t make the Material asset remember a non-asset texture across domain reloads / project reopen. The robust fixes are still (A) MaterialPropertyBlock / instanced material, or (B) make the texture an asset.

If you still want the “auto-reset on Save” (plus a manual button), here’s a tidy way to do it.

1) Add a callable rebuild method to your component

Put this inside your GradientMapper so the editor script can trigger it:

#if UNITY_EDITOR
using UnityEngine;

public partial class GradientMapper
{
    [ContextMenu("Rebuild & Apply (Editor)")]
    public void RebuildAndApplyEditor()
    {
        if (string.IsNullOrEmpty(texture_name)) return;

        // ensure texture exists & has correct size
        if (texture == null || texture.width != gradientMapDimensions.x || texture.height != gradientMapDimensions.y)
        {
            texture = new Texture2D(gradientMapDimensions.x, gradientMapDimensions.y, TextureFormat.RGBA32, false, true);
            texture.wrapMode = TextureWrapMode.Clamp;
            texture.filterMode = FilterMode.Point;
            texture.name = "GradientRuntimeTex";
        }

        // fill pixels (faster than SetPixel in two nested loops)
        int w = gradientMapDimensions.x, h = gradientMapDimensions.y;
        var pixels = new Color[w * h];
        for (int x = 0; x < w; x++)
        {
            var c = gradient.Evaluate((float)x / (w - 1));
            for (int y = 0; y < h; y++)
                pixels[y * w + x] = c;
        }
        texture.SetPixels(pixels);
        texture.Apply(false, false);

        // re-apply to your material (⚠️ this is the fragile bit)
        if (mat != null && mat.HasProperty(texture_name))
            mat.SetTexture(texture_name, texture);
    }
}
#endif

Tip: If you switch to MaterialPropertyBlock instead of touching the material asset, this method can push to the renderer’s MPB instead—no white flashes and no persistence issues.

Create a new file under an Editor/ folder, e.g. Editor/GradientMapperAutoReset.cs:

#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;

[InitializeOnLoad]
public static class GradientMapperAutoReset
{
    static GradientMapperAutoReset()
    {
        // After *any* scene is saved, re-apply gradients on the next editor tick
        EditorSceneManager.sceneSaved += _ =>
        {
            EditorApplication.delayCall += ResetAllInOpenScenes;
        };
    }

    [MenuItem("Tools/Gradient Mapper/Reset All In Open Scenes")]
    public static void ResetAllInOpenScenes()
    {
        var mappers = Object.FindObjectsByType<GradientMapper>(FindObjectsSortMode.None);
        foreach (var gm in mappers)
        {
            if (gm == null || !gm.isActiveAndEnabled) continue;
            gm.RebuildAndApplyEditor();
        }
    }
}
#endif

How this behaves:

Every time you save a scene, Unity clears the non-asset texture reference on the Material asset.
This hook runs after the save and immediately re-assigns your runtime texture, so things stop being white.
It does not persist through project reloads/domain reloads. On recompile/reopen, you’ll still need either this hook to run again (it will when you save) or a more permanent fix (A or B).

Caveats (worth reading)

If you have Auto Save enabled for assets, repeatedly touching the Material asset can cause it to get dirty again and be saved again (Unity will drop the non-asset reference again). Using MPB avoids this loop entirely.
If you ever need the gradient texture to survive closing/reopening the project, go with Option B (sub-asset). It eliminates the need for any of these editor hooks and avoids project clutter by nesting the texture under the material.
If you stick with the material-assignment approach, consider also calling your rebuild in OnEnable with [ExecuteAlways] so it re-applies after domain reloads.

If you want, I can refactor your GradientMapper to a clean MPB version (no editor hooks needed) or the sub-asset version (persistent, no clutter).

Great question!

What is a “property ID” in Unity?

Shaders expose parameters (textures, colors, floats) by property name—strings like _MainTex, _BaseMap, _Color, _GradientTex.
Unity lets you convert that string into an integer handle with Shader.PropertyToID(...). The integer:

avoids repeated string hashing/lookup (slightly faster, fewer GC allocations),
works with the int overloads of Material/MaterialPropertyBlock APIs (SetTexture(int id, ...), HasProperty(int id), etc.),
should not be serialized or assumed stable across editor sessions—just compute it at runtime and cache it.

What your line does

_propId = Shader.PropertyToID(string.IsNullOrEmpty(textureName) ? "_MainTex" : textureName);

If textureName is empty/null, it falls back to _MainTex (the historic “main texture” name on many shaders).
Otherwise it uses whatever you typed in textureName.

The resulting int goes into _propId, which you then use like:

if (mat.HasProperty(_propId))
    mat.SetTexture(_propId, texture);

Important details when using Shader Graph

In Shader Graph, every exposed property has a Reference field (e.g. _GradientTex).
Use that exact reference string—not the display name you see in the Blackboard.
_MainTex is a good default only if your shader actually uses _MainTex.
- URP Lit uses _BaseMap as its base-color texture.
- Sprite shaders and many legacy shaders use _MainTex. So it’s safer to enter your property name explicitly (e.g. _GradientTex) instead of relying on a default.

Cache the common IDs to avoid calling PropertyToID repeatedly:

static readonly int MainTexID = Shader.PropertyToID("_MainTex");
int _propId;

void RefreshPropId()
{
    _propId = string.IsNullOrEmpty(textureName)
        ? MainTexID
        : Shader.PropertyToID(textureName);
}

Quick checklist to avoid “nothing happens”:

Confirm the Shader Graph property’s Reference (leading underscore matters).
Make sure the Material has that property (mat.HasProperty(_propId)).
If you’re using URP Lit, consider _BaseMap for the color texture, or better, create a dedicated Texture2D property in the graph (e.g. _GradientTex) and use that.

That’s all a property ID is—just a speedy, typo-proof handle to the shader property you want to set.