JacksonDunstan.com

using System;
using System.Runtime.InteropServices;
using System.Text;
using UnityEngine;
 
[StructLayout(LayoutKind.Explicit)]
struct UintFloatUnion
{
    [FieldOffset(0)] public uint Uint;
    [FieldOffset(0)] public float Float;
}
 
class TestScript : MonoBehaviour
{
    void Start()
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= 23; ++i)
        {
            uint u = 0b00111111100000000000000000000000; // == 1.0
            u |= (1u << i) - 1; // Change the least significant 'i' bits to 1
 
            // Reinterpret as float
            UintFloatUnion ufu;
            ufu.Float = 0;
            ufu.Uint = u;
            float f = ufu.Float;
 
            if (i < 10)
            {
                sb.Append(' ');
            }
            sb.Append(i);
            sb.Append(": ");
            sb.Append(f.ToString("0." + new string('0', 30)));
            sb.Append('n');
        }
        print(sb.ToString());
    }
}

// Read the integer value stored in the least-signficant 3 bits
float myVal = ...;
uint readVal = FloatBitStealing.ReadStolen(myVal, 3);
 
// Read the float value with the least-signficant 3 bits set to zero
float myVal = ...;
float myValCleared = FloatBitStealing.ReadFloatCleared(myVal, 3);
 
// Write srcVal to destVal without changing the least-significant 3 bits
float srcVal = ...;
float destVal = ...;
float writtenVal = FloatBitStealing.Write(srcVal, destVal, 3);

/// <summary>
/// Utility functions for working with <see cref="float"/> values that have some
/// of their least-signficant bits "stolen" by storing another value there.
/// </summary>
///
/// <author>
/// Jackson Dunstan, https://JacksonDunstan.com/articles/5365
/// </author>
///
/// <license>
/// MIT
/// </license>
public static class FloatBitStealing
{
    /// <summary>
    /// Utility to change the type of a <see cref="float"/> to a
    /// <see cref="uint"/> or visa versa.
    /// </summary>
    [System.Runtime.InteropServices.StructLayout(
        System.Runtime.InteropServices.LayoutKind.Explicit)]
    private struct UintFloatUnion
    {
        /// <summary>
        /// <see cref="uint"/> value of the memory
        /// </summary>
        [System.Runtime.InteropServices.FieldOffset(0)] public uint Uint;
 
        /// <summary>
        /// <see cref="float"/> value of the memory
        /// </summary>
        [System.Runtime.InteropServices.FieldOffset(0)] public float Float;
    }
 
    /// <summary>
    /// Read the value with the least-signficant bits cleared to zero
    /// </summary>
    /// 
    /// <param name="f">
    /// Value to read from
    /// </param>
    /// 
    /// <param name="numStolenBits">
    /// Number of least-signficant bits to clear to zero
    /// </param>
    /// 
    /// <returns>
    /// The given value with the given number of least-signficant bits cleared
    /// to zero
    /// </returns>
    public static float ReadFloatCleared(float f, int numStolenBits)
    {
        // 1s for all stolen bits
        uint stolenMask = (1u << numStolenBits) - 1;
 
        UintFloatUnion ufu;
        ufu.Uint = 0;
        ufu.Float = f;
        ufu.Uint = ufu.Uint & ~stolenMask;
        return ufu.Float;
    }
 
    /// <summary>
    /// Read the least-signficant bits
    /// </summary>
    /// 
    /// <param name="f">
    /// Value to read from
    /// </param>
    /// 
    /// <param name="numStolenBits">
    /// Number of least-signficant bits to read
    /// </param>
    /// 
    /// <returns>
    /// The given number of least-signficant bits of the given value
    /// </returns>
    public static uint ReadStolen(float f, int numStolenBits)
    {
        // 1s for all stolen bits
        uint stolenMask = (1u << numStolenBits) - 1;
 
        UintFloatUnion ufu;
        ufu.Uint = 0;
        ufu.Float = f;
        return ufu.Uint & stolenMask;
    }
 
    /// <summary>
    /// Write a value to an existing value without overwriting its
    /// least-signficant bits
    /// </summary>
    /// 
    /// <param name="src">
    /// Value to write
    /// </param>
    /// 
    /// <param name="dest">
    /// Value to write to
    /// </param>
    /// 
    /// <param name="numStolenBits">
    /// Number of least-signficant bits to not overwrite
    /// </param>
    /// 
    /// <returns>
    /// The most-signficant <paramref name="numStolenBits"/> bits of the given
    /// <paramref name="src"/> value combined with the least-signficant bits of
    /// the given <paramref name="dest"/> value.
    /// </returns>
    public static float Write(float src, float dest, int numStolenBits)
    {
        // 1s for all stolen bits
        uint stolenMask = (1u << numStolenBits) - 1;
 
        // Get the not-stolen bits of 'src', which are the most-signficant bits
        UintFloatUnion ufu;
        ufu.Uint = 0;
        ufu.Float = src;
        uint srcNotStolen = ufu.Uint & ~stolenMask;
 
        // Get the stolen bits of 'dest', which are the least-significant bits
        ufu.Uint = 0;
        ufu.Float = dest;
        uint destStolen = ufu.Uint & stolenMask;
 
        // Combine them
        ufu.Uint = srcNotStolen | destStolen;
        return ufu.Float;
    }
}