Home/ Questions/Q 39522
In Process

askthedev.com Latest Questions

Asked: 2025-05-09T20:14:00+05:30

Why does enabling and disabling material emission in Unity revert back upon saving the scene?

I’ve been working on a project in Unity where I want to control the glow effect on my materials, and I thought I had it figured out. I set up this simple script called `GlowEffectHandler` which lets me enable or disable material emissions directly from the inspector. Initially, everything seems to be working perfectly. I toggle the emission setting on and off, and the material glow responds immediately as I would expect.

Here’s the catch: whenever I save the scene, the emission setting always reverts back to being enabled, regardless of what I set in the inspector. At first, I thought it might be something I was missing in my script, but after some digging, I’m not so sure.

Here’s the core of my script for context:

“`csharp
using UnityEngine;

public class GlowEffectHandler : MonoBehaviour
{
[SerializeField] private Material material;
[SerializeField] private bool isEmissionEnabled;

private void OnValidate()
{
if(isEmissionEnabled)
{
material.EnableKeyword(“_EMISSION”);
}
else
{
material.DisableKeyword(“_EMISSION”);
}
}
}
“`

I’ve been using the `OnValidate()` method to toggle the emission based on the `isEmissionEnabled` variable. It works beautifully while I’m actively editing. I can see the changes in the editor right away! However, as soon as I hit save and reopen the scene, poof! The emission is back on. I’ve tried several workarounds but no luck so far.

Is there something I’m overlooking in Unity or perhaps a best practice that I’m not aware of? I’ve checked if the material instance is being manipulated correctly and it seems like it is, so why would saving the scene affect the emission keyword? It feels like I’m going in circles here.

Any insights? Am I missing some critical step or maybe there’s a quirk with how materials are handled in Unity? Would really appreciate any tips or suggestions on how to get the desired behavior so that saving doesn’t mess with my emission settings!

Share

    Leave an answer

    You must login to add an answer.

    Need An Account,

    2 Answers

    1. It sounds like you’re running into a common issue with how Unity handles material properties. The thing with the `OnValidate()` method is that while it works when you’re in edit mode, it doesn’t save your settings to the actual material when you save the scene. This is why your emission setting keeps reverting back.

      One possible way to make this work is by using a combination of `OnEnable()` and `Awake()`. Instead of only toggling the emission in `OnValidate()`, you might want to store the emission state in a more permanent way, such as updating the material properties during those lifecycle methods.

      Here’s a modified version of your script that might help:

          
    using UnityEngine;

    public class GlowEffectHandler : MonoBehaviour
    {
        [SerializeField] private Material material;
        [SerializeField] private bool isEmissionEnabled;

        private void Awake()
        {
            SetEmission(isEmissionEnabled);
        }

        private void OnValidate()
        {
            SetEmission(isEmissionEnabled);
        }

        private void SetEmission(bool enabled)
        {
            if (enabled)
            {
                material.EnableKeyword("_EMISSION");
            }
            else
            {
                material.DisableKeyword("_EMISSION");
            }
        }
    }

      After making this change, make sure to save the scene and then check the settings. It should ideally maintain the emission state as you want. Another thing to keep in mind is that if you’re using a shared material, any changes you make affect all objects using that material. If that’s the case, consider creating a unique material instance just for your object, which will help maintain the desired glow effect independently.

      Hope this helps you out! Good luck with your project!

    2. In Unity, one subtle but critical consideration when manipulating materials at runtime or in the editor is whether you are working with a shared or material instance. When you directly alter a material’s properties, like enabling or disabling emission through material.EnableKeyword("_EMISSION"), you’re editing the shared material asset itself, causing changes to propagate globally and possibly revert unexpectedly upon saving the scene. Unity typically resets material keywords and properties when reloading or saving scenes, because keywords alone don’t automatically serialize with scene data. Additionally, the OnValidate() method is called by Unity’s editor frequently, including on loading, recompiling scripts, or asset database refreshes, potentially leading to unintended behavior or inconsistent initial states.

      To resolve this issue effectively, consider creating a material instance at runtime or in editor mode to ensure that changes persist only where intended. You can do this by accessing Renderer.material instead of the shared material, or use MaterialPropertyBlock to apply emission and other shader properties without altering the original asset. If you’d like emission settings to persist reliably in the editor between saves, explicitly setting the emission properties with material.SetColor("_EmissionColor", yourColor), followed by using EditorUtility.SetDirty() on the associated serialized material asset, can ensure Unity correctly serializes your modifications. This combination ensures consistent and predictable material emission behavior, preventing emission state resets when saving or reloading scenes.