Enum to float conversion

2025-03-27 16:42 UTC o3-mini-high Open in ChatGPT ↗

I have a Unity animation track. I am animating an enum property and I want to actually read the keyframe values from a script. however, when I read them they are converted to floats and are actually extremely small values like: 4.203895E-45 1.401298E-45 2.802597E-45 4.203895E-45

etc etc.

I suspect some weird int to float type encoding bullshit is going on. can you help me?

my enum is this:

    public enum Output
    {
                      Diffusion,
                      SDF,
                      History ,
                      Threshold ,
                      Edge_Detection
    }

This value 4.203895E-45 corresponds to “Threshold”, the value with integer 3. can you figure out the pattern?

Yes, exactly. Unity is not converting the integer value to the corresponding float value (like 3.0), but rather it is using the underlying bit pattern of the integer as a float.

In IEEE 754, the smallest positive subnormal float is approximately 1.401298E-45. When you “cast” the integer value to a float at the bit level, you get:

0 → 0.0f
1 → 1.401298E-45 (bit pattern 0x00000001)
2 → 2.802597E-45 (bit pattern 0x00000002)
3 → 4.203895E-45 (bit pattern 0x00000003)
4 → 5.604994E-45 (bit pattern 0x00000004)

So, the value 4.203895E-45 corresponds to the integer 3, which is your enum value Threshold.

This “weird” conversion is simply because Unity is storing the enum’s integer values in a float field, and the bit pattern isn’t converted in the way you might expect (e.g., 3 becoming 3.0f). Instead, it’s interpreted directly as the float whose bit pattern equals the integer value.

You can convert the float back to the enum by extracting its underlying integer bit pattern and then casting that integer to your enum type. For example, you could do something like this in C#:

using System;

public enum Output
{
    Diffusion,      // 0
    SDF,            // 1
    History,        // 2
    Threshold,      // 3
    Edge_Detection  // 4
}

public static class EnumConversionHelper
{
    public static Output FloatToEnum(float f)
    {
        // Extract the raw integer bits from the float
        int intValue = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
        return (Output)intValue;
    }

    // Alternatively, a generic version for any enum type:
    public static TEnum FloatToEnum<TEnum>(float f) where TEnum : Enum
    {
        int intValue = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
        return (TEnum)Enum.ToObject(typeof(TEnum), intValue);
    }
}

Explanation

Bit Conversion:
BitConverter.GetBytes(f) converts the float to its byte representation. Then BitConverter.ToInt32(..., 0) reads those bytes as an integer. This integer represents the original enum’s integer value stored as a float (e.g., 4.203895E-45 becomes 3).
Casting to Enum:
Once you have the integer, you can cast it directly to your enum type (Output) which will give you the corresponding enum value (in this case, Threshold).

This approach works because Unity is storing your enum values as floats by preserving the bit pattern of the underlying integer.

What if I only know the type via reflection, and thus can’t use it in advance in the generic function call, but i need to pass it as an argument?

    public static TEnum FloatToEnum<TEnum>(float f) where TEnum : Enum
    {
        var intValue = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
        return (TEnum)Enum.ToObject(typeof(TEnum), intValue);
    }

When you only know the enum type at runtime, you can write a non-generic helper method that takes a Type parameter. That method can then use Enum.ToObject to perform the conversion. For example:

public static object FloatToEnum(Type enumType, float f)
{
    if (!enumType.IsEnum)
        throw new ArgumentException("Provided type must be an enum.", nameof(enumType));

    int intValue = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
    return Enum.ToObject(enumType, intValue);
}

Explanation

Type Check:
The method checks that the provided type is an enum. If it’s not, it throws an exception.
Bit Conversion:
The float is converted to its underlying integer bit representation with BitConverter.ToInt32(BitConverter.GetBytes(f), 0).
Enum Conversion:
The Enum.ToObject method creates an enum object of the specified type with the corresponding integer value.

Usage

If you have a Type at runtime (for example, obtained via reflection), you can use the function like this:

Type myEnumType = typeof(Output); // This could be obtained dynamically.
float floatValue = 4.203895E-45f;
object enumValue = FloatToEnum(myEnumType, floatValue);

// If you need to work with the enum value strongly typed later, you can cast it:
Output myEnum = (Output)enumValue;

This approach lets you convert the float back into the proper enum value even when you only know the enum type at runtime.